"""Legacy CLI: sketch + fabric for EquiFashion_DB train/test layout. Core logic: equifashion_pipeline.sketch_fabric."""

from __future__ import annotations

import argparse
import json
import os
import sys
from concurrent.futures import ProcessPoolExecutor, as_completed
from pathlib import Path
from typing import Optional, Tuple

from tqdm import tqdm

from EquiFashionDB_pipeline import sketch_fabric as sf


def _default_workers() -> int:
    return max(1, (os.cpu_count() or 4) - 1)


def process_one(
    gt_name: str,
    image_root: Path,
    out_sketch: Path,
    out_fabric: Path,
    fabric_patch: int,
) -> Tuple[str, Optional[str]]:
    stem = Path(gt_name).stem
    img_path = image_root / gt_name
    if not img_path.is_file():
        return gt_name, f"missing image: {img_path}"
    return sf.process_one_sample(img_path, out_sketch, out_fabric, stem, fabric_patch)


def _worker(
    job: Tuple[str, Path, Path, Path, int],
) -> Tuple[str, Optional[str]]:
    return process_one(*job)


def load_gt_list(manifest: Path) -> list[str]:
    with open(manifest, encoding="utf-8") as f:
        data = json.load(f)
    out = []
    for row in data:
        if isinstance(row, dict) and "gt" in row:
            out.append(row["gt"])
        elif isinstance(row, str):
            out.append(row)
    return out


def main() -> None:
    p = argparse.ArgumentParser(description="Sketch + fabric enrichment for EquiFashion-DB")
    p.add_argument(
        "--db-root",
        type=Path,
        default=Path(__file__).resolve().parent / "EquiFashion_DB",
        help="Folder containing train/, test/, train_pose/",
    )
    p.add_argument("--split", choices=("train", "test", "all"), default="train")
    p.add_argument("--workers", type=int, default=_default_workers())
    p.add_argument("--fabric-patch", type=int, default=128, help="Fabric patch side length (pixels)")
    p.add_argument("--limit", type=int, default=0, help="If >0, only process first N items per split (debug)")
    args = p.parse_args()

    root: Path = args.db_root
    jobs: list[Tuple[str, Path, Path, Path, int]] = []

    def enqueue(split: str) -> None:
        manifest = root / f"{split}.json"
        image_root = root / split
        out_sketch = root / f"{split}_sketch"
        out_fabric = root / f"{split}_fabric"
        gts = load_gt_list(manifest)
        for i, gt in enumerate(gts):
            if args.limit and i >= args.limit:
                break
            jobs.append((gt, image_root, out_sketch, out_fabric, args.fabric_patch))

    if args.split in ("train", "all"):
        enqueue("train")
    if args.split in ("test", "all"):
        enqueue("test")

    if not jobs:
        print("No jobs.", file=sys.stderr)
        sys.exit(1)

    errs: list[Tuple[str, str]] = []
    if args.workers <= 1:
        for job in tqdm(jobs, desc="enrich"):
            name, err = process_one(*job)
            if err:
                errs.append((name, err))
    else:
        with ProcessPoolExecutor(max_workers=args.workers) as ex:
            futs = {ex.submit(_worker, job): job[0] for job in jobs}
            for fut in tqdm(as_completed(futs), total=len(futs), desc="enrich"):
                name, err = fut.result()
                if err:
                    errs.append((name, err))

    if errs:
        err_path = root / "enrich_sketch_fabric_errors.txt"
        with open(err_path, "w", encoding="utf-8") as f:
            for name, msg in errs:
                f.write(f"{name}\t{msg}\n")
        print(f"Done with {len(errs)} errors logged to {err_path}")
    else:
        print("Done. No errors.")


if __name__ == "__main__":
    main()