"""argparse-based CLI.

Commands::

    video2dataset process    ./videos      # full pipeline
    video2dataset transcribe ./audio       # transcripts only -> JSONL
    video2dataset segment    ./audio       # cut clips from sidecar transcripts
    video2dataset features   ./dataset     # build features/train.{bin,dat}
    video2dataset train      ./dataset     # launch wav2vec2 training

Global options (``--config``, ``--device``, ``--whisper-model``, ``--language``,
``--output-dir``, ``--verbose``) override the YAML configuration.
"""

from __future__ import annotations

import argparse
import sys
from pathlib import Path
from typing import Optional, Sequence

from video_vec2wav2_tokenizer import __version__
from video_vec2wav2_tokenizer.utils.config import Config, load_config
from video_vec2wav2_tokenizer.utils.io import Segment, ensure_dir, read_jsonl, write_jsonl
from video_vec2wav2_tokenizer.utils.logging import get_logger, setup_logging

logger = get_logger(__name__)


# --------------------------------------------------------------------------- #
# Parser
# --------------------------------------------------------------------------- #
def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="video2dataset",
        description="Convert videos into ASR/TTS training datasets.",
    )
    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")

    # Shared options applied to every subcommand.
    common = argparse.ArgumentParser(add_help=False)
    common.add_argument("--config", type=str, default=None, help="Path to config.yaml")
    common.add_argument("--output-dir", type=str, default=None, help="Output directory")
    common.add_argument("--device", choices=["auto", "cpu", "cuda"], default=None)
    common.add_argument("--whisper-model", type=str, default=None)
    common.add_argument("--language", type=str, default=None, help="ISO code or 'auto'")
    common.add_argument("-v", "--verbose", action="store_true", help="Debug logging")

    sub = parser.add_subparsers(dest="command", required=True)

    p_process = sub.add_parser("process", parents=[common], help="Run the full pipeline")
    p_process.add_argument("input", help="Directory of input videos")
    p_process.add_argument(
        "--extract-features", action="store_true", help="Also build feature store"
    )
    p_process.set_defaults(func=cmd_process)

    p_tr = sub.add_parser("transcribe", parents=[common], help="Transcribe audio only")
    p_tr.add_argument("input", help="Directory of audio (.wav) files")
    p_tr.set_defaults(func=cmd_transcribe)

    p_seg = sub.add_parser("segment", parents=[common], help="Cut clips from transcripts")
    p_seg.add_argument("input", help="Directory of audio with sidecar .json transcripts")
    p_seg.set_defaults(func=cmd_segment)

    p_feat = sub.add_parser("features", parents=[common], help="Extract features")
    p_feat.add_argument("input", help="Dataset directory containing audio/")
    p_feat.set_defaults(func=cmd_features)

    p_train = sub.add_parser("train", parents=[common], help="Train wav2vec2 CTC model")
    p_train.add_argument("input", help="Dataset directory")
    p_train.add_argument("--epochs", type=int, default=None)
    p_train.add_argument("--batch-size", type=int, default=None)
    p_train.add_argument("--resume", action="store_true", help="Resume from checkpoint")
    p_train.set_defaults(func=cmd_train)

    return parser


def _config_from_args(args: argparse.Namespace) -> Config:
    overrides: dict[str, object] = {}
    if getattr(args, "output_dir", None):
        overrides["output_dir"] = args.output_dir
    if getattr(args, "device", None):
        overrides["device"] = args.device
    if getattr(args, "whisper_model", None):
        overrides["whisper_model"] = args.whisper_model
    if getattr(args, "language", None) and args.language != "auto":
        overrides["language"] = args.language
    return load_config(args.config, overrides=overrides)


# --------------------------------------------------------------------------- #
# Commands
# --------------------------------------------------------------------------- #
def cmd_process(args: argparse.Namespace) -> int:
    from video_vec2wav2_tokenizer.pipeline import Pipeline

    cfg = _config_from_args(args)
    Pipeline(cfg).run(args.input, extract_features=args.extract_features)
    return 0


def cmd_transcribe(args: argparse.Namespace) -> int:
    from video_vec2wav2_tokenizer.transcription.transcriber import Transcriber

    cfg = _config_from_args(args)
    transcriber = Transcriber.from_config(cfg)
    out_dir = ensure_dir(Path(cfg.output_dir) / "transcripts")

    audio_files = sorted(Path(args.input).rglob("*.wav"))
    if not audio_files:
        logger.warning("No .wav files found under %s", args.input)
        return 1

    from tqdm import tqdm

    for audio in tqdm(audio_files, desc="transcribe", unit="file"):
        result = transcriber.transcribe(audio)
        write_jsonl(
            out_dir / f"{audio.stem}.jsonl",
            (s.to_dict() for s in result.segments),
        )
    logger.info("Wrote transcripts to %s", out_dir)
    return 0


def cmd_segment(args: argparse.Namespace) -> int:
    from video_vec2wav2_tokenizer.segmentation.segmenter import Segmenter, normalize_segments

    cfg = _config_from_args(args)
    segmenter = Segmenter(sample_rate=cfg.sample_rate)
    audio_dir = ensure_dir(cfg.audio_dir)

    audio_files = sorted(Path(args.input).rglob("*.wav"))
    clip_index = 1
    for audio in audio_files:
        transcript = audio.with_suffix(".json")
        if not transcript.exists():
            transcript = audio.with_suffix(".jsonl")
        if not transcript.exists():
            logger.warning("No transcript for %s, skipping", audio.name)
            continue
        segments = [Segment.from_dict(r) for r in read_jsonl(transcript)]
        segments = normalize_segments(
            segments,
            min_length=cfg.min_segment_length,
            max_length=cfg.max_segment_length,
            padding=cfg.segment_padding,
        )
        clips = segmenter.segment_file(audio, segments, audio_dir, start_index=clip_index)
        clip_index += len(clips)
    logger.info("Wrote clips to %s", audio_dir)
    return 0


def cmd_features(args: argparse.Namespace) -> int:
    from video_vec2wav2_tokenizer.features.extractor import FeatureExtractor

    cfg = _config_from_args(args)
    audio_dir = Path(args.input) / "audio"
    if not audio_dir.exists():
        audio_dir = Path(args.input)
    clip_paths = sorted(audio_dir.rglob("*.wav"))
    if not clip_paths:
        logger.warning("No .wav clips found under %s", audio_dir)
        return 1
    fx = FeatureExtractor(sample_rate=cfg.sample_rate)
    fx.extract_dataset(clip_paths, cfg.features_dir)
    return 0


def cmd_train(args: argparse.Namespace) -> int:
    from video_vec2wav2_tokenizer.training.train_wav2vec2 import TrainingArguments, train

    cfg = _config_from_args(args)
    targs = TrainingArguments(
        dataset_dir=Path(args.input),
        model_name=cfg.model_name,
        output_dir=Path(cfg.output_dir) / "checkpoints",
        resume=args.resume,
    )
    if args.epochs is not None:
        targs.num_epochs = args.epochs
    if args.batch_size is not None:
        targs.batch_size = args.batch_size
    train(targs)
    return 0


def main(argv: Optional[Sequence[str]] = None) -> int:
    parser = build_parser()
    args = parser.parse_args(argv)
    setup_logging("DEBUG" if getattr(args, "verbose", False) else "INFO")
    try:
        return int(args.func(args))
    except KeyboardInterrupt:  # pragma: no cover
        logger.error("Interrupted by user")
        return 130
    except Exception as exc:  # pragma: no cover - top-level guard
        logger.exception("Command failed: %s", exc)
        return 1


if __name__ == "__main__":  # pragma: no cover
    sys.exit(main())