# -*- coding: utf-8 -*-
"""
UNIT AND STRUCTURAL TESTS: AR88-JOINT-FIX-01
Validates the state contract and internal incident wiring:
1. PASS does not generate an incident.
2. BLOCKED does not generate an incident.
3. UNPROVEN does not generate an incident.
4. FAIL with insufficient evidence (no assertion error or traceback) is rejected.
5. FAIL with boundary escape (outside workspace) is rejected.
6. FAIL targeting protected baselines or critical files is rejected.
7. Authentic FAIL within workspace with genuine evidence produces valid incident & bundle.
8. Authentic FAIL incident passes through CircuitTracer and RootCauseAnalyzer without fabricating mission data.
9. RootCauseAnalyzer with UNPROVEN cause halts patch generation cleanly.
"""
import os
import sys
import pytest

WS = r"C:\Users\intel\AppData\Local\OptimusRuntime\Labs\AR74\12_ar88_authority_operational_closure\functional_detector_nobypass_ws"
sys.path.insert(0, WS)

from app.remediation.self_repair.functional_assessor import (
    FunctionalAssessmentStatus,
    FunctionalEvaluationResult,
)
from app.remediation.self_repair.functional_diagnostic_adapter import (
    FunctionalDiagnosticAdapter,
    _compute_sha256,
)
from app.remediation.self_repair.circuit import CircuitTracer
from app.remediation.self_repair.analyzer import RootCauseAnalyzer
from app.remediation.self_repair.planner import RepairPlanner
from app.remediation.self_repair.schemas import (
    CircuitStatus,
    IncidentFailureType,
    RootCauseClassification,
)


def test_pass_does_not_generate_incident():
    res = FunctionalEvaluationResult(
        contract_id="contract_test_pass",
        component_name="CircuitTracer",
        target_file_rel="app/remediation/self_repair/circuit.py",
        file_sha256="DUMMY",
        status=FunctionalAssessmentStatus.PASS,
        duration_ms=10.0,
    )
    valid, reason, result_tuple = FunctionalDiagnosticAdapter.validate_and_convert_failure(res, WS)
    assert not valid
    assert "REJECTED_STATUS" in reason
    assert result_tuple is None
    assert FunctionalDiagnosticAdapter.failure_result_to_incident_and_evidence(res, WS) is None


def test_blocked_does_not_generate_incident():
    res = FunctionalEvaluationResult(
        contract_id="contract_test_blocked",
        component_name="CircuitTracer",
        target_file_rel="app/remediation/self_repair/circuit.py",
        file_sha256="DUMMY",
        status=FunctionalAssessmentStatus.BLOCKED,
        duration_ms=1.0,
        inconclusive_reason="FAIL_CLOSED: OS isolation unverified",
    )
    valid, reason, result_tuple = FunctionalDiagnosticAdapter.validate_and_convert_failure(res, WS)
    assert not valid
    assert "REJECTED_STATUS" in reason
    assert result_tuple is None
    assert FunctionalDiagnosticAdapter.failure_result_to_incident_and_evidence(res, WS) is None


def test_unproven_does_not_generate_incident():
    res = FunctionalEvaluationResult(
        contract_id="contract_test_unproven",
        component_name="CircuitTracer",
        target_file_rel="app/remediation/self_repair/circuit.py",
        file_sha256="DUMMY",
        status=FunctionalAssessmentStatus.UNPROVEN,
        duration_ms=5000.0,
        inconclusive_reason="Evaluation timed out",
    )
    valid, reason, result_tuple = FunctionalDiagnosticAdapter.validate_and_convert_failure(res, WS)
    assert not valid
    assert "REJECTED_STATUS" in reason
    assert result_tuple is None
    assert FunctionalDiagnosticAdapter.failure_result_to_incident_and_evidence(res, WS) is None


def test_fail_with_insufficient_evidence_rejected():
    res = FunctionalEvaluationResult(
        contract_id="contract_circuit_tracer_downstream_break",
        component_name="CircuitTracer",
        target_file_rel="app/remediation/self_repair/circuit.py",
        file_sha256=_compute_sha256(os.path.join(WS, "app/remediation/self_repair/circuit.py")),
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=5.0,
        assertion_error=None,
        stack_trace=None,
    )
    valid, reason, result_tuple = FunctionalDiagnosticAdapter.validate_and_convert_failure(res, WS)
    assert not valid
    assert "REJECTED_INSUFFICIENT_EVIDENCE" in reason
    assert result_tuple is None


def test_fail_with_boundary_escape_rejected():
    # Attempting to use authorized contract ID but pointing to path outside workspace
    # Registry check verifies that component and target match canonical contract definition
    res = FunctionalEvaluationResult(
        contract_id="contract_circuit_tracer_downstream_break",
        component_name="CircuitTracer",
        target_file_rel="../../some_external_file.py",
        file_sha256="DUMMY",
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=5.0,
        assertion_error="AssertionError: external",
    )
    valid, reason, result_tuple = FunctionalDiagnosticAdapter.validate_and_convert_failure(res, WS)
    assert not valid
    assert "REJECTED_PROVENANCE_MISMATCH" in reason
    assert result_tuple is None


def test_fail_with_protected_target_rejected():
    # Attempting to target protected engine path using unauthorized contract
    res = FunctionalEvaluationResult(
        contract_id="contract_test_protected",
        component_name="Engine",
        target_file_rel="app/remediation/self_repair/engine.py",
        file_sha256="DUMMY",
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=5.0,
        assertion_error="AssertionError: engine test",
    )
    valid, reason, result_tuple = FunctionalDiagnosticAdapter.validate_and_convert_failure(res, WS)
    assert not valid
    assert "REJECTED_UNAUTHORIZED_CONTRACT" in reason
    assert result_tuple is None


def test_fail_with_unauthorized_contract_rejected():
    res = FunctionalEvaluationResult(
        contract_id="contract_arbitrary_unregistered",
        component_name="CircuitTracer",
        target_file_rel="app/remediation/self_repair/circuit.py",
        file_sha256=_compute_sha256(os.path.join(WS, "app/remediation/self_repair/circuit.py")),
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=5.0,
        assertion_error="AssertionError: arbitrary",
    )
    valid, reason, result_tuple = FunctionalDiagnosticAdapter.validate_and_convert_failure(res, WS)
    assert not valid
    assert "REJECTED_UNAUTHORIZED_CONTRACT" in reason
    assert result_tuple is None


def test_fail_with_provenance_mismatch_component_rejected():
    res = FunctionalEvaluationResult(
        contract_id="contract_circuit_tracer_downstream_break",
        component_name="WrongComponent",
        target_file_rel="app/remediation/self_repair/circuit.py",
        file_sha256=_compute_sha256(os.path.join(WS, "app/remediation/self_repair/circuit.py")),
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=5.0,
        assertion_error="AssertionError: mismatch",
    )
    valid, reason, result_tuple = FunctionalDiagnosticAdapter.validate_and_convert_failure(res, WS)
    assert not valid
    assert "REJECTED_PROVENANCE_MISMATCH" in reason
    assert result_tuple is None


def test_authentic_fail_creates_valid_incident_and_evidence():
    target_rel = "app/remediation/self_repair/circuit.py"
    target_abs = os.path.join(WS, target_rel)
    current_hash = _compute_sha256(target_abs)

    res = FunctionalEvaluationResult(
        contract_id="contract_circuit_tracer_downstream_break",
        component_name="CircuitTracer",
        target_file_rel=target_rel,
        file_sha256=current_hash,
        status=FunctionalAssessmentStatus.FAIL,
        duration_ms=35.0,
        assertion_error="AssertionError: effector expected NOT_REACHED, got CircuitStatus.UNKNOWN",
        stack_trace="Traceback (most recent call last):\n  File 'test.py', line 10\nAssertionError: ...",
        stdout="__START__",
    )

    valid, reason, result_tuple = FunctionalDiagnosticAdapter.validate_and_convert_failure(res, WS)
    assert valid, f"Expected valid conversion, got rejection: {reason}"
    assert result_tuple is not None

    event, incident, bundle = result_tuple

    # Verify structural integrity
    assert incident.failure_type == IncidentFailureType.FAILED_TEST
    assert incident.source_component == "CircuitTracer"
    assert bundle.target_file == target_rel
    assert len(bundle.source_excerpts) == 1
    assert bundle.source_excerpts[0]["sha256"] == current_hash

    # Verify circuit tracing
    tracer = CircuitTracer()
    trace = tracer.trace(incident=incident, evidence=bundle)
    assert trace is not None

    # Verify RootCauseAnalyzer identification
    analyzer = RootCauseAnalyzer()
    classif = analyzer.analyze(incident=incident, evidence=bundle, trace=trace, workspace_root=WS)
    assert classif.defective_module == "app/remediation/self_repair/circuit.py"
    assert classif.responsible_function == "CircuitTracer.trace"
    assert classif.confidence == "HIGH"


def test_unproven_root_cause_halts_patch_planning():
    # If root cause is UNPROVEN, planner must not produce actionable patch
    planner = RepairPlanner()
    unproven_classif = RootCauseClassification(
        incident_id="inc_test_unproven",
        symptom="Unknown functional anomaly",
        direct_failure="UNKNOWN",
        root_cause="UNPROVEN",
        proven=False,
    )
    conv = FunctionalDiagnosticAdapter.failure_result_to_incident_and_evidence(
        FunctionalEvaluationResult(
            contract_id="contract_circuit_tracer_downstream_break",
            component_name="CircuitTracer",
            target_file_rel="app/remediation/self_repair/circuit.py",
            file_sha256=_compute_sha256(os.path.join(WS, "app/remediation/self_repair/circuit.py")),
            status=FunctionalAssessmentStatus.FAIL,
            duration_ms=1.0,
            assertion_error="Dummy error",
        ),
        WS,
    )
    assert conv is not None
    incident = conv[1]
    proposal = planner.plan_repair(
        incident=incident,
        root_cause_info=unproven_classif,
    )
    assert not proposal.repair_authorized
    assert proposal.root_cause == "UNPROVEN"
    assert proposal.files_allowed == []
    assert "Root cause unproven" in proposal.exact_change_scope