"""Duplicate ticket detection tests."""

from __future__ import annotations

import pytest

from packages.db.models import WorkflowState
from packages.integrations.duplicates import (
    candidate_search_jql,
    duplicate_review_comment_body,
)
from packages.integrations.jira import JiraIssue
from packages.integrations.jira_webhook import (
    duplicate_review_decision,
    normalize_jira_webhook,
    should_resume_duplicate_review,
)
from packages.orchestrator.graph import Orchestrator, create_run
from tests.conftest import load_story


def test_candidate_search_jql():
    assert 'project = "AN" AND key != AN-45' in candidate_search_jql("AN", "AN-45")


def test_duplicate_review_comment_mentions_original():
    body = duplicate_review_comment_body("AN-12", "Same field request")
    assert "AN-12" in body
    assert "continue" in body
    assert "duplicate" in body


def test_duplicate_review_decision_keywords():
    assert (
        duplicate_review_decision(
            normalize_jira_webhook(
                {
                    "webhookEvent": "comment_created",
                    "issue": {"key": "AN-1", "fields": {}},
                    "comment": {"body": "please continue with this"},
                },
                "d1",
            )
        )
        == "continue"
    )
    assert (
        duplicate_review_decision(
            normalize_jira_webhook(
                {
                    "webhookEvent": "comment_created",
                    "issue": {"key": "AN-1", "fields": {}},
                    "comment": {"body": "close as duplicate"},
                },
                "d2",
            )
        )
        == "close"
    )
    assert (
        duplicate_review_decision(
            normalize_jira_webhook(
                {
                    "webhookEvent": "comment_created",
                    "issue": {"key": "AN-1", "fields": {}},
                    "comment": {"body": "duplicate"},
                },
                "d3",
            )
        )
        == "close"
    )
    assert (
        duplicate_review_decision(
            normalize_jira_webhook(
                {
                    "webhookEvent": "comment_created",
                    "issue": {"key": "AN-1", "fields": {}},
                    "comment": {"body": "looks fine"},
                },
                "d4",
            )
        )
        is None
    )


def test_should_resume_duplicate_review():
    event = normalize_jira_webhook(
        {
            "webhookEvent": "comment_created",
            "issue": {"key": "AN-1", "fields": {"project": {"key": "AN"}}},
            "comment": {"author": {"accountId": "human-1"}, "body": "continue"},
        },
        "d5",
    )
    assert should_resume_duplicate_review(event, WorkflowState.DUPLICATE_REVIEW) is True
    assert should_resume_duplicate_review(event, WorkflowState.DESIGN_REVIEW) is False


@pytest.mark.asyncio
async def test_duplicate_pause_then_continue(db_session, mock_jira, artifacts_tmpdir):
    original = load_story("SALES-101")
    mock_jira.seed(original)

    dup = JiraIssue(
        key="SALES-201",
        summary=original.summary,
        description=original.description,
        status="Ready for Agent",
        issue_type="Story",
        labels=["agent-nova"],
        acceptance_criteria=list(original.acceptance_criteria),
        project_key="SALES",
    )
    mock_jira.seed(dup)

    run = await create_run(db_session, dup.key)
    orch = Orchestrator(db_session, jira=mock_jira)
    paused = await orch.run(run.id)
    assert paused.state == WorkflowState.DUPLICATE_REVIEW
    assert paused.artifacts.get("duplicate_of") == "SALES-101"
    assert any("possible duplicate" in c["body"].lower() for c in mock_jira.comments_posted)
    assert any("SALES-101" in c["body"] for c in mock_jira.comments_posted)

    arts = dict(paused.artifacts or {})
    arts["duplicate_decision"] = "continue"
    paused.artifacts = arts
    await db_session.flush()

    resumed = await orch.run(run.id, resume=True)
    assert resumed.state == WorkflowState.DESIGN_REVIEW
    assert resumed.artifacts.get("duplicate_check_skipped") is True


@pytest.mark.asyncio
async def test_duplicate_pause_then_close(db_session, mock_jira, artifacts_tmpdir):
    original = load_story("SALES-101")
    mock_jira.seed(original)

    dup = JiraIssue(
        key="SALES-202",
        summary=original.summary,
        description=original.description,
        status="Ready for Agent",
        issue_type="Story",
        labels=["agent-nova"],
        acceptance_criteria=list(original.acceptance_criteria),
        project_key="SALES",
    )
    mock_jira.seed(dup)

    run = await create_run(db_session, dup.key)
    orch = Orchestrator(db_session, jira=mock_jira)
    paused = await orch.run(run.id)
    assert paused.state == WorkflowState.DUPLICATE_REVIEW

    arts = dict(paused.artifacts or {})
    arts["duplicate_decision"] = "close"
    paused.artifacts = arts
    await db_session.flush()

    closed = await orch.run(run.id, resume=True)
    assert closed.state == WorkflowState.FAILED
    assert "duplicate" in (closed.error or "").lower()
    assert any("closed as duplicate" in c["body"].lower() for c in mock_jira.comments_posted)