#!/usr/bin/env python3
from __future__ import annotations

import argparse
import inspect
import json
import os
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Any

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))

from romani_asr.env import configure_certifi  # noqa: E402
from romani_asr.manifest import read_manifest_csv  # noqa: E402
from romani_asr.metrics import compute_asr_metrics  # noqa: E402
from romani_asr.mms import build_ctc_vocab, normalize_for_mms_ctc  # noqa: E402


@dataclass
class DataCollatorCTCWithPadding:
    processor: Any
    padding: bool | str = True

    def __call__(self, features: list[dict[str, Any]]) -> dict[str, Any]:
        input_features = [{"input_values": feature["input_values"]} for feature in features]
        label_features = [{"input_ids": feature["labels"]} for feature in features]

        batch = self.processor.pad(
            input_features,
            padding=self.padding,
            return_tensors="pt",
        )
        labels_batch = self.processor.pad(
            labels=label_features,
            padding=self.padding,
            return_tensors="pt",
        )
        labels = labels_batch["input_ids"].masked_fill(
            labels_batch.attention_mask.ne(1),
            -100,
        )
        batch["labels"] = labels
        return batch


class AdapterCheckpointCallback:
    def __init__(
        self,
        output_dir: Path,
        target_lang: str,
        processor: Any,
        save_adapter_steps: int,
    ) -> None:
        self.output_dir = output_dir
        self.target_lang = target_lang
        self.processor = processor
        self.save_adapter_steps = save_adapter_steps
        self.best_cer: float | None = None

    def _save(
        self,
        model: Any,
        output_dir: Path,
        metrics: dict[str, Any] | None = None,
    ) -> None:
        adapter_path = save_adapter(model, output_dir, self.target_lang)
        self.processor.save_pretrained(str(output_dir / "processor"))
        payload = {
            "adapter_path": str(adapter_path),
            "target_lang": self.target_lang,
        }
        if metrics is not None:
            payload["metrics"] = metrics
        (output_dir / "adapter_summary.json").write_text(
            json.dumps(payload, indent=2, ensure_ascii=False, default=str),
            encoding="utf-8",
        )

    def on_step_end(
        self,
        args: Any,
        state: Any,
        control: Any,
        model: Any | None = None,
        **_: Any,
    ) -> Any:
        if (
            model is not None
            and self.save_adapter_steps > 0
            and state.global_step > 0
            and state.global_step % self.save_adapter_steps == 0
        ):
            self._save(
                model=model,
                output_dir=self.output_dir / f"adapter-step-{state.global_step}",
            )
        return control

    def on_evaluate(
        self,
        args: Any,
        state: Any,
        control: Any,
        metrics: dict[str, Any] | None = None,
        model: Any | None = None,
        **_: Any,
    ) -> Any:
        if model is None or not metrics:
            return control
        cer = metrics.get("eval_cer")
        if not isinstance(cer, (int, float)):
            return control
        if self.best_cer is None or cer < self.best_cer:
            self.best_cer = float(cer)
            self._save(
                model=model,
                output_dir=self.output_dir / "best_adapter",
                metrics=metrics,
            )
        return control


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Fine-tune MMS-1B-All adapters for Romani ASR.")
    parser.add_argument("--model-id", default="facebook/mms-1b-all")
    parser.add_argument("--target-lang", default="rmc-script_latin")
    parser.add_argument(
        "--train-manifest",
        type=Path,
        default=Path("artifacts/manifests/clean/train_clean.csv"),
    )
    parser.add_argument(
        "--validation-manifest",
        type=Path,
        default=Path("artifacts/manifests/clean/validation_clean.csv"),
    )
    parser.add_argument(
        "--output-dir",
        type=Path,
        default=Path("artifacts/models/mms-1b-all-romani-adapter"),
    )
    parser.add_argument("--sampling-rate", type=int, default=16000)
    parser.add_argument("--num-train-epochs", type=float, default=4.0)
    parser.add_argument("--max-steps", type=int, default=0)
    parser.add_argument("--per-device-train-batch-size", type=int, default=1)
    parser.add_argument("--per-device-eval-batch-size", type=int, default=1)
    parser.add_argument("--gradient-accumulation-steps", type=int, default=8)
    parser.add_argument("--learning-rate", type=float, default=1e-3)
    parser.add_argument("--warmup-steps", type=int, default=25)
    parser.add_argument("--eval-steps", type=int, default=50)
    parser.add_argument("--logging-steps", type=int, default=10)
    parser.add_argument("--save-adapter-steps", type=int, default=100)
    parser.add_argument("--gradient-checkpointing", action="store_true")
    parser.add_argument(
        "--mixed-precision",
        choices=("auto", "fp16", "bf16", "no"),
        default="auto",
    )
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--dataloader-num-workers", type=int, default=2)
    parser.add_argument("--no-group-by-length", action="store_true")
    parser.add_argument("--train-limit", type=int, default=0)
    parser.add_argument("--validation-limit", type=int, default=0)
    parser.add_argument("--num-proc", type=int, default=1)
    parser.add_argument(
        "--no-reinit-adapters",
        action="store_true",
        help="Continue from the model's target adapter instead of reinitializing adapters.",
    )
    return parser.parse_args()


def load_manifest_dataset(args: argparse.Namespace):
    from datasets import Audio, load_dataset

    dataset = load_dataset(
        "csv",
        data_files={
            "train": str(args.train_manifest),
            "validation": str(args.validation_manifest),
        },
    )
    dataset = dataset.rename_column("audio_path", "audio")
    dataset = dataset.map(
        lambda batch: {
            "audio": [
                {
                    "path": str((Path.cwd() / path).resolve())
                    if not Path(path).is_absolute()
                    else path,
                    "bytes": None,
                }
                for path in batch["audio"]
            ],
            "ctc_text": [normalize_for_mms_ctc(text) for text in batch["transcript"]],
        },
        batched=True,
    )
    return dataset.cast_column("audio", Audio(sampling_rate=args.sampling_rate))


def build_processor(args: argparse.Namespace):
    from transformers import (
        Wav2Vec2CTCTokenizer,
        Wav2Vec2FeatureExtractor,
        Wav2Vec2Processor,
    )

    train_rows = read_manifest_csv(args.train_manifest)
    validation_rows = read_manifest_csv(args.validation_manifest)
    vocab = build_ctc_vocab(
        [row["transcript"] for row in [*train_rows, *validation_rows]]
    )
    processor_dir = args.output_dir / "processor"
    processor_dir.mkdir(parents=True, exist_ok=True)
    (processor_dir / "vocab.json").write_text(
        json.dumps({args.target_lang: vocab}, indent=2, ensure_ascii=False),
        encoding="utf-8",
    )
    tokenizer = Wav2Vec2CTCTokenizer.from_pretrained(
        str(processor_dir),
        unk_token="[UNK]",
        pad_token="[PAD]",
        word_delimiter_token="|",
        target_lang=args.target_lang,
    )
    feature_extractor = Wav2Vec2FeatureExtractor(
        feature_size=1,
        sampling_rate=args.sampling_rate,
        padding_value=0.0,
        do_normalize=True,
        return_attention_mask=True,
    )
    processor = Wav2Vec2Processor(
        feature_extractor=feature_extractor,
        tokenizer=tokenizer,
    )
    processor.save_pretrained(str(processor_dir))
    return processor


def mixed_precision_flags(args: argparse.Namespace) -> tuple[bool, bool]:
    import torch

    if args.mixed_precision == "no" or not torch.cuda.is_available():
        return False, False
    if args.mixed_precision == "fp16":
        return True, False
    if args.mixed_precision == "bf16":
        if not torch.cuda.is_bf16_supported():
            raise ValueError("Requested bf16, but this CUDA device does not support it.")
        return False, True
    if torch.cuda.is_bf16_supported():
        return False, True
    return True, False


def prepare_training_arguments(
    args: argparse.Namespace,
    use_fp16: bool,
    use_bf16: bool,
):
    from transformers import TrainingArguments

    kwargs: dict[str, Any] = {
        "output_dir": str(args.output_dir),
        "per_device_train_batch_size": args.per_device_train_batch_size,
        "per_device_eval_batch_size": args.per_device_eval_batch_size,
        "gradient_accumulation_steps": args.gradient_accumulation_steps,
        "learning_rate": args.learning_rate,
        "warmup_steps": args.warmup_steps,
        "num_train_epochs": args.num_train_epochs,
        "gradient_checkpointing": args.gradient_checkpointing,
        "fp16": use_fp16,
        "bf16": use_bf16,
        "eval_steps": args.eval_steps,
        "save_strategy": "no",
        "logging_steps": args.logging_steps,
        "report_to": [],
        "remove_unused_columns": False,
        "seed": args.seed,
        "data_seed": args.seed,
        "dataloader_num_workers": args.dataloader_num_workers,
        "group_by_length": not args.no_group_by_length,
        "length_column_name": "input_length",
    }
    if args.max_steps > 0:
        kwargs["max_steps"] = args.max_steps

    parameters = inspect.signature(TrainingArguments).parameters
    if "eval_strategy" in parameters:
        kwargs["eval_strategy"] = "steps"
    elif "evaluation_strategy" in parameters:
        kwargs["evaluation_strategy"] = "steps"
    filtered_kwargs = {
        key: value for key, value in kwargs.items() if key in parameters
    }
    return TrainingArguments(**filtered_kwargs)


def save_adapter(model: Any, output_dir: Path, target_lang: str) -> Path:
    from safetensors.torch import save_file as safe_save_file
    from transformers.models.wav2vec2.modeling_wav2vec2 import (
        WAV2VEC2_ADAPTER_SAFE_FILE,
    )

    output_dir.mkdir(parents=True, exist_ok=True)
    adapter_path = output_dir / WAV2VEC2_ADAPTER_SAFE_FILE.format(target_lang)
    safe_save_file(model._get_adapters(), str(adapter_path), metadata={"format": "pt"})
    return adapter_path


def main() -> None:
    args = parse_args()
    configure_certifi()
    os.environ.setdefault("PYTORCH_ENABLE_MPS_FALLBACK", "1")

    import numpy as np
    import torch
    from transformers import Trainer, Wav2Vec2ForCTC, set_seed

    set_seed(args.seed)
    processor = build_processor(args)
    dataset = load_manifest_dataset(args)
    if args.train_limit:
        dataset["train"] = dataset["train"].select(
            range(min(args.train_limit, len(dataset["train"])))
        )
    if args.validation_limit:
        dataset["validation"] = dataset["validation"].select(
            range(min(args.validation_limit, len(dataset["validation"])))
        )

    model = Wav2Vec2ForCTC.from_pretrained(
        args.model_id,
        target_lang=args.target_lang,
        attention_dropout=0.0,
        hidden_dropout=0.0,
        feat_proj_dropout=0.0,
        layerdrop=0.0,
        ctc_loss_reduction="mean",
        ctc_zero_infinity=True,
        pad_token_id=processor.tokenizer.pad_token_id,
        vocab_size=len(processor.tokenizer),
        ignore_mismatched_sizes=True,
    )
    if not args.no_reinit_adapters:
        model.init_adapter_layers()
    model.freeze_base_model()
    for parameter in model._get_adapters().values():
        parameter.requires_grad = True

    def prepare_batch(batch: dict[str, Any]) -> dict[str, Any]:
        audio = batch["audio"]
        if isinstance(audio, dict):
            audio_array = audio["array"]
            sampling_rate = audio["sampling_rate"]
        else:
            samples = audio.get_all_samples()
            audio_tensor = samples.data
            if audio_tensor.ndim == 2:
                audio_tensor = audio_tensor.mean(dim=0)
            audio_array = audio_tensor.detach().cpu().numpy()
            sampling_rate = samples.sample_rate
        batch["input_values"] = processor(
            audio_array,
            sampling_rate=sampling_rate,
        ).input_values[0]
        batch["input_length"] = len(batch["input_values"])
        batch["labels"] = processor(text=batch["ctc_text"]).input_ids
        return batch

    remove_columns = dataset["train"].column_names
    dataset = dataset.map(
        prepare_batch,
        remove_columns=remove_columns,
        num_proc=args.num_proc,
    )

    data_collator = DataCollatorCTCWithPadding(processor=processor, padding=True)

    def compute_metrics(eval_prediction: Any) -> dict[str, float]:
        pred_logits = eval_prediction.predictions
        pred_ids = np.argmax(pred_logits, axis=-1)
        label_ids = eval_prediction.label_ids
        label_ids[label_ids == -100] = processor.tokenizer.pad_token_id
        pred_str = processor.batch_decode(pred_ids)
        label_str = processor.batch_decode(label_ids, group_tokens=False)
        metrics = compute_asr_metrics(label_str, pred_str, keep_diacritics=True)
        metrics_ascii = compute_asr_metrics(
            label_str,
            pred_str,
            keep_diacritics=False,
        )
        return {
            "wer": metrics["wer"],
            "cer": metrics["cer"],
            "wer_ascii": metrics_ascii["wer"],
            "cer_ascii": metrics_ascii["cer"],
        }

    use_fp16, use_bf16 = mixed_precision_flags(args)
    training_args = prepare_training_arguments(args, use_fp16, use_bf16)
    trainer_kwargs: dict[str, Any] = {
        "args": training_args,
        "model": model,
        "train_dataset": dataset["train"],
        "eval_dataset": dataset["validation"],
        "data_collator": data_collator,
        "compute_metrics": compute_metrics,
    }
    trainer_parameters = inspect.signature(Trainer).parameters
    if "processing_class" in trainer_parameters:
        trainer_kwargs["processing_class"] = processor.feature_extractor

    trainer = Trainer(**trainer_kwargs)
    trainer.add_callback(
        AdapterCheckpointCallback(
            output_dir=args.output_dir,
            target_lang=args.target_lang,
            processor=processor,
            save_adapter_steps=args.save_adapter_steps,
        )
    )
    trainer.train()
    eval_metrics = trainer.evaluate()
    adapter_path = save_adapter(model, args.output_dir, args.target_lang)
    processor.save_pretrained(str(args.output_dir / "processor"))
    (args.output_dir / "training_summary.json").write_text(
        json.dumps(
            {
                "model_id": args.model_id,
                "target_lang": args.target_lang,
                "train_manifest": str(args.train_manifest),
                "validation_manifest": str(args.validation_manifest),
                "adapter_path": str(adapter_path),
                "eval_metrics": eval_metrics,
                "settings": vars(args),
            },
            indent=2,
            ensure_ascii=False,
            default=str,
        ),
        encoding="utf-8",
    )
    print(f"Wrote adapter {adapter_path}", flush=True)


if __name__ == "__main__":
    main()