#!/usr/bin/env python3
import argparse
import gzip
import subprocess
from concurrent.futures import FIRST_COMPLETED, ProcessPoolExecutor, wait
from pathlib import Path


DEFAULT_WORKERS = 32
DEFAULT_CHUNK_MB = 32


def gzip_chunk(data: bytes, compresslevel: int) -> bytes:
    return gzip.compress(data, compresslevel=compresslevel, mtime=0)


def stream_tar_gz_parallel(
    input_dir: Path,
    output_file: Path,
    workers: int,
    chunk_size: int,
    compresslevel: int,
) -> None:
    tar_cmd = ["tar", "-cf", "-", "-C", str(input_dir.parent), input_dir.name]
    tar_proc = subprocess.Popen(tar_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    if tar_proc.stdout is None or tar_proc.stderr is None:
        raise RuntimeError("Failed to start tar process")

    pending = {}
    completed = {}
    next_index = 0
    next_to_write = 0
    max_in_flight = max(workers * 2, 1)

    with output_file.open("wb") as out_f, ProcessPoolExecutor(max_workers=workers) as executor:
        try:
            while True:
                while len(pending) < max_in_flight:
                    chunk = tar_proc.stdout.read(chunk_size)
                    if not chunk:
                        break
                    future = executor.submit(gzip_chunk, chunk, compresslevel)
                    pending[future] = next_index
                    next_index += 1

                if not pending:
                    break

                done, _ = wait(pending, return_when=FIRST_COMPLETED)
                for future in done:
                    completed[pending.pop(future)] = future.result()

                while next_to_write in completed:
                    out_f.write(completed.pop(next_to_write))
                    next_to_write += 1
        finally:
            tar_proc.stdout.close()

        stderr = tar_proc.stderr.read().decode("utf-8", errors="replace").strip()
        tar_proc.stderr.close()
        return_code = tar_proc.wait()
        if return_code != 0:
            raise RuntimeError(f"tar failed with exit code {return_code}: {stderr}")


def main() -> None:
    parser = argparse.ArgumentParser(description="Compress a directory into tar.gz with parallel gzip workers.")
    parser.add_argument("--input-dir", required=True, help="Directory to compress.")
    parser.add_argument("--output", required=True, help="Output tar.gz file path.")
    parser.add_argument("--workers", type=int, default=DEFAULT_WORKERS, help="Number of gzip worker processes.")
    parser.add_argument("--chunk-mb", type=int, default=DEFAULT_CHUNK_MB, help="Chunk size in MB.")
    parser.add_argument("--compresslevel", type=int, default=6, help="Gzip level from 0 to 9.")
    args = parser.parse_args()

    input_dir = Path(args.input_dir).resolve()
    output_file = Path(args.output).resolve()

    if not input_dir.exists():
        raise FileNotFoundError(f"Input directory not found: {input_dir}")
    if not input_dir.is_dir():
        raise NotADirectoryError(f"Input path is not a directory: {input_dir}")

    output_file.parent.mkdir(parents=True, exist_ok=True)
    stream_tar_gz_parallel(
        input_dir=input_dir,
        output_file=output_file,
        workers=args.workers,
        chunk_size=args.chunk_mb * 1024 * 1024,
        compresslevel=args.compresslevel,
    )
    print(f"Created archive: {output_file}")


if __name__ == "__main__":
    main()