#!/usr/bin/env python3
"""統合ASR CLI。

ASR固有の処理は ``tkasr_*.py`` に分離し、このモジュールは入力分割、
再開、出力、LLM校正の呼出しだけを担当する。

:doc:`transcribe2_usage`
"""

from __future__ import annotations

import argparse
import glob
import importlib
import json
import math
import tempfile
import time
from pathlib import Path
from typing import Any

from tkasr_common import (
    ASRResult,
    OptionalDependencyError,
    Segment,
    audio_duration,
    extract_wav,
    ffmpeg_commands,
    save_json,
    write_outputs,
)


LANGUAGE_NAMES = {"ja": "Japanese", "en": "English", "zh": "Chinese", "ko": "Korean"}
BACKEND_MODULES = {
    "qwen-api": "tkasr_qwen_api",
    "qwen-local": "tkasr_qwen_local",
    "whisper": "tkasr_whisper",
}


def normalize_language(value: str) -> str | None:
    """短縮言語名をASRバックエンド用の名称に変換する。

    :param value: (str) 言語名（例: "ja", "en", "auto"）。
    :returns: (str | None) 正規化された言語名。認識できない場合や "auto" の場合は None。
    """
    value = value.strip()
    return None if not value or value.lower() == "auto" else LANGUAGE_NAMES.get(value.lower(), value)


def make_boundary_text(chunks: list[dict[str, Any]], overlap_seconds: float) -> str:
    """LLM校正のため、各ASRチャンクと重複区間を明示した文字列を作る。

    生成される文字列は、各ASRチャンクの開始・終了時刻と、チャンク間の重複区間を示すマーカーを含みます。
    これにより、LLMは元の音声における文脈や区切りを理解しやすくなります。
    マーカーの例::

        [[ASR_CHUNK 0001 START=0.0s END=240.0s]]
        最初のチャンクのテキスト
        [[/ASR_CHUNK 0001]]
        [[ASR_BOUNDARY 0001|0002 OVERLAP=10.0s]]
        [[ASR_CHUNK 0002 START=230.0s END=470.0s]]
        次のチャンクのテキスト
        [[/ASR_CHUNK 0002]]

    :param chunks: (list[dict[str, Any]]) ASR結果のチャンクのリスト。各チャンクは `index`, `start`, `end`, `text` などのキーを持つ。
    :param overlap_seconds: (float) チャンク間の重複秒数。
    :returns: (str) LLM校正用の境界情報を含むテキスト。
    """
    lines: list[str] = []
    for position, chunk in enumerate(chunks):
        number = int(chunk["index"]) + 1
        if position:
            lines.append(
                f"[[ASR_BOUNDARY {number - 1:04d}|{number:04d} "
                f"OVERLAP={overlap_seconds:.1f}s]]"
            )
        lines.extend(
            [
                f"[[ASR_CHUNK {number:04d} START={chunk['start']:.1f}s "
                f"END={chunk['end']:.1f}s]]",
                str(chunk["text"]).strip(),
                f"[[/ASR_CHUNK {number:04d}]]",
            ]
        )
    return "\n".join(line for line in lines if line)


def remove_asr_markers(text: str) -> str:
    """最終的なASR原文から、LLM用のチャンク管理行だけを取り除く。

    ``[[ASR_...]]`` で始まる行と ``[[/ASR_...]]`` で始まる行を削除します。

    :param text: (str) ASR結果とLLM校正用のマーカーを含むテキスト。
    :returns: (str) マーカーが除去されたクリーンなテキスト。
    """
    return "\n".join(
        line
        for line in text.splitlines()
        if not line.startswith("[[ASR_") and not line.startswith("[[/ASR_")
    ).strip()


def create_backend(args: argparse.Namespace):
    """選択されたASRバックエンドだけを遅延 import して生成する。

    指定されたバックエンド名に基づいて、対応するモジュールを動的にインポートし、
    そのモジュール内の `Backend` クラスのインスタンスを生成して返します。

    :param args: (argparse.Namespace) コマンドライン引数を格納する名前空間オブジェクト。`args.backend` に使用するバックエンド名が含まれる。
    :returns: (Any) 選択されたASRバックエンドのインスタンス。
    """
    module = importlib.import_module(BACKEND_MODULES[args.backend])
    return module.Backend(args)


def load_checkpoint(
    checkpoint_path: Path,
    source: Path,
    args: argparse.Namespace,
    initial_state: dict[str, Any],
) -> dict[str, Any]:
    """--resume 時に、同じ入力ファイルのチェックポイントだけを復元する。

    チェックポイントファイルが存在し、かつ `--resume` オプションが指定されている場合に、
    その内容を読み込み、状態を復元します。
    ただし、復元するチェックポイントが現在の入力ファイルと異なる場合はエラーとします。

    :param checkpoint_path: (Path) チェックポイントファイルのパス。
    :param source: (Path) 現在処理中の入力ファイルのパス。
    :param args: (argparse.Namespace) コマンドライン引数を格納する名前空間オブジェクト。`args.resume` オプションの有無をチェックする。
    :param initial_state: (dict[str, Any]) チェックポイントが存在しない場合に返される初期状態。
    :returns: (dict[str, Any]) 復元された、または初期状態の辞書。
    :raises RuntimeError: チェックポイントの入力ファイルが現在処理中のファイルと異なる場合。
    """
    if not args.resume or not checkpoint_path.exists():
        return initial_state

    state = json.loads(checkpoint_path.read_text(encoding="utf-8"))
    if Path(state.get("source", "")).resolve() != source:
        raise RuntimeError("チェックポイントの入力ファイルが異なります。")

    print(f"再開: {len(state['segments'])} チャンク完了")
    return state


def make_timestamp_segments(chunks: list[dict[str, Any]]) -> list[Segment]:
    """チャンク内の相対時刻を、入力ファイル全体での絶対時刻へ変換する。

    各ASRチャンクは自身の開始時刻を基準とした相対的なセグメント情報を持つ可能性があります。
    この関数は、これらの相対時刻を、元の入力音声ファイル全体における絶対時刻に変換し、
    単一の `Segment` オブジェクトのリストとして結合します。

    :param chunks: (list[dict[str, Any]]) ASR結果のチャンクのリスト。各チャンクは `start` と `asr_segments` のキーを持つ。
    :returns: (list[Segment]) 入力ファイル全体の絶対時刻に対応するセグメントのリスト。
    """
    segments: list[Segment] = []
    for chunk in chunks:
        rows = chunk["asr_segments"] or [
            {"start": 0.0, "end": chunk["end"] - chunk["start"], "text": chunk["text"]}
        ]
        for row in rows:
            segments.append(
                Segment(
                    start=None if row["start"] is None else row["start"] + chunk["start"],
                    end=None if row["end"] is None else row["end"] + chunk["start"],
                    text=row["text"],
                )
            )
    return segments


def process_file(source: Path, args: argparse.Namespace, ffmpeg: str, ffprobe: str) -> None:
    """1入力ファイルをASRし、必要ならLLM校正して出力する。

    この関数は、単一の音声/動画ファイルを受け取り、以下の処理を実行します。

    1. 音声ファイルを指定されたチャンクサイズとオーバーラップで分割。
    2. 各チャンクに対してASRバックエンドを呼び出し、文字起こしを実行。
    3. `--resume` オプションが指定されている場合は、中断箇所から処理を再開。
    4. 中間結果をチェックポイントファイルに保存。
    5. 全てのチャンクの処理が完了したら、必要に応じてLLMによる校正を実施。
    6. 最終的な文字起こし結果とメタデータを出力ファイルに書き込み。

    :param source: (Path) 処理対象の音声・動画ファイルのパス。
    :param args: (argparse.Namespace) コマンドライン引数を格納する名前空間オブジェクト。
    :param ffmpeg: (str) ffmpeg実行ファイルのパス。
    :param ffprobe: (str) ffprobe実行ファイルのパス。
    :returns: (None)
    :raises RuntimeError: チェックポイントのチャンク数が入力条件と一致しない場合。
    """
    output_path = (args.output or source.with_suffix(".asr.txt")).resolve()
    checkpoint_path = output_path.with_suffix(output_path.suffix + ".partial.json")

    total_seconds = audio_duration(source, ffprobe)
    step_seconds = args.chunk_seconds - args.overlap_seconds
    starts = [
        index * step_seconds
        for index in range(math.ceil(total_seconds / step_seconds))
        if index * step_seconds < total_seconds - 0.01
    ]

    engine = create_backend(args)
    engine.load()

    initial_state = {
        "source": str(source),
        "duration_seconds": total_seconds,
        "backend": engine.describe(),
        "chunk_seconds": args.chunk_seconds,
        "overlap_seconds": args.overlap_seconds,
        "segments": [],
    }
    state = load_checkpoint(checkpoint_path, source, args, initial_state)
    completed_count = len(state["segments"])
    if completed_count > len(starts):
        raise RuntimeError("チェックポイントのチャンク数が入力条件と一致しません。")

    with tempfile.TemporaryDirectory(prefix="tkasr-") as temporary_dir:
        for index, start in enumerate(starts[completed_count:], start=completed_count):
            length = min(args.chunk_seconds, total_seconds - start)
            wav_path = Path(temporary_dir) / f"chunk_{index:04d}.wav"
            extract_wav(source, start, length, wav_path, ffmpeg)

            began = time.monotonic()
            result = engine.transcribe(wav_path, normalize_language(args.lang), args.context)
            elapsed = time.monotonic() - began

            state["segments"].append(
                {
                    "index": index,
                    "start": start,
                    "end": start + length,
                    "text": result.text,
                    "language": result.language,
                    "elapsed_seconds": elapsed,
                    "metadata": result.metadata,
                    "asr_segments": [
                        {"start": segment.start, "end": segment.end, "text": segment.text}
                        for segment in result.segments
                    ],
                }
            )
            save_json(checkpoint_path, state)
            print(
                f"[{index + 1}/{len(starts)}] {start:.1f}-{start + length:.1f}s "
                f"({elapsed:.1f}s): {result.text[:100]}",
                flush=True,
            )

    marked_text = make_boundary_text(state["segments"], args.overlap_seconds)
    raw_result = ASRResult(
        text=remove_asr_markers(marked_text),
        segments=make_timestamp_segments(state["segments"]),
    )

    corrected_text = None
    if not args.no_correct:
        from tkasr_llm import correct

        corrected_text = correct(
            marked_text,
            config=args.llm_config,
            provider=args.llm_provider,
            model=args.llm_model,
            context=args.context,
            max_tokens=args.llm_max_tokens,
            maximum_chars=args.correction_chars,
        )

    write_outputs(output_path, raw_result, {**state, "output": str(output_path)}, corrected_text)


def build_parser() -> argparse.ArgumentParser:
    """コマンドライン引数パーサーを構築する。

    ASR処理とLLM校正に関連する様々なオプションを含む `ArgumentParser` オブジェクトを生成します。
    引数は、バックエンド、API設定、共通の音声処理、LLM校正、ローカルQwen設定、Whisper設定など、
    機能ごとにグループ化されています。

    :returns: (argparse.ArgumentParser) 設定済みの `ArgumentParser` オブジェクト。
    """
    parser = argparse.ArgumentParser(
        description="Qwen3-ASR API / local Qwen3-ASR / Whisper 統合文字起こし"
    )
    parser.add_argument("input", help="音声・動画ファイル（glob可）")
    parser.add_argument("--backend", choices=BACKEND_MODULES, default="qwen-api")
    parser.add_argument("-m", "--model", default="Qwen/Qwen3-ASR-1.7B")
    parser.add_argument("-l", "--lang", default="ja")
    parser.add_argument("--output", type=Path)

    api = parser.add_argument_group("Qwen ASR API")
    api.add_argument("--api-base", default="http://192.168.27.18:8001/v1")
    api.add_argument("--timeout", type=float, default=1800)

    common = parser.add_argument_group("共通の音声処理")
    common.add_argument("--ffmpeg-dir", type=Path)
    common.add_argument("--chunk-seconds", type=float, default=240)
    common.add_argument("--overlap-seconds", type=float, default=10)
    common.add_argument("--resume", action="store_true")
    common.add_argument("--context", "--prompt", dest="context", default="")

    llm = parser.add_argument_group("LLM校正（tkai_lib_litellm.py）")
    llm.add_argument("--no-correct", action="store_true")
    llm.add_argument("--llm-config", default="ai.env")
    llm.add_argument("--llm-provider", default="lmstudio")
    llm.add_argument("--llm-model", default="openai/gpt-oss-20b")
    llm.add_argument("--llm-max-tokens", type=int, default=16384)
    llm.add_argument("--correction-chars", type=int, default=4000)

    local_qwen = parser.add_argument_group("ローカル Qwen3-ASR")
    local_qwen.add_argument("-d", "--device", default="auto")
    local_qwen.add_argument("--dtype", choices=["auto", "bfloat16", "float16", "float32"], default="auto")
    local_qwen.add_argument("--timestamps", type=int, choices=[0, 1], default=1)
    local_qwen.add_argument("--aligner", default="Qwen/Qwen3-ForcedAligner-0.6B")
    local_qwen.add_argument("--attention", choices=["auto", "sdpa", "eager", "flash_attention_2"], default="auto")
    local_qwen.add_argument("--max-inference-batch-size", type=int, default=1)
    local_qwen.add_argument("--max-new-tokens", type=int, default=4096)

    whisper = parser.add_argument_group("Whisper")
    whisper.add_argument("--beam-size", type=int, default=5)
    whisper.add_argument("--temperature", default="0,0.2,0.4,0.6")
    whisper.add_argument("--compression-ratio-threshold", type=float, default=2.4)
    whisper.add_argument("--log-prob-threshold", type=float, default=-1.0)
    whisper.add_argument("--no-speech-threshold", type=float, default=0.6)

    return parser


def main() -> int:
    """スクリプトのエントリポイント。

    コマンドライン引数を解析し、入力ファイルを glob 展開して、
    それぞれのファイルに対して文字起こしと校正の処理 (`process_file`) を実行します。
    引数の検証もここで行われます。

    :returns: (int) 成功時には 0、エラー時には 1 を返すシステム終了コード。
    :raises SystemExit: 処理中にエラーが発生した場合、またはユーザーによって中断された場合。
    :raises RuntimeError: 入力ファイルが見つからない、複数入力時に --output が指定された、または引数の値が不正な場合。
    """
    args = build_parser().parse_args()

    print("\n=== 入力パラメータ ===")
    for name, value in vars(args).items():
        print(f"{name} = {value}")
    print("======================\n")

    files = [Path(path).resolve() for path in sorted(glob.glob(args.input))]

    if not files:
        raise RuntimeError(f"入力ファイルがありません: {args.input}")
    if len(files) > 1 and args.output:
        raise RuntimeError("複数入力時は --output を指定できません。")
    if args.chunk_seconds <= 0:
        raise RuntimeError("--chunk-seconds は正の値にしてください。")
    if not 0 <= args.overlap_seconds < args.chunk_seconds:
        raise RuntimeError("--overlap-seconds は0以上かつ --chunk-seconds 未満にしてください。")

    ffmpeg, ffprobe = ffmpeg_commands(args.ffmpeg_dir)
    for source in files:
        process_file(source, args, ffmpeg, ffprobe)
    return 0


if __name__ == "__main__":
    try:
        raise SystemExit(main())
    except KeyboardInterrupt:
        print("\n中断しました。--resume で再開できます。")
        raise SystemExit(130)
    except (RuntimeError, OptionalDependencyError) as exc:
        print(f"エラー: {exc}")
        raise SystemExit(1)