"""Tests for admin value reports (6.1 daily / 6.2 weekly)."""

from __future__ import annotations

import uuid
from datetime import date, datetime, timedelta, timezone

import pytest

from investibook.db import queries as dbq


@pytest.fixture
def db(monkeypatch, tmp_path):
    p = tmp_path / "investibook.db"
    monkeypatch.setattr(dbq, "DB_PATH", p)
    dbq._db_init()
    return p


def _insert_jira(
    conn,
    key: str,
    *,
    first_seen: int,
    flag: str = "yes",
    eligibility: str = "eligible",
) -> None:
    conn.execute(
        """
        INSERT INTO jira_tickets (
          issue_key, project_key, summary, first_seen_at, last_jira_sync_at,
          jira_created_at, jira_updated_at, raw_payload_json,
          jira_incident_flag, eligibility
        ) VALUES (?, 'TCOC', 's', ?, ?, ?, ?, '{}', ?, ?)
        """,
        (key, first_seen, first_seen, first_seen, first_seen, flag, eligibility),
    )


def test_daily_report_counts_new_signals_and_dossiers(db):
    day = date(2026, 5, 10)
    start_e, end_e = dbq._utc_calendar_day_bounds_epoch(day)
    mid = start_e + 3600
    dossier_id = str(uuid.uuid4())
    with dbq._db_lock:
        conn = dbq._db_connect()
        _insert_jira(conn, "TCOC-D1", first_seen=mid)
        conn.execute(
            """
            INSERT INTO incident_dossiers (
              id, title, status, merged_into_dossier_id, created_at, updated_at
            ) VALUES (?, 't', 'active', NULL, ?, ?)
            """,
            (dossier_id, mid, mid),
        )
        conn.commit()
        conn.close()

    r = dbq._db_admin_value_report_daily(day)
    assert r["kind"] == "daily"
    assert r["day"] == "2026-05-10"
    assert len(r["new_external_signals"]) == 1
    assert r["new_external_signals"][0]["issue_key"] == "TCOC-D1"
    assert len(r["new_dossiers"]) == 1
    assert r["new_dossiers"][0]["id"] == dossier_id


def test_weekly_coverage_ratio(db):
    monday = date(2026, 5, 11)
    start_e = dbq._utc_calendar_day_bounds_epoch(monday)[0]
    t1 = start_e + 100
    t2 = start_e + 200
    d_cov = str(uuid.uuid4())
    d_unc = str(uuid.uuid4())
    ws = f"ws-{uuid.uuid4().hex[:8]}"
    with dbq._db_lock:
        conn = dbq._db_connect()
        _insert_jira(conn, "TCOC-W1", first_seen=t1)
        _insert_jira(conn, "TCOC-W2", first_seen=t2)
        conn.execute(
            """
            INSERT INTO workspaces (
              id, user_id, name, description, is_example, is_shared, created_at, updated_at
            ) VALUES (?, 'u1', 'W', '', 0, 0, ?, ?)
            """,
            (ws, dbq._utc_now(), dbq._utc_now()),
        )
        for did, ik in ((d_cov, "TCOC-W1"), (d_unc, "TCOC-W2")):
            conn.execute(
                """
                INSERT INTO incident_dossiers (
                  id, title, status, merged_into_dossier_id, created_at, updated_at
                ) VALUES (?, 'x', 'active', NULL, ?, ?)
                """,
                (did, t1, t1),
            )
            conn.execute(
                """
                INSERT INTO incident_dossier_issues (
                  dossier_id, issue_key, link_role, link_confidence, created_at
                ) VALUES (?, ?, 'primary', 'auto', ?)
                """,
                (did, ik, t1),
            )
        conn.execute(
            """
            INSERT INTO workspace_jira_links (
              id, workspace_id, issue_key, source_id, user_id, linked_at
            ) VALUES (?, ?, 'TCOC-W1', 's1', 'u1', ?)
            """,
            (str(uuid.uuid4()), ws, dbq._utc_now()),
        )
        conn.commit()
        conn.close()

    r = dbq._db_admin_value_report_weekly(monday)
    assert r["kind"] == "weekly"
    cov = r["coverage_incident_eligible_dossiers"]
    assert cov["denominator_distinct_dossiers"] == 2
    assert cov["with_any_workspace_jira_link_on_eligible_issue"] == 1
    assert cov["ratio"] == pytest.approx(0.5)
    ids_unc = {x["id"] for x in r["uncovered_dossiers"]}
    assert d_unc in ids_unc
    assert d_cov not in ids_unc


def test_weekly_rejects_non_monday(db):
    with pytest.raises(ValueError, match="Monday"):
        dbq._db_admin_value_report_weekly(date(2026, 5, 12))


def test_api_daily_defaults_and_weekly(monkeypatch, db):
    from fastapi.testclient import TestClient

    from investibook.main import app

    monkeypatch.setattr(dbq, "DB_PATH", db)

    class _FakeAdmin:
        id = "admin-user"

    app.dependency_overrides.clear()
    try:
        from investibook.api.deps import require_admin

        async def _fake_admin():
            return {"id": _FakeAdmin.id, "is_admin": True}

        app.dependency_overrides[require_admin] = _fake_admin
        client = TestClient(app)
        rd = client.get("/api/admin/value-reports/daily")
        assert rd.status_code == 200
        assert rd.json().get("kind") == "daily"
        today = datetime.now(timezone.utc).date()
        monday = today - timedelta(days=today.weekday())
        rw = client.get(f"/api/admin/value-reports/weekly?week_start={monday.isoformat()}")
        assert rw.status_code == 200
        assert rw.json().get("kind") == "weekly"
        bad = client.get("/api/admin/value-reports/weekly?week_start=2026-05-13")
        assert bad.status_code == 400
    finally:
        app.dependency_overrides.clear()