import csv

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_marks_fragments_as_negative(tmp_path) -> None:
    library = tmp_path / "library"
    incoming = tmp_path / "generated" / "incoming"
    eval_csv = tmp_path / "generated" / "eval.csv"
    library.mkdir()
    (library / "song.txt").write_text(BASE_LYRIC, encoding="utf-8")

    generate_eval_set(library_dir=library, output_dir=incoming, csv_path=eval_csv, size=20, positive_ratio=0.5)

    rows = list(csv.DictReader(eval_csv.open(encoding="utf-8")))
    positive_types = {row["sample_type"] for row in rows if row["expected"] == "应去重"}
    fragment_rows = [row for row in rows if row["sample_type"] == "single_song_fragment"]

    assert "trimmed_version" not in positive_types
    assert "single_song_fragment" not in positive_types
    assert fragment_rows
    assert all(row["expected"] == "不应去重" for row in fragment_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 == "原文哈希一致，但疑似整段翻译结构拆分置信度较低，需要人工复核"