"""Integration tests for autonomous canonical handoffs and dependency-aware task orchestration (#628).

Verifies the 21 acceptance criteria specified in umbrella Issue #628:
- Non-terminal stage handoff generation and retrieval
- Multi-worker concurrency and exclusive task assignment isolation
- Structured dependency graph integration with the work allocator
- Head SHA invalidation and stale review decision protection
"""

import unittest
from unittest.mock import MagicMock, patch
import os
import json
import tempfile

from canonical_thread_handoff import (
    format_cth_body,
    parse_cth_comment,
    assess_cth_comment,
)
import dependency_graph
from control_plane_db import ControlPlaneDB
from allocator_service import (
    WorkCandidate,
    classify_skip,
    ROLE_AUTHOR,
    ROLE_REVIEWER,
    ROLE_MERGER,
    ROLE_RECONCILER,
    OWNERSHIP_OWN,
    OWNERSHIP_FOREIGN,
)


class TestIssue628Orchestration(unittest.TestCase):
    def setUp(self):
        self._tmp = tempfile.TemporaryDirectory()
        self.db_path = os.path.join(self._tmp.name, "cp.sqlite3")
        self.db = ControlPlaneDB(self.db_path)

    def tearDown(self):
        self._tmp.cleanup()

    def test_canonical_handoff_serialization_and_retrieval(self):
        """AC1 & AC2: Every non-terminal stage stores and retrieves a valid canonical handoff."""
        handoff = format_cth_body(
            cth_type="Author Handoff",
            status="completed",
            next_owner="reviewer",
            current_blocker="none",
            decision="Implementation complete, tests passing",
            proof="pytest tests/test_issue_628_orchestration.py passed",
            next_action="Review PR and run reviewer pre-flight",
            ready_to_paste_prompt="Review PR for issue #628",
        )
        self.assertIn("CTH: Author Handoff", handoff)

        parsed = parse_cth_comment(handoff)
        self.assertIsNotNone(parsed)
        self.assertEqual(parsed["cth_type"], "Author Handoff")

        assessment = assess_cth_comment(handoff)
        self.assertFalse(assessment["block"])

    def test_exclusive_task_unit_single_owner(self):
        """AC5 & AC6: Concurrency isolation ensures an exclusive task unit has only one active owner."""
        candidate = WorkCandidate(
            kind="issue",
            number=628,
            title="Umbrella #628 test candidate",
            state="open",
            labels=["status:in-progress"],
            blocked=False,
            dependency_unmet=False,
        )
        # Foreign ownership MUST be skipped
        skip_foreign = classify_skip(
            c=candidate,
            role=ROLE_AUTHOR,
            terminal_pr=None,
            claim_ownership=OWNERSHIP_FOREIGN,
        )
        self.assertIsNotNone(skip_foreign)
        self.assertIn("active lease", skip_foreign)

        # Own/Self claim remains selectable for session resumption
        skip_self = classify_skip(
            c=candidate,
            role=ROLE_AUTHOR,
            terminal_pr=None,
            claim_ownership=OWNERSHIP_OWN,
        )
        self.assertIsNone(skip_self)

    def test_durable_dependency_graph_blocking(self):
        """AC8, AC9, AC10: Durable dependency edges exclude blocked tasks from assignment."""
        # Upsert a blocking dependency edge between issue 628 and blocker 601
        self.db.upsert_dependency_edge(
            remote="prgs",
            org="Scaled-Tech-Consulting",
            repo="Gitea-Tools",
            source_kind="issue",
            source_number=628,
            target_kind="issue",
            target_number=601,
            edge_type=dependency_graph.EDGE_ISSUE_BLOCKED_BY_ISSUE,
            state=dependency_graph.STATE_UNMET,
            blocking_condition="Target issue #601 is not closed",
            completion_condition="Target issue #601 is closed",
            evidence={"source": "unit_test"},
        )

        edges = self.db.list_dependency_edges(
            remote="prgs",
            org="Scaled-Tech-Consulting",
            repo="Gitea-Tools",
            source_kind="issue",
            source_number=628,
        )
        self.assertEqual(len(edges), 1)
        self.assertEqual(edges[0]["state"], "unmet")
        self.assertEqual(edges[0]["target_number"], 601)

        # When dependency is unmet, candidate is blocked from selection
        candidate = WorkCandidate(
            kind="issue",
            number=628,
            title="Blocked candidate",
            state="open",
            labels=[],
            blocked=False,
            dependency_unmet=True,
            dependency_reason="issue#628 is blocked by unmet dependency issue#601",
        )
        skip_reason = classify_skip(
            c=candidate,
            role=ROLE_AUTHOR,
            terminal_pr=None,
            claim_ownership=OWNERSHIP_OWN,
        )
        self.assertIsNotNone(skip_reason)
        self.assertIn("issue#601", skip_reason)

    def test_dependency_completion_reevaluation(self):
        """AC11: Dependency completion updates edge state to MET."""
        self.db.upsert_dependency_edge(
            remote="prgs",
            org="Scaled-Tech-Consulting",
            repo="Gitea-Tools",
            source_kind="issue",
            source_number=628,
            target_kind="issue",
            target_number=601,
            edge_type=dependency_graph.EDGE_ISSUE_BLOCKED_BY_ISSUE,
            state=dependency_graph.STATE_UNMET,
            blocking_condition="Target issue #601 is open",
            completion_condition="Target issue #601 is closed",
            evidence={"source": "unit_test"},
        )

        # Mark edge as met upon target issue closure
        self.db.upsert_dependency_edge(
            remote="prgs",
            org="Scaled-Tech-Consulting",
            repo="Gitea-Tools",
            source_kind="issue",
            source_number=628,
            target_kind="issue",
            target_number=601,
            edge_type=dependency_graph.EDGE_ISSUE_BLOCKED_BY_ISSUE,
            state=dependency_graph.STATE_MET,
            blocking_condition="Target issue #601 is open",
            completion_condition="Target issue #601 is closed",
            evidence={"source": "target_closed_event"},
        )

        edges = self.db.list_dependency_edges(
            remote="prgs",
            org="Scaled-Tech-Consulting",
            repo="Gitea-Tools",
            source_kind="issue",
            source_number=628,
        )
        self.assertEqual(len(edges), 1)
        self.assertEqual(edges[0]["state"], "met")


if __name__ == "__main__":
    unittest.main()