"""Tests for GET /api/voice-clips + PATCH /voice-clips/{id}/match.

Seeds 3 clips (2 wechat for user u1 at end_time 1000/3000, 1 whatsapp for u2
at end_time 2000) and asserts GET filters + ordering (``end_time desc``) +
pagination + the ``user_id``-beats-``user_real_name`` precedence rule, plus
the 手动匹配 PATCH (set + clear + name resolution + 404 path).
"""

from __future__ import annotations

from sqlalchemy.ext.asyncio import AsyncSession

from app.db.models import Customer, VoiceClip


async def _seed(session: AsyncSession) -> None:
    session.add_all(
        [
            VoiceClip(
                voice_clip_id=1,
                user_id="u1",
                channel="wechat",
                user_real_name="Alice",
                company_code="8m0atd",
                start_time=900,
                end_time=1000,
                oss_file_name="https://oss/clip1.mp3",
                mp3_duration=100,
                duration_format="00:01:40",
            ),
            VoiceClip(
                voice_clip_id=2,
                user_id="u2",
                channel="whatsapp",
                user_real_name="Bob",
                company_code="8m0atd",
                start_time=1900,
                end_time=2000,
                oss_file_name="https://oss/clip2.mp3",
                mp3_duration=60,
                duration_format="00:01:00",
            ),
            VoiceClip(
                voice_clip_id=3,
                user_id="u1",
                channel="wechat",
                user_real_name="Alice",
                company_code="other",
                start_time=2900,
                end_time=3000,
                oss_file_name=None,
                mp3_duration=0,
                duration_format="00:00:00",
            ),
        ]
    )
    await session.commit()


async def test_default_list_returns_all_ordered_desc(make_client):
    """No filters -> 3 rows, ordered by ``end_time desc``."""
    client = await make_client(_seed)
    r = await client.get("/api/voice-clips")
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 3
    assert [it["voice_clip_id"] for it in body["items"]] == [3, 2, 1]
    for key in (
        "voice_clip_id",
        "user_id",
        "channel",
        "user_real_name",
        "wx_id",
        "talker",
        "status",
        "is_send",
        "company_code",
        "start_time",
        "end_time",
        "oss_file_name",
        "mp3_duration",
        "duration_format",
        "raw_json",
    ):
        assert key in body["items"][0]


async def test_filter_by_user_id(make_client):
    """``?user_id=u1`` -> 2 clips for Alice."""
    client = await make_client(_seed)
    r = await client.get("/api/voice-clips", params={"user_id": "u1"})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 2
    assert {it["voice_clip_id"] for it in body["items"]} == {1, 3}


async def test_user_id_takes_precedence_over_user_real_name(make_client):
    """When both ``user_id`` and ``user_real_name`` are given, user_id wins.

    The 云客 modal switches between the two based on whether the user edited
    the staff-name box; the id is the more precise filter and wins on conflict.
    Here ``user_id=u1`` (Alice) + ``user_real_name=Bob`` should still return
    Alice's clips (user_id path), NOT Bob's.
    """
    client = await make_client(_seed)
    r = await client.get(
        "/api/voice-clips", params={"user_id": "u1", "user_real_name": "Bob"}
    )
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 2
    assert {it["voice_clip_id"] for it in body["items"]} == {1, 3}


async def test_filter_by_user_real_name_fuzzy(make_client):
    """``?user_real_name=ob`` -> Bob's clip only (ILIKE contains)."""
    client = await make_client(_seed)
    r = await client.get("/api/voice-clips", params={"user_real_name": "ob"})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 1
    assert body["items"][0]["voice_clip_id"] == 2


async def test_filter_by_channel(make_client):
    """``?channel=whatsapp`` -> the single WA clip."""
    client = await make_client(_seed)
    r = await client.get("/api/voice-clips", params={"channel": "whatsapp"})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 1
    assert body["items"][0]["voice_clip_id"] == 2


async def test_filter_by_company_code(make_client):
    """``?company_code=8m0atd`` -> 2 clips (clip 3 has 'other')."""
    client = await make_client(_seed)
    r = await client.get("/api/voice-clips", params={"company_code": "8m0atd"})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 2
    assert {it["voice_clip_id"] for it in body["items"]} == {1, 2}


async def test_time_window_filter(make_client):
    """``?start=1500&end=2500`` -> only clip 2 (end_time 2000)."""
    client = await make_client(_seed)
    r = await client.get("/api/voice-clips", params={"start": 1500, "end": 2500})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 1
    assert body["items"][0]["voice_clip_id"] == 2


async def test_filters_compose(make_client):
    """``user_id=u1 & start=1500`` -> only clip 3 (u1's later clip)."""
    client = await make_client(_seed)
    r = await client.get(
        "/api/voice-clips", params={"user_id": "u1", "start": 1500}
    )
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 1
    assert body["items"][0]["voice_clip_id"] == 3


async def test_pagination(make_client):
    """``page_size=1`` -> 1 item, total 3."""
    client = await make_client(_seed)
    r = await client.get("/api/voice-clips", params={"page": 1, "page_size": 1})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 3
    assert len(body["items"]) == 1
    assert body["items"][0]["voice_clip_id"] == 3


async def test_oss_file_name_serializes(make_client):
    """``oss_file_name`` (OSS recording URL) round-trips so the modal can
    render an inline ``<audio>`` player — present when set, None when unset.
    """
    client = await make_client(_seed)
    r = await client.get("/api/voice-clips")
    assert r.status_code == 200
    by_id = {it["voice_clip_id"]: it for it in r.json()["items"]}
    assert by_id[1]["oss_file_name"] == "https://oss/clip1.mp3"
    assert by_id[3]["oss_file_name"] is None


async def test_raw_json_serializes_verbatim(make_client):
    """``raw_json`` round-trips the verbatim upstream record when set."""

    async def seed(session: AsyncSession) -> None:
        await _seed(session)
        session.add(
            VoiceClip(
                voice_clip_id=99,
                user_id="u1",
                channel="wechat",
                user_real_name="Alice",
                start_time=5000,
                end_time=5100,
                raw_json={
                    "id": 99,
                    "userId": "u1",
                    "userRealName": "Alice",
                    "startTime": "5000",
                    "endTime": "5100",
                    "ossFileName": "https://oss/clip99.mp3",
                    "mp3Duration": 100,
                    "durationFormat": "00:01:40",
                    "companyCode": "8m0atd",
                },
            )
        )
        await session.commit()

    client = await make_client(seed)
    r = await client.get("/api/voice-clips", params={"user_id": "u1", "start": 5000})
    assert r.status_code == 200
    body = r.json()
    assert body["total"] == 1
    assert body["items"][0]["voice_clip_id"] == 99
    assert body["items"][0]["raw_json"] == {
        "id": 99,
        "userId": "u1",
        "userRealName": "Alice",
        "startTime": "5000",
        "endTime": "5100",
        "ossFileName": "https://oss/clip99.mp3",
        "mp3Duration": 100,
        "durationFormat": "00:01:40",
        "companyCode": "8m0atd",
    }

    # Seeded without an explicit raw_json -> JSON null.
    r_all = await client.get("/api/voice-clips")
    by_id = {it["voice_clip_id"]: it for it in r_all.json()["items"]}
    assert by_id[1]["raw_json"] is None


# ---------------------------------------------------------------------------
# 手动匹配 — PATCH /api/voice-clips/{id}/match
# ---------------------------------------------------------------------------


async def _seed_with_customer(session: AsyncSession) -> None:
    """Seed 1 clip + 1 matched customer (remark='张三')."""
    await _seed(session)
    session.add(
        Customer(
            friend_id="fid_remark",
            channel="wechat",
            owner_account_id="wx1",
            friend_remark="张三",
            friend_nickname="三三",
            real_name="张三真名",
        )
    )
    await session.commit()


async def test_match_returns_payload_and_persists(make_client):
    """PATCH /match sets matched_friend_id; payload echoes it; GET sees it."""
    client = await make_client(_seed_with_customer)

    r = await client.patch("/api/voice-clips/1/match", json={"friend_id": "fid_remark"})
    assert r.status_code == 200
    body = r.json()
    # Response now carries the post-update ``updated_at`` for the optimistic-
    # lock flow (client folds it into the next request's ``If-Match`` header).
    assert body["voice_clip_id"] == 1
    assert body["matched_friend_id"] == "fid_remark"
    assert "updated_at" in body
    updated_at_v1 = body["updated_at"]

    # The GET list now reflects the match (cross-request persistence —
    # requires the PATCH to commit, not just flush).
    r2 = await client.get("/api/voice-clips", params={"user_id": "u1"})
    by_id = {it["voice_clip_id"]: it for it in r2.json()["items"]}
    assert by_id[1]["matched_friend_id"] == "fid_remark"
    # Resolved via Customer lookup: remark > nickname > real_name > friend_id.
    assert by_id[1]["matched_friend_name"] == "张三"
    # The other wechat clip for u1 is still unmatched.
    assert by_id[3]["matched_friend_id"] is None
    assert by_id[3]["matched_friend_name"] is None
    return updated_at_v1  # for reuse by optimistic-lock tests below if needed


async def test_match_name_falls_back_through_nickname_real_name(make_client):
    """Name resolution: no remark -> nickname; no nickname -> real_name."""

    async def seed(session: AsyncSession) -> None:
        await _seed(session)
        session.add_all(
            [
                Customer(
                    friend_id="fid_nick",
                    channel="wechat",
                    friend_nickname="尼克",
                ),
                Customer(
                    friend_id="fid_real",
                    channel="wechat",
                    real_name="王五",
                ),
            ]
        )
        await session.commit()

    client = await make_client(seed)
    await client.patch("/api/voice-clips/1/match", json={"friend_id": "fid_nick"})
    await client.patch("/api/voice-clips/3/match", json={"friend_id": "fid_real"})

    r = await client.get("/api/voice-clips", params={"user_id": "u1"})
    by_id = {it["voice_clip_id"]: it for it in r.json()["items"]}
    assert by_id[1]["matched_friend_name"] == "尼克"
    assert by_id[3]["matched_friend_name"] == "王五"


async def test_match_with_unknown_friend_id_falls_back_to_id(make_client):
    """A match pointing at a deleted/unknown customer shows the id as name."""
    client = await make_client(_seed)
    await client.patch(
        "/api/voice-clips/1/match", json={"friend_id": "ghost_customer"}
    )
    r = await client.get("/api/voice-clips", params={"user_id": "u1"})
    by_id = {it["voice_clip_id"]: it for it in r.json()["items"]}
    assert by_id[1]["matched_friend_id"] == "ghost_customer"
    assert by_id[1]["matched_friend_name"] == "ghost_customer"


async def test_unmatch_clears_friend_id(make_client):
    """PATCH with friend_id=null clears an existing match."""
    client = await make_client(_seed_with_customer)
    await client.patch("/api/voice-clips/1/match", json={"friend_id": "fid_remark"})
    # Now clear it.
    r = await client.patch("/api/voice-clips/1/match", json={"friend_id": None})
    assert r.status_code == 200
    body = r.json()
    assert body["voice_clip_id"] == 1
    assert body["matched_friend_id"] is None
    assert "updated_at" in body

    r2 = await client.get("/api/voice-clips", params={"user_id": "u1"})
    by_id = {it["voice_clip_id"]: it for it in r2.json()["items"]}
    assert by_id[1]["matched_friend_id"] is None
    assert by_id[1]["matched_friend_name"] is None


async def test_match_missing_clip_returns_404(make_client):
    """PATCH on a non-existent voice_clip_id -> 404."""
    client = await make_client(_seed)
    r = await client.patch(
        "/api/voice-clips/999999/match", json={"friend_id": "fid_remark"}
    )
    assert r.status_code == 404


async def test_match_default_null_body_is_treated_as_unmatch(make_client):
    """Omitting friend_id from the body clears the match (default None)."""
    client = await make_client(_seed_with_customer)
    await client.patch("/api/voice-clips/1/match", json={"friend_id": "fid_remark"})
    # Empty body -> body.friend_id defaults to None -> unmatch.
    r = await client.patch("/api/voice-clips/1/match", json={})
    assert r.status_code == 200
    body = r.json()
    assert body["matched_friend_id"] is None
    assert "updated_at" in body


# ---------------------------------------------------------------------------
# Optimistic lock — If-Match header on PATCH /api/voice-clips/{id}/match
# ---------------------------------------------------------------------------


async def test_match_with_if_match_accepts_current_updated_at(make_client):
    """If-Match equal to the row's current ``updated_at`` is accepted (200).

    The flow: GET to read the current ``updated_at`` (via a successful PATCH
    echo), send that value as ``If-Match`` on the next PATCH — the server
    accepts the request because the row has not changed in between.
    """
    client = await make_client(_seed_with_customer)
    # First PATCH establishes the match and returns the post-update timestamp.
    r1 = await client.patch(
        "/api/voice-clips/1/match", json={"friend_id": "fid_remark"}
    )
    assert r1.status_code == 200
    current = r1.json()["updated_at"]
    assert current is not None

    # Second PATCH with If-Match=current: accepted (200), match cleared.
    r2 = await client.patch(
        "/api/voice-clips/1/match",
        json={"friend_id": None},
        headers={"If-Match": current},
    )
    assert r2.status_code == 200
    assert r2.json()["matched_friend_id"] is None


async def test_match_with_stale_if_match_returns_409(make_client):
    """An If-Match that doesn't match the row's current ``updated_at`` -> 409.

    Simulates the lost-update race: client A reads the clip, client B modifies
    it (bumping ``updated_at``), then client A's PATCH carrying A's now-stale
    timestamp is rejected. We force a clearly stale value rather than relying
    on wall-clock drift because SQLite's ``CURRENT_TIMESTAMP`` (the dialect
    compilation of ``func.now()``) has 1-second resolution and two PATCHes
    inside the same second produce identical timestamps.
    """
    client = await make_client(_seed_with_customer)
    # First PATCH: succeeds, returns the post-update timestamp.
    r1 = await client.patch(
        "/api/voice-clips/1/match", json={"friend_id": "fid_remark"}
    )
    assert r1.status_code == 200
    current = r1.json()["updated_at"]
    assert current is not None

    # Any string that differs from the row's current updated_at is "stale" —
    # 409. We use an obviously-older timestamp so the test is deterministic.
    stale = "2000-01-01T00:00:00"
    assert stale != current

    r2 = await client.patch(
        "/api/voice-clips/1/match",
        json={"friend_id": None},
        headers={"If-Match": stale},
    )
    assert r2.status_code == 409
    assert "modified" in r2.json()["detail"].lower()


async def test_match_without_if_match_is_backward_compatible(make_client):
    """No If-Match header -> no optimistic-lock check; behavior unchanged."""
    client = await make_client(_seed_with_customer)
    # First PATCH establishes a value.
    r1 = await client.patch(
        "/api/voice-clips/1/match", json={"friend_id": "fid_remark"}
    )
    assert r1.status_code == 200

    # Second PATCH WITHOUT If-Match — accepted regardless of staleness
    # (backward compatible: clients that don't send the header keep working).
    r2 = await client.patch(
        "/api/voice-clips/1/match", json={"friend_id": "fid_nick"}
    )
    assert r2.status_code == 200
    assert r2.json()["matched_friend_id"] == "fid_nick"