import csv
import json

from lyric_dedup import DuplicateChecker
from lyric_dedup import DuplicateDecision
from lyric_dedup import LyricRecord
from lyric_dedup.cli import evaluate_csv
from lyric_dedup.eval_dataset import generate_eval_set
from lyric_dedup.file_import import record_from_file
from lyric_dedup.normalization import normalize_lyrics


BASE_LYRIC = """
[00:01.00]作词：Someone
[00:02.00]我爱你在每个夜里
[00:03.00]听风说话也听见你
[00:04.00]城市的灯慢慢亮起
[00:05.00]我把回忆写进歌曲
[00:06.00]啦啦啦 我们不分离
[00:07.00]啦啦啦 我们不分离
[00:08.00]明天还会继续想你
"""


def test_normalization_removes_lyric_noise_and_simplifies() -> None:
    normalized = normalize_lyrics("[00:01.20]我愛你！\nQQ音乐 www.example.com\n(副歌)\n聽風說話\n")

    assert normalized.normalized_lines == ("我爱你", "听风说话")
    assert normalized.normalized_full_text == "我爱你\n听风说话"
    assert normalized.primary_lines == ("我爱你", "听风说话")


def test_exact_duplicate_handles_timestamps_punctuation_traditional_and_chorus_counts() -> None:
    checker = DuplicateChecker()
    checker.add_record(LyricRecord("song-1", BASE_LYRIC))

    result = checker.check(
        """
        我愛你，在每個夜裡！！！
        聽風說話，也聽見你
        城市的燈慢慢亮起
        我把回憶寫進歌曲
        啦啦啦 我們不分離
        明天還會繼續想你
        """
    )

    assert result.decision == DuplicateDecision.DUPLICATE
    assert result.confidence == 1.0
    assert result.candidates[0].record_id == "song-1"


def test_short_shared_repeated_chorus_is_review_not_duplicate() -> None:
    checker = DuplicateChecker()
    checker.add_record(
        LyricRecord(
            "song-1",
            """
            海边的风吹过旧信
            你说夏天不会远去
            啦啦啦 我们不分离
            啦啦啦 我们不分离
            转身以后各自旅行
            """,
        )
    )

    result = checker.check(
        """
        山谷的雨落在清晨
        我把名字交给星辰
        啦啦啦 我们不分离
        啦啦啦 我们不分离
        世界安静等一个人
        """
    )

    assert result.decision == DuplicateDecision.REVIEW
    assert result.candidates[0].reason == "重合内容主要集中在重复副歌行，不自动判重"


def test_substantial_line_overlap_is_duplicate_after_lsh_recall() -> None:
    checker = DuplicateChecker()
    checker.add_record(LyricRecord("song-1", BASE_LYRIC))

    result = checker.check(
        """
        我爱你在每个夜里
        听风说话也听见你
        城市灯火慢慢亮起
        我把回忆写进歌曲
        啦啦啦 我们不分离
        明天还会继续想你
        """
    )

    assert result.decision == DuplicateDecision.DUPLICATE
    assert result.candidates[0].jaccard >= 0.78
    assert result.candidates[0].line_coverage >= 0.72


def test_fragment_of_full_song_is_not_duplicate() -> None:
    checker = DuplicateChecker()
    checker.add_record(LyricRecord("song-1", BASE_LYRIC))

    result = checker.check(
        """
        听风说话也听见你
        城市的灯慢慢亮起
        我把回忆写进歌曲
        """
    )

    assert result.decision != DuplicateDecision.DUPLICATE
    assert result.candidates[0].primary_line_coverage < 0.72


def test_no_effective_lyrics_use_metadata_fallback_without_empty_hash_collision() -> None:
    placeholder = """
    作词：DJ金木
    作曲：DJ金木
    编曲：DJ金木
    混音：DJ金木
    【未经著作权人许可 不得翻唱 翻录或使用】
    """
    checker = DuplicateChecker()
    checker.add_record(LyricRecord("song-1", placeholder, title="Amnesia(House)", artist="DJ金木"))
    checker.add_record(LyricRecord("song-2", placeholder, title="Angel(纯音乐)", artist="DJ金木"))

    same_song = checker.check_record(
        LyricRecord("__query__", placeholder, title="Amnesia(House)", artist="DJ金木")
    )
    different_title = checker.check_record(
        LyricRecord("__query__", placeholder, title="Different Song", artist="DJ金木")
    )

    assert same_song.decision == DuplicateDecision.DUPLICATE
    assert same_song.reason == "无有效歌词，使用文件内容兜底指纹命中"
    assert different_title.decision == DuplicateDecision.DUPLICATE


def test_no_effective_lyrics_metadata_fallback_ignores_placeholder_noise() -> None:
    source = """
    作词：DJ金木
    作曲：DJ金木
    编曲：DJ金木
    混音：DJ金木
    【未经著作权人许可 不得翻唱 翻录或使用】
    """
    noisy = """
    [00:01.00]歌词来自QQ音乐
    [00:02.00]作词：测试
    [00:03.00]作词：DJ金木！
    [00:04.00]作曲：DJ金木...
    [00:05.00]未经著作权人许可 不得翻唱
    """
    checker = DuplicateChecker()
    checker.add_record(LyricRecord("song-1", source, title="Amnesia(House)", artist="DJ金木"))

    result = checker.check_record(LyricRecord("__query__", noisy, title="Amnesia(House)", artist="DJ金木"))

    assert result.decision == DuplicateDecision.DUPLICATE
    assert result.reason == "无有效歌词，文件内容兜底特征高度相似"


def test_unrelated_lyrics_with_shared_watermark_are_new() -> None:
    checker = DuplicateChecker()
    checker.add_record(
        LyricRecord(
            "song-1",
            """
            歌词来自QQ音乐
            北方的雪落在窗前
            我等一封迟来的信
            """,
        )
    )

    result = checker.check(
        """
        歌词来自QQ音乐
        南方的雨穿过街心
        你把故事说给云听
        """
    )

    assert result.decision == DuplicateDecision.NEW
    assert result.candidates == ()


def test_mixed_chinese_english_tokenization_recalls_candidate() -> None:
    checker = DuplicateChecker()
    checker.add_record(
        LyricRecord(
            "song-1",
            """
            say hello 在风里
            hold me close tonight
            我们穿过蓝色街道
            never let me go
            """,
        )
    )

    result = checker.check(
        """
        say hello 在风里
        hold me close tonight
        我们穿过蓝色街道
        never let me go
        """
    )

    assert result.decision == DuplicateDecision.DUPLICATE


def test_checker_can_persist_index(tmp_path) -> None:
    index_path = tmp_path / "lyrics.pkl"
    checker = DuplicateChecker()
    checker.add_record(LyricRecord("song-1", BASE_LYRIC))
    checker.save(index_path)

    loaded = DuplicateChecker.load(index_path)
    result = loaded.check(BASE_LYRIC)

    assert loaded.record_count == 1
    assert result.decision == DuplicateDecision.DUPLICATE


def test_record_from_lrc_file(tmp_path) -> None:
    lyric_file = tmp_path / "周杰伦 - 测试歌.lrc"
    lyric_file.write_text("[00:01.00]我愛你\n", encoding="utf-8")

    record = record_from_file(lyric_file, base_dir=tmp_path)

    assert record.title == "测试歌"
    assert record.artist == "周杰伦"
    assert record.lyrics == "[00:01.00]我愛你\n"


def test_record_from_song_artist_lyrics_filename(tmp_path) -> None:
    lyric_file = tmp_path / "Amnesia(House)-DJ金木-歌词.txt"
    lyric_file.write_text("作词：DJ金木\n", encoding="utf-8")

    record = record_from_file(lyric_file, base_dir=tmp_path)

    assert record.title == "Amnesia(House)"
    assert record.artist == "DJ金木"


def test_evaluate_csv_reports_binary_metrics(tmp_path) -> None:
    library = tmp_path / "library"
    incoming = tmp_path / "incoming"
    library.mkdir()
    incoming.mkdir()
    (library / "歌手A - 夜里.lrc").write_text(BASE_LYRIC, encoding="utf-8")
    (incoming / "dup.lrc").write_text(BASE_LYRIC.replace("我爱你", "我愛你"), encoding="utf-8")
    (incoming / "new.txt").write_text("南方的雨穿过街心\n你把故事说给云听\n", encoding="utf-8")

    checker = DuplicateChecker()
    checker.add_record(record_from_file(library / "歌手A - 夜里.lrc", base_dir=library))
    index_path = tmp_path / "lyrics.pkl"
    checker.save(index_path)

    eval_csv = tmp_path / "eval.csv"
    eval_csv.write_text(
        "id,file,expected\n"
        "case-1,incoming/dup.lrc,应去重\n"
        "case-2,incoming/new.txt,不应去重\n",
        encoding="utf-8",
    )
    out_path = tmp_path / "eval_out.csv"

    evaluate_csv(
        index_path,
        eval_csv,
        out_path,
        base_dir=tmp_path,
        positive_decisions={"duplicate"},
        max_candidates=5,
    )

    rows = list(csv.DictReader(out_path.open(encoding="utf-8")))
    assert [row["correct"] for row in rows] == ["True", "True"]
    assert rows[0]["reason"] == "规范化后的原文歌词哈希完全一致"
    assert (tmp_path / "eval_out.csv.summary.json").exists()


def test_generated_eval_set_uses_stratified_production_mix(tmp_path) -> None:
    library = tmp_path / "library"
    incoming = tmp_path / "generated" / "incoming"
    eval_csv = tmp_path / "generated" / "eval.csv"
    library.mkdir()
    for idx in range(12):
        prefix = "AY" if idx % 2 == 0 else "WHHY"
        (library / f"{idx}_{prefix}{idx:06d}.txt").write_text(
            BASE_LYRIC.replace("我爱你", f"我想你{idx}").replace("城市", f"城市{idx}"),
            encoding="utf-8",
        )

    generate_eval_set(library_dir=library, output_dir=incoming, csv_path=eval_csv, size=30, positive_ratio=0.3)

    rows = list(csv.DictReader(eval_csv.open(encoding="utf-8")))
    manifest = json.loads((tmp_path / "generated" / "eval.csv.manifest.json").read_text(encoding="utf-8"))
    negative_types = {row["sample_type"] for row in rows if row["expected"] == "不应去重"}

    assert len(rows) == 30
    assert manifest["library_files"] == 12
    assert manifest["sample_size"] == 30
    assert manifest["unique_source_records"] > 1
    assert manifest["holdout_records"] > 1
    assert (tmp_path / "generated" / "eval.csv.index.pkl").exists()
    assert "positive_full_duplicate" in manifest["plan"]
    assert "negative_real_holdout_full_song" in negative_types
    assert "negative_fragment" in negative_types
    assert all(row["expected"] == "不应去重" for row in rows if row["sample_type"].startswith("negative_"))


def test_generated_hard_eval_set_uses_business_realistic_edge_mix(tmp_path) -> None:
    library = tmp_path / "library"
    incoming = tmp_path / "generated" / "incoming"
    eval_csv = tmp_path / "generated" / "eval_hard.csv"
    library.mkdir()
    for idx in range(24):
        prefix = "AY" if idx % 3 == 0 else "WHHY"
        lyric = BASE_LYRIC.replace("我爱你", f"我想你{idx}").replace("城市", f"城市{idx}")
        if idx % 4 == 0:
            lyric += "\nI miss you tonight\nUnder the moonlight\nNever let me go\n"
        (library / f"{idx}_{prefix}{idx:06d}.txt").write_text(lyric, encoding="utf-8")

    generate_eval_set(
        library_dir=library,
        output_dir=incoming,
        csv_path=eval_csv,
        size=40,
        positive_ratio=0.3,
        profile="hard",
    )

    rows = list(csv.DictReader(eval_csv.open(encoding="utf-8")))
    manifest = json.loads((tmp_path / "generated" / "eval_hard.csv.manifest.json").read_text(encoding="utf-8"))
    sample_types = {row["sample_type"] for row in rows}

    assert len(rows) == 40
    assert manifest["profile"] == "hard"
    assert "positive_realistic_variant" in manifest["plan"]
    assert "negative_near_neighbor_holdout_full_song" in manifest["plan"]
    assert "negative_long_fragment" in sample_types
    assert "negative_catalog_mashup" in sample_types
    assert any(row["sample_type"].startswith("positive_") for row in rows)


def test_foreign_original_with_added_chinese_translation_is_duplicate() -> None:
    checker = DuplicateChecker()
    checker.add_record(
        LyricRecord(
            "song-1",
            """
            I miss you tonight
            Under the moonlight
            Never let me go
            """,
        )
    )

    result = checker.check(
        """
        I miss you tonight
        今晚我想你
        Under the moonlight
        月光之下
        Never let me go
        永远不要让我离开
        """
    )

    assert result.decision == DuplicateDecision.DUPLICATE
    assert result.reason == "规范化后的原文歌词哈希完全一致，翻译行未参与自动判重"


def test_same_timestamp_translation_split_is_high_confidence() -> None:
    normalized = normalize_lyrics(
        """
        [00:01.00]I miss you tonight
        [00:01.00]今晚我想你
        [00:02.00]Under the moonlight
        [00:02.00]月光之下
        """
    )

    assert normalized.primary_lines == ("i miss you tonight", "under the moonlight")
    assert normalized.translation_lines == ("今晚我想你", "月光之下")
    assert normalized.split_confidence == "high"


def test_translation_only_overlap_is_review_not_duplicate() -> None:
    checker = DuplicateChecker()
    checker.add_record(
        LyricRecord(
            "song-1",
            """
            I miss you tonight
            今晚我想你
            Under the moonlight
            月光之下
            Never let me go
            永远不要让我离开
            """,
        )
    )

    result = checker.check(
        """
        Te extrano esta noche
        今晚我想你
        Bajo la luna
        月光之下
        No me dejes ir
        永远不要让我离开
        """
    )

    assert result.decision == DuplicateDecision.REVIEW
    assert result.reason == "仅翻译行相似，原文字面重合不足，不自动判重"
    assert result.candidates[0].translation_jaccard >= 0.45


def test_block_translation_split_is_review_when_primary_matches() -> None:
    checker = DuplicateChecker()
    checker.add_record(
        LyricRecord(
            "song-1",
            """
            I miss you tonight
            Under the moonlight
            Never let me go
            """,
        )
    )

    result = checker.check(
        """
        I miss you tonight
        Under the moonlight
        Never let me go
        今晚我想你
        月光之下
        永远不要让我离开
        """
    )

    assert result.decision == DuplicateDecision.REVIEW
    assert result.reason == "原文哈希一致，但疑似整段翻译结构拆分置信度较低，需要人工复核"