"""Tests for incident dossier split / move / promote / eligibility (manual maintenance)."""

from __future__ import annotations

import uuid

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_dossier(conn, did: str, title: str) -> None:
    now_e = dbq._utc_epoch_now()
    conn.execute(
        """
        INSERT INTO incident_dossiers (
          id, title, status, merged_into_dossier_id, created_at, updated_at
        ) VALUES (?, ?, 'active', NULL, ?, ?)
        """,
        (did, title, now_e, now_e),
    )


def _insert_jira(conn, key: str) -> None:
    now_e = dbq._utc_epoch_now()
    conn.execute(
        """
        INSERT INTO jira_tickets (
          issue_key, project_key, summary, first_seen_at, last_jira_sync_at,
          eligibility, eligibility_reason, eligibility_set_by
        ) VALUES (?, 'TCOC', ?, ?, ?, 'unknown', '', '')
        """,
        (key, f"sum-{key}", now_e, now_e),
    )


def test_split_moves_subset_and_keeps_primary_normalized(db):
    a = str(uuid.uuid4())
    with dbq._db_lock:
        conn = dbq._db_connect()
        _insert_dossier(conn, a, "A")
        _insert_jira(conn, "TCOC-S1")
        _insert_jira(conn, "TCOC-S2")
        now_e = dbq._utc_epoch_now()
        conn.execute(
            """
            INSERT INTO incident_dossier_issues (
              dossier_id, issue_key, link_role, link_confidence, created_at
            ) VALUES (?, 'TCOC-S1', 'primary', 'auto', ?)
            """,
            (a, now_e),
        )
        conn.execute(
            """
            INSERT INTO incident_dossier_issues (
              dossier_id, issue_key, link_role, link_confidence, created_at
            ) VALUES (?, 'TCOC-S2', 'related', 'manual', ?)
            """,
            (a, now_e),
        )
        conn.commit()
        conn.close()

    out = dbq._db_split_incident_dossier(a, ["TCOC-S2"], "Fork", "u1")
    new_id = out["new_dossier_id"]

    conn = dbq._db_connect()
    rows_a = conn.execute(
        """
        SELECT issue_key, link_role FROM incident_dossier_issues
         WHERE dossier_id = ? ORDER BY issue_key
        """,
        (a,),
    ).fetchall()
    rows_n = conn.execute(
        """
        SELECT issue_key, link_role FROM incident_dossier_issues
         WHERE dossier_id = ? ORDER BY issue_key
        """,
        (new_id,),
    ).fetchall()
    conn.close()

    assert [dict(r) for r in rows_a] == [
        {"issue_key": "TCOC-S1", "link_role": "primary"},
    ]
    assert [dict(r) for r in rows_n] == [
        {"issue_key": "TCOC-S2", "link_role": "primary"},
    ]


def test_split_rejects_emptying_source(db):
    a = str(uuid.uuid4())
    with dbq._db_lock:
        conn = dbq._db_connect()
        _insert_dossier(conn, a, "A")
        _insert_jira(conn, "TCOC-ONLY")
        now_e = dbq._utc_epoch_now()
        conn.execute(
            """
            INSERT INTO incident_dossier_issues (
              dossier_id, issue_key, link_role, link_confidence, created_at
            ) VALUES (?, 'TCOC-ONLY', 'primary', 'auto', ?)
            """,
            (a, now_e),
        )
        conn.commit()
        conn.close()

    with pytest.raises(ValueError, match="promote-new-dossier"):
        dbq._db_split_incident_dossier(a, ["TCOC-ONLY"], None, "u1")


def test_move_issue_between_dossiers(db):
    a = str(uuid.uuid4())
    b = str(uuid.uuid4())
    with dbq._db_lock:
        conn = dbq._db_connect()
        _insert_dossier(conn, a, "A")
        _insert_dossier(conn, b, "B")
        _insert_jira(conn, "TCOC-M1")
        _insert_jira(conn, "TCOC-M2")
        now_e = dbq._utc_epoch_now()
        for ik in ("TCOC-M1", "TCOC-M2"):
            conn.execute(
                """
                INSERT INTO incident_dossier_issues (
                  dossier_id, issue_key, link_role, link_confidence, created_at
                ) VALUES (?, ?, 'related', 'manual', ?)
                """,
                (a, ik, now_e),
            )
        conn.commit()
        conn.close()

    dbq._db_move_dossier_issue_between(a, b, "TCOC-M1", "actor")

    conn = dbq._db_connect()
    ka = {
        r["issue_key"]
        for r in conn.execute(
            "SELECT issue_key FROM incident_dossier_issues WHERE dossier_id = ?",
            (a,),
        ).fetchall()
    }
    kb = {
        r["issue_key"]
        for r in conn.execute(
            "SELECT issue_key FROM incident_dossier_issues WHERE dossier_id = ?",
            (b,),
        ).fetchall()
    }
    conn.close()

    assert ka == {"TCOC-M2"}
    assert kb == {"TCOC-M1"}


def test_promote_closes_source_when_last_issue(db):
    a = str(uuid.uuid4())
    with dbq._db_lock:
        conn = dbq._db_connect()
        _insert_dossier(conn, a, "A")
        _insert_jira(conn, "TCOC-P1")
        now_e = dbq._utc_epoch_now()
        conn.execute(
            """
            INSERT INTO incident_dossier_issues (
              dossier_id, issue_key, link_role, link_confidence, created_at
            ) VALUES (?, 'TCOC-P1', 'primary', 'auto', ?)
            """,
            (a, now_e),
        )
        conn.commit()
        conn.close()

    out = dbq._db_promote_issue_to_new_dossier(a, "TCOC-P1", "Standalone", "u1")
    assert out["source_closed"] is True
    assert out["source_remaining_issues"] == 0

    row_a = dbq._db_get_incident_dossier_row(a)
    assert row_a is not None
    assert row_a["status"] == "closed"


def test_set_eligibility_persists(db):
    with dbq._db_lock:
        conn = dbq._db_connect()
        _insert_jira(conn, "TCOC-E1")
        conn.commit()
        conn.close()

    dbq._db_set_jira_ticket_eligibility_admin(
        "TCOC-E1",
        "not_eligible",
        "consult not incident",
        "admin-1",
    )
    row = dbq._db_get_jira_ticket("TCOC-E1")
    assert row is not None
    assert row["eligibility"] == "not_eligible"
    assert "consult" in (row.get("eligibility_reason") or "")