"""HTTP endpoints for the Regulatory Reasoning Engine (spec §7).

Thin handlers — all reasoning lives in `compliance.reasoning.*`. No DB, no RAG;
pure deterministic rule evaluation.

    POST /reasoning/scope                      -> which regulations apply + missing facts
    POST /reasoning/obligations                -> obligations, overlaps, multi-evidence
    POST /reasoning/implementation-assessment  -> claim coverage per obligation
    POST /reasoning/interpretation-assessment  -> verdict on a customer interpretation
"""

from __future__ import annotations

from fastapi import APIRouter

from compliance.reasoning import (
    assess_implementation,
    assess_interpretation,
    derive_obligations,
    discover_scope,
)
from compliance.reasoning.schemas import (
    ImplementationRequest,
    ImplementationResponse,
    InterpretationRequest,
    InterpretationResponse,
    ObligationsRequest,
    ObligationsResponse,
    ScopeRequest,
    ScopeResponse,
)

router = APIRouter(prefix="/reasoning", tags=["reasoning"])


@router.post("/scope", response_model=ScopeResponse)
def scope_discovery(req: ScopeRequest) -> ScopeResponse:
    scope = discover_scope(req.product_profile)
    return ScopeResponse(
        regulatory_scope=scope,
        missing_facts=scope.missing_facts,
        confidence=scope.confidence,
    )


@router.post("/obligations", response_model=ObligationsResponse)
def applicable_obligations(req: ObligationsRequest) -> ObligationsResponse:
    return derive_obligations(req.product_profile, req.regulatory_scope)


@router.post("/implementation-assessment", response_model=ImplementationResponse)
def implementation_assessment(req: ImplementationRequest) -> ImplementationResponse:
    return assess_implementation(req.product_profile, req.customer_claim)


@router.post("/interpretation-assessment", response_model=InterpretationResponse)
def interpretation_assessment(req: InterpretationRequest) -> InterpretationResponse:
    result = assess_interpretation(req.customer_interpretation, req.product_profile)
    return InterpretationResponse(
        assessment=result.assessment,
        affected_regulations=result.affected_regulations,
        affected_obligations=result.affected_obligations,
        corrected_interpretation=result.corrected_interpretation,
        risks=result.risks,
        legal_basis_refs=result.legal_basis_refs,
        explanation=result.explanation,
        confidence=result.confidence,
    )