"""通知与手工开单。

这两个功能都有一个共同的翻车方式：**看起来有，实际没送到**。
所以要断言的从来不是"接口 200"，而是"该收到的人收到了、不该收到的人没收到"。

1. 自己改自己的任务不该给自己发通知（否则未读数两天就没人看了）；
2. 通知必须落到具体的人头上——被指派人、创建人，而不是"整个工作区"；
3. 手工开的工单要和升级来的工单走同一条路：能接受、能提交、能验收；
4. 指派给工作区外的人必须当场拒绝，否则任务会挂在一个没人看得到的名字上。
"""

from __future__ import annotations

from datetime import datetime, timedelta, timezone
from typing import Any

import pytest
from httpx import AsyncClient

from app.services import reminders

from .conftest import create_workspace, login, unwrap

V1 = "/api/v1"


async def _member(
    client: AsyncClient, owner: dict[str, Any], ws: dict[str, Any], role: str = "member"
) -> dict[str, Any]:
    user = await login(client)
    inv = unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/invitations", json={"role": role}, headers=owner["headers"]
        )
    )
    unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/join",
            json={"code": inv["code"]},
            headers=user["headers"],
        )
    )
    return user


async def _inbox(client: AsyncClient, user: dict[str, Any], ws_id: str) -> list[dict]:
    page = unwrap(
        await client.get(
            f"{V1}/workspaces/{ws_id}/notifications",
            params={"unread_only": "false"},
            headers=user["headers"],
        )
    )
    return page["notifications"]


async def _task_assigned_to(
    client: AsyncClient, owner: dict[str, Any], ws_id: str, assignee_id: str, title: str
) -> dict:
    return unwrap(
        await client.post(
            f"{V1}/workspaces/{ws_id}/items",
            json={"title": title, "status": "todo", "assignee_id": assignee_id},
            headers=owner["headers"],
        )
    )


@pytest.mark.asyncio
async def test_task_status_change_notifies_the_other_side(client: AsyncClient) -> None:
    owner = await login(client)
    ws = await create_workspace(client, owner, "通知测试")
    helper = await _member(client, owner, ws, "member")

    item = await _task_assigned_to(client, owner, ws["id"], helper["user_id"], "月度对账")

    # owner 指派给 helper 时，helper 应该收到通知
    helper_inbox = await _inbox(client, helper, ws["id"])
    assert any(n["kind"] == "task_assigned" and n["item_id"] == item["id"] for n in helper_inbox)
    # owner 自己指派的，不该收到
    assert not [n for n in await _inbox(client, owner, ws["id"]) if n["kind"] == "task_assigned"]

    # helper 把状态改成进行中 → owner（创建人）应该收到
    unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/items/{item['id']}/status",
            json={"status": "doing", "version": item["version"]},
            headers=helper["headers"],
        )
    )
    owner_inbox = await _inbox(client, owner, ws["id"])
    changed = [n for n in owner_inbox if n["kind"] == "task_status_changed"]
    assert len(changed) == 1
    assert "进行中" in changed[0]["body"]
    assert changed[0]["item_title"] == "月度对账"

    # helper 是操作者本人，不该收到自己那次改动的通知
    assert not [
        n for n in await _inbox(client, helper, ws["id"]) if n["kind"] == "task_status_changed"
    ]


@pytest.mark.asyncio
async def test_assignee_must_be_a_member(client: AsyncClient) -> None:
    owner = await login(client)
    ws = await create_workspace(client, owner, "越界指派")
    outsider = await login(client)  # 没加入这个工作区

    resp = await client.post(
        f"{V1}/workspaces/{ws['id']}/items",
        json={"title": "指派给外人", "assignee_id": outsider["user_id"]},
        headers=owner["headers"],
    )
    assert resp.status_code == 400, resp.text
    assert resp.json()["code"] == 1001

    item = unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/items",
            json={"title": "不指派"},
            headers=owner["headers"],
        )
    )
    resp = await client.patch(
        f"{V1}/workspaces/{ws['id']}/items/{item['id']}",
        json={"assignee_id": outsider["user_id"], "version": item["version"]},
        headers=owner["headers"],
    )
    assert resp.status_code == 400, resp.text


@pytest.mark.asyncio
async def test_manual_ticket_runs_the_whole_flow(client: AsyncClient) -> None:
    """手工开的工单不是"半个工单"：接受、提交、验收都得能走。"""
    owner = await login(client)
    ws = await create_workspace(client, owner, "手工开单")
    helper = await _member(client, owner, ws, "member")

    ticket = unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/tickets",
            json={
                "title": "帮忙核对一遍报价单",
                "body_md": "客户催得急，今天下班前要",
                "assignee_id": helper["user_id"],
                "priority": 2,
            },
            headers=owner["headers"],
        )
    )
    assert ticket["status"] == "open"
    assert ticket["kind"] == "ticket"
    assert ticket["ticket"]["requester_id"] == owner["user_id"]
    assert ticket["ticket"]["assignee_id"] == helper["user_id"]
    assert ticket["ticket"]["parent_item_id"] is None  # 没有来源任务

    # 出现在被指派人的工单列表里
    assigned = unwrap(
        await client.get(
            f"{V1}/workspaces/{ws['id']}/tickets",
            params={"role": "assigned"},
            headers=helper["headers"],
        )
    )
    assert [t["id"] for t in assigned["tickets"]] == [ticket["id"]]

    # 被指派人收到通知
    inbox = await _inbox(client, helper, ws["id"])
    assert any(n["kind"] == "ticket_assigned" and n["item_id"] == ticket["id"] for n in inbox)

    # 接受 → 开工 → 提交 → 验收通过
    for action, body in (
        ("accept", {}),
        ("start", {}),
        ("submit", {"note": "核对完了"}),
    ):
        unwrap(
            await client.post(
                f"{V1}/workspaces/{ws['id']}/items/{ticket['id']}/ticket/{action}",
                json=body,
                headers=helper["headers"],
            )
        )
    done = unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/items/{ticket['id']}/ticket/verify",
            json={"approve": True, "resolution_md": "确认了三处差异"},
            headers=owner["headers"],
        )
    )
    assert done["status"] == "done"
    # 验收是需求人做的，通知该发给办理人；需求人自己不该收到"你通过了"这种通知
    helper_inbox = await _inbox(client, helper, ws["id"])
    assert any(n["kind"] == "ticket_approved" for n in helper_inbox)
    assert not [n for n in await _inbox(client, owner, ws["id"]) if n["kind"] == "ticket_approved"]


@pytest.mark.asyncio
async def test_manual_ticket_rejects_outsider(client: AsyncClient) -> None:
    owner = await login(client)
    ws = await create_workspace(client, owner, "手工开单越界")
    outsider = await login(client)

    resp = await client.post(
        f"{V1}/workspaces/{ws['id']}/tickets",
        json={"title": "给外人开单", "assignee_id": outsider["user_id"]},
        headers=owner["headers"],
    )
    assert resp.status_code == 400, resp.text
    assert resp.json()["code"] == 1001


@pytest.mark.asyncio
async def test_comment_notifies_the_other_party(client: AsyncClient) -> None:
    owner = await login(client)
    ws = await create_workspace(client, owner, "评论通知")
    helper = await _member(client, owner, ws, "member")
    item = await _task_assigned_to(client, owner, ws["id"], helper["user_id"], "整理发票")

    unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/items/{item['id']}/comments",
            json={"body_md": "发票抬头要写公司全称"},
            headers=helper["headers"],
        )
    )
    owner_inbox = await _inbox(client, owner, ws["id"])
    assert any(n["kind"] == "item_commented" for n in owner_inbox)

    # 操作者本人不该收到
    assert not [n for n in await _inbox(client, helper, ws["id"]) if n["kind"] == "item_commented"]


@pytest.mark.asyncio
async def test_unread_count_and_read_all(client: AsyncClient) -> None:
    owner = await login(client)
    ws = await create_workspace(client, owner, "未读数")
    helper = await _member(client, owner, ws, "member")
    await _task_assigned_to(client, owner, ws["id"], helper["user_id"], "第一件")
    await _task_assigned_to(client, owner, ws["id"], helper["user_id"], "第二件")

    count = unwrap(
        await client.get(
            f"{V1}/workspaces/{ws['id']}/notifications/unread-count", headers=helper["headers"]
        )
    )
    assert count["unread"] == 2

    first = (await _inbox(client, helper, ws["id"]))[0]
    unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/notifications/{first['id']}/read",
            headers=helper["headers"],
        )
    )
    count = unwrap(
        await client.get(
            f"{V1}/workspaces/{ws['id']}/notifications/unread-count", headers=helper["headers"]
        )
    )
    assert count["unread"] == 1

    marked = unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/notifications/read-all", headers=helper["headers"]
        )
    )
    assert marked["marked"] == 1
    count = unwrap(
        await client.get(
            f"{V1}/workspaces/{ws['id']}/notifications/unread-count", headers=helper["headers"]
        )
    )
    assert count["unread"] == 0


async def _set_status(
    client: AsyncClient, user: dict[str, Any], ws_id: str, item: dict, status: str
) -> dict:
    return unwrap(
        await client.post(
            f"{V1}/workspaces/{ws_id}/items/{item['id']}/status",
            json={"status": status, "version": item["version"]},
            headers=user["headers"],
        )
    )


@pytest.mark.asyncio
async def test_task_completion_notifies_the_creator(client: AsyncClient) -> None:
    """派出去的活被干完了，派活的人要知道——但干活的人不该收到"你完成了"。"""
    owner = await login(client)
    ws = await create_workspace(client, owner, "完成通知")
    helper = await _member(client, owner, ws, "member")
    item = await _task_assigned_to(client, owner, ws["id"], helper["user_id"], "季度盘点")

    await _set_status(client, helper, ws["id"], item, "done")

    owner_inbox = await _inbox(client, owner, ws["id"])
    completed = [n for n in owner_inbox if n["kind"] == "task_completed"]
    assert len(completed) == 1
    assert completed[0]["item_id"] == item["id"]
    assert completed[0]["item_kind"] == "task"
    assert "已完成" in completed[0]["title"]
    assert not [n for n in await _inbox(client, helper, ws["id"]) if n["kind"] == "task_completed"]


@pytest.mark.asyncio
async def test_batch_status_sends_the_same_notifications(client: AsyncClient) -> None:
    """看板批量拖拽不能静默：拖 3 条完成，创建人就该收到 3 条完成通知。"""
    owner = await login(client)
    ws = await create_workspace(client, owner, "批量完成通知")
    helper = await _member(client, owner, ws, "member")
    items = [
        await _task_assigned_to(client, owner, ws["id"], helper["user_id"], f"批量任务 {i}")
        for i in range(3)
    ]

    unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/items/batch-status",
            json={
                "status": "done",
                "items": [{"id": item["id"], "version": item["version"]} for item in items],
            },
            headers=helper["headers"],
        )
    )

    owner_inbox = await _inbox(client, owner, ws["id"])
    completed = {n["item_id"] for n in owner_inbox if n["kind"] == "task_completed"}
    assert completed == {item["id"] for item in items}
    assert not [n for n in await _inbox(client, helper, ws["id"]) if n["kind"] == "task_completed"]


@pytest.mark.asyncio
async def test_knowledge_notifications_follow_the_flow(client: AsyncClient) -> None:
    """知识库的四个节点都要有人知道：新草稿、待核对、已发布、已归档。"""
    owner = await login(client)
    ws = await create_workspace(client, owner, "知识通知")
    admin = await _member(client, owner, ws, "admin")

    doc = unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/knowledge",
            json={"title": "报价流程", "body_md": "先核价，再报给客户"},
            headers=admin["headers"],
        )
    )

    # 管理员新建草稿 → 其他管理员（owner）收到
    created = [
        n
        for n in await _inbox(client, owner, ws["id"])
        if n["kind"] == "knowledge_draft_created" and n["item_id"] == doc["id"]
    ]
    assert len(created) == 1
    assert created[0]["item_kind"] == "knowledge"

    # 提交核对 → owner 收到"待核对"
    doc = unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/knowledge/{doc['id']}/status",
            json={"action": "submit_review", "version": doc["version"]},
            headers=admin["headers"],
        )
    )
    assert any(
        n["kind"] == "knowledge_review_requested" and n["item_id"] == doc["id"]
        for n in await _inbox(client, owner, ws["id"])
    )

    # 发布 → 作者（admin）收到
    doc = unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/knowledge/{doc['id']}/status",
            json={"action": "publish", "version": doc["version"]},
            headers=owner["headers"],
        )
    )
    published = [
        n
        for n in await _inbox(client, admin, ws["id"])
        if n["kind"] == "knowledge_published" and n["item_id"] == doc["id"]
    ]
    assert len(published) == 1
    assert published[0]["item_kind"] == "knowledge"

    # 归档 → 作者（admin）收到
    unwrap(
        await client.post(
            f"{V1}/workspaces/{ws['id']}/knowledge/{doc['id']}/status",
            json={"action": "archive", "version": doc["version"]},
            headers=owner["headers"],
        )
    )
    assert any(
        n["kind"] == "knowledge_archived" and n["item_id"] == doc["id"]
        for n in await _inbox(client, admin, ws["id"])
    )


async def _task_with_due(
    client: AsyncClient,
    owner: dict[str, Any],
    ws_id: str,
    assignee_id: str,
    title: str,
    due_at: datetime,
    status: str = "todo",
) -> dict:
    return unwrap(
        await client.post(
            f"{V1}/workspaces/{ws_id}/items",
            json={
                "title": title,
                "status": status,
                "assignee_id": assignee_id,
                "due_at": due_at.isoformat(),
            },
            headers=owner["headers"],
        )
    )


@pytest.mark.asyncio
async def test_reminders_cover_due_soon_and_overdue_once(client: AsyncClient) -> None:
    """扫描器只负责"该提醒的人收到且只收到一次"，不负责业务判断。"""
    owner = await login(client)
    ws = await create_workspace(client, owner, "到期提醒")
    helper = await _member(client, owner, ws, "member")
    now = datetime.now(timezone.utc)

    soon = await _task_with_due(
        client, owner, ws["id"], helper["user_id"], "明早交付", now + timedelta(hours=3)
    )
    late = await _task_with_due(
        client, owner, ws["id"], helper["user_id"], "昨天该交", now - timedelta(days=1)
    )
    await _task_with_due(
        client,
        owner,
        ws["id"],
        helper["user_id"],
        "已经做完的",
        now + timedelta(hours=1),
        status="done",
    )

    first = await reminders.tick()
    assert first["sent"] == 2, first

    inbox = await _inbox(client, helper, ws["id"])
    due_soon = [n for n in inbox if n["kind"] == "task_due_soon"]
    overdue = [n for n in inbox if n["kind"] == "task_overdue"]
    assert [n["item_id"] for n in due_soon] == [soon["id"]]
    assert [n["item_id"] for n in overdue] == [late["id"]]
    assert "截止时间" in due_soon[0]["body"]
    assert "已逾期" in overdue[0]["title"]

    # 第二轮不能重复写：dedupe_key 兜底
    second = await reminders.tick()
    assert second["sent"] == 0, second
    inbox = await _inbox(client, helper, ws["id"])
    assert len([n for n in inbox if n["kind"] == "task_due_soon"]) == 1
    assert len([n for n in inbox if n["kind"] == "task_overdue"]) == 1


@pytest.mark.asyncio
async def test_reminders_stay_inside_each_workspace(client: AsyncClient) -> None:
    """提醒是平台级扫描，但写通知必须回到各自工作区，不能串租户。"""
    owner_a = await login(client)
    ws_a = await create_workspace(client, owner_a, "提醒甲")
    helper_a = await _member(client, owner_a, ws_a, "member")

    owner_b = await login(client)
    ws_b = await create_workspace(client, owner_b, "提醒乙")
    helper_b = await _member(client, owner_b, ws_b, "member")

    now = datetime.now(timezone.utc)
    item_a = await _task_with_due(
        client, owner_a, ws_a["id"], helper_a["user_id"], "甲的逾期", now - timedelta(hours=2)
    )
    item_b = await _task_with_due(
        client, owner_b, ws_b["id"], helper_b["user_id"], "乙的逾期", now - timedelta(hours=2)
    )

    result = await reminders.tick()
    assert result["sent"] == 2, result

    inbox_a = await _inbox(client, helper_a, ws_a["id"])
    inbox_b = await _inbox(client, helper_b, ws_b["id"])
    assert {n["item_id"] for n in inbox_a if n["kind"] == "task_overdue"} == {item_a["id"]}
    assert {n["item_id"] for n in inbox_b if n["kind"] == "task_overdue"} == {item_b["id"]}