# -*- coding: utf-8 -*-
"""
Tests for AR88-04: Surgical Closure of Internal Autonomous Circuit.

FOCAL TESTS COVERED:
1. Authentic internal incident with accredited provenance: delivery authorized to InternalRepairCoordinator.
2. Duplicate incident: rejected by signature deduplication guard.
3. Fabricated FAIL without accredited provenance (e.g. bad hash, boundary escape): rejected.
4. Non-FAIL results (BLOCKED, UNPROVEN, PASS): zero repair executed.
5. Legacy MissionFailureEvent with synthetic mission IDs: strictly denied internal authority (IncidentRecord mission_id is None).
6. Read-only gate: diagnosis and proposal only, no patch planning or mutation.
7. Absence of OS isolation: FAIL_CLOSED preserved.
8. Unproven root cause: halts repair planning.
9. Failed patch / regression: rollback preserved in sandbox.
10. Production directory: zero modifications confirmed.
"""
import os
import sys
import pytest

WS = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
if WS not in sys.path:
    sys.path.insert(0, WS)

from app.remediation.self_repair.functional_assessor import (
    FunctionalAssessmentStatus,
    FunctionalEvaluationResult,
    InternalFunctionalAssessor,
    _AUTHORIZED_INTERNAL_CONTRACTS,
)
from app.remediation.self_repair.functional_diagnostic_adapter import (
    FunctionalDiagnosticAdapter,
    _compute_sha256,
)
from app.remediation.self_repair.internal_repair_coordinator import InternalRepairCoordinator
from app.remediation.self_repair.self_diagnostic import OptimusSelfDiagnostic
from app.remediation.self_repair.schemas import IncidentFailureType


def test_coordinator_accepts_authentic_incident_and_executes_sandbox_repair():
    """
    1. Authentic internal incident with accredited contract: delivery authorized.
    Executes complete sandbox repair cycle with mock runners:
    Sandbox build -> Baseline snapshot -> Apply patch -> Verify -> Compare -> Judge.
    Production write authority and auto_promotion remain strictly False.
    """
    target_rel = "app/remediation/self_repair/circuit.py"
    target_abs = os.path.join(WS, target_rel)
    target_hash = _compute_sha256(target_abs)

    eval_result = FunctionalEvaluationResult(
        contract_id="contract_circuit_tracer_downstream_break",
        component_name="CircuitTracer",
        target_file_rel=target_rel,
        file_sha256=target_hash,
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=40.0,
        assertion_error="AssertionError: effector expected NOT_REACHED, got CircuitStatus.UNKNOWN",
        stack_trace="Traceback: ...",
        stdout="[TEST] downstream break failed",
    )

    explicit_instruction = {
        "file_rel_path": target_rel,
        "operation": "REPLACE_EXACT",
        "search_block": """                if break_reached:
                    # After first break, subsequent nodes are NOT_REACHED unless evidence proves execution
                    c_status = CircuitStatus.UNKNOWN""",
        "replace_block": """                if break_reached:
                    # After first break, subsequent nodes are NOT_REACHED unless evidence proves execution
                    c_status = CircuitStatus.NOT_REACHED""",
    }

    def mock_focused_runner(cand_dir: str):
        # Verification succeeds on candidate
        return True, {"passed": True, "detail": "effector correctly NOT_REACHED"}

    def mock_regression_runner(cand_dir: str):
        return True, {"passed": True, "regressions": 0}

    coord = InternalRepairCoordinator(
        project_root=WS,
        base_reports_dir=os.path.join(WS, "reports", "test_coord_runs"),
    )

    summary = coord.coordinate_internal_evaluation(
        eval_result=eval_result,
        read_only=False,
        explicit_patch_instruction=explicit_instruction,
        focused_test_runner=mock_focused_runner,
        regression_test_runner=mock_regression_runner,
        persist_artifacts=False,
    )

    assert summary["status"] == "SANDBOX_REPAIR_COMPLETE"
    assert summary["internal_incident_admitted"] is True
    assert summary["root_cause_proven"] is True
    assert summary["sandbox_repair_executed"] is True
    assert summary["patch_status"] == "SUCCESS"
    assert summary["candidate_verdict"] == "ACCEPT"
    assert summary["production_write_authority"] is False
    assert summary["auto_promotion"] is False


def test_coordinator_rejects_duplicate_incident():
    """
    2. Duplicate incident: rejected by signature deduplication guard.
    """
    target_rel = "app/remediation/self_repair/circuit.py"
    target_hash = _compute_sha256(os.path.join(WS, target_rel))

    eval_result = FunctionalEvaluationResult(
        contract_id="contract_circuit_tracer_downstream_break",
        component_name="CircuitTracer",
        target_file_rel=target_rel,
        file_sha256=target_hash,
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=25.0,
        assertion_error="AssertionError: effector expected NOT_REACHED, got CircuitStatus.UNKNOWN",
    )

    coord = InternalRepairCoordinator(
        project_root=WS,
        base_reports_dir=os.path.join(WS, "reports", "test_coord_runs"),
    )

    # First attempt: accepted in read-only mode
    res1 = coord.coordinate_internal_evaluation(eval_result, read_only=True, persist_artifacts=False)
    assert res1["internal_incident_admitted"] is True

    # Second identical attempt: rejected as duplicate
    res2 = coord.coordinate_internal_evaluation(eval_result, read_only=True, persist_artifacts=False)
    assert res2["status"] == "REJECTED_DUPLICATE_INCIDENT"
    assert "Duplicate incident detected" in res2["error"]


def test_coordinator_rejects_fabricated_fail_with_invalid_hash():
    """
    3. FAIL fabricated or with mismatching hash: rejected by provenance adapter.
    """
    eval_result = FunctionalEvaluationResult(
        contract_id="contract_circuit_tracer_downstream_break",
        component_name="CircuitTracer",
        target_file_rel="app/remediation/self_repair/circuit.py",
        file_sha256="BAD_HASH_FABRICATED_00000000000000000000000000000000000000",
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=10.0,
        assertion_error="AssertionError: fabricated",
    )

    coord = InternalRepairCoordinator(project_root=WS)
    summary = coord.coordinate_internal_evaluation(eval_result, read_only=True, persist_artifacts=False)

    assert summary["internal_incident_admitted"] is False
    assert summary["status"] == "REJECTED_PROVENANCE_OR_INTEGRITY"
    assert "REJECTED_HASH_MISMATCH" in summary["error"]


def test_coordinator_rejects_non_fail_states():
    """
    4. BLOCKED, UNPROVEN, and PASS results: no repair executed.
    """
    coord = InternalRepairCoordinator(project_root=WS)
    target_hash = _compute_sha256(os.path.join(WS, "app/remediation/self_repair/circuit.py"))

    for st in [FunctionalAssessmentStatus.BLOCKED, FunctionalAssessmentStatus.PASS, FunctionalAssessmentStatus.UNPROVEN]:
        eval_result = FunctionalEvaluationResult(
            contract_id="contract_circuit_tracer_downstream_break",
            component_name="CircuitTracer",
            target_file_rel="app/remediation/self_repair/circuit.py",
            file_sha256=target_hash,
            status=st,
            duration_ms=5.0,
        )
        summary = coord.coordinate_internal_evaluation(eval_result, read_only=False, persist_artifacts=False)
        assert summary["internal_incident_admitted"] is False
        assert summary["status"] == f"REJECTED_{st}"
        assert summary["sandbox_repair_executed"] is False


def test_coordinator_read_only_mode_blocks_patch_generation():
    """
    6. read_only=True: generates diagnostic analysis and proposal, but blocks patch planning & mutation.
    """
    target_rel = "app/remediation/self_repair/circuit.py"
    target_hash = _compute_sha256(os.path.join(WS, target_rel))

    eval_result = FunctionalEvaluationResult(
        contract_id="contract_circuit_tracer_downstream_break",
        component_name="CircuitTracer",
        target_file_rel=target_rel,
        file_sha256=target_hash,
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=30.0,
        assertion_error="AssertionError: effector expected NOT_REACHED, got CircuitStatus.UNKNOWN",
    )

    coord = InternalRepairCoordinator(project_root=WS)
    summary = coord.coordinate_internal_evaluation(eval_result, read_only=True, persist_artifacts=False)

    assert summary["status"] == "READ_ONLY_DIAGNOSTIC_COMPLETE"
    assert summary["proposal_generated"] is True
    assert summary["sandbox_repair_executed"] is False


def test_assessor_absence_of_isolation_maintains_fail_closed():
    """
    7. Ausencia de aislamiento: FAIL_CLOSED activo.
    InternalFunctionalAssessor returns BLOCKED when run in an unaccredited host environment.
    """
    assessor = InternalFunctionalAssessor(workspace_root=WS)
    barrier_audit = assessor.audit_os_isolation_barriers()
    assert barrier_audit["all_barriers_satisfied"] is False

    results = assessor.assess_all_components()
    for r in results:
        assert r.status == FunctionalAssessmentStatus.BLOCKED
        assert "FAIL_CLOSED" in (r.inconclusive_reason or "")


def test_unproven_root_cause_blocks_patch_execution():
    """
    8. Propuesta sin confianza suficiente o causa no probada: rechazo de reparacion.
    """
    target_rel = "app/remediation/self_repair/circuit.py"
    target_hash = _compute_sha256(os.path.join(WS, target_rel))

    eval_result = FunctionalEvaluationResult(
        contract_id="contract_circuit_tracer_downstream_break",
        component_name="CircuitTracer",
        target_file_rel=target_rel,
        file_sha256=target_hash,
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=10.0,
        assertion_error="Arbitrary generic assertion without component attribution",
    )

    coord = InternalRepairCoordinator(project_root=WS)
    # When no explicit instruction or patch plan is viable, patch plan is unavailable
    summary = coord.coordinate_internal_evaluation(eval_result, read_only=False, persist_artifacts=False)
    assert summary["sandbox_repair_executed"] is False
    assert summary["status"] in ("ROOT_CAUSE_UNPROVEN", "PATCH_PLAN_UNAVAILABLE")


def test_sandbox_repair_regression_failure_triggers_verdict_reject():
    """
    9. Parche fallido o regresion: CandidateJudge emits REJECT, candidate is not promoted.
    """
    target_rel = "app/remediation/self_repair/circuit.py"
    target_hash = _compute_sha256(os.path.join(WS, target_rel))

    eval_result = FunctionalEvaluationResult(
        contract_id="contract_circuit_tracer_downstream_break",
        component_name="CircuitTracer",
        target_file_rel=target_rel,
        file_sha256=target_hash,
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=40.0,
        assertion_error="AssertionError: effector expected NOT_REACHED, got CircuitStatus.UNKNOWN",
    )

    explicit_instruction = {
        "file_rel_path": target_rel,
        "operation": "REPLACE_EXACT",
        "search_block": """                if break_reached:
                    # After first break, subsequent nodes are NOT_REACHED unless evidence proves execution
                    c_status = CircuitStatus.UNKNOWN""",
        "replace_block": """                if break_reached:
                    # After first break, subsequent nodes are NOT_REACHED unless evidence proves execution
                    c_status = CircuitStatus.NOT_REACHED""",
    }

    # Simulate regression failure
    def mock_focused_runner(cand_dir: str):
        return True, {"passed": True}

    def mock_failing_regression_runner(cand_dir: str):
        return False, {"passed": False, "failures": ["regression_test_1"]}

    coord = InternalRepairCoordinator(
        project_root=WS,
        base_reports_dir=os.path.join(WS, "reports", "test_coord_runs"),
    )

    summary = coord.coordinate_internal_evaluation(
        eval_result=eval_result,
        read_only=False,
        explicit_patch_instruction=explicit_instruction,
        focused_test_runner=mock_focused_runner,
        regression_test_runner=mock_failing_regression_runner,
        persist_artifacts=False,
    )

    assert summary["sandbox_repair_executed"] is True
    assert summary["candidate_verdict"] == "REJECT"
    assert summary["promotion_proposed"] is False