from __future__ import annotations

from typing import Any

from pydantic import BaseModel, Field

from src.domain import (
    DocFormat,
    EntityType,
    Language,
    Method,
    PolicyAction,
    Split,
    Verdict,
    Workflow,
)


class Issue(BaseModel):
    code: str
    message: str
    locator: str | None = None
    severity: str = "error"


class ValidationReport(BaseModel):
    ok: bool
    issues: list[Issue] = Field(default_factory=list)

    def add(self, code: str, message: str, locator: str | None = None, severity: str = "error") -> None:
        self.issues.append(Issue(code=code, message=message, locator=locator, severity=severity))
        if severity == "error":
            self.ok = False


class Span(BaseModel):
    start: int
    end: int
    entity_type: EntityType
    surface: str
    confidence: float
    method: str
    rule_id: str
    language: str = "en"
    workflow: Workflow = Workflow.DETECTED
    finding_id: str = ""
    reason: str = ""
    page: int | None = None
    field: str | None = None


class GoldSpan(BaseModel):
    start: int
    end: int
    entity_type: EntityType
    surface: str
    language: str = "en"
    field: str | None = None


class GoldMeta(BaseModel):
    field: str
    entity_type: EntityType
    surface: str


class LabDocument(BaseModel):
    doc_id: str
    template: str
    family: str
    split: Split
    language: Language
    format: DocFormat
    title: str
    body: str
    metadata: dict[str, str] = Field(default_factory=dict)
    gold_spans: list[GoldSpan] = Field(default_factory=list)
    gold_meta: list[GoldMeta] = Field(default_factory=list)
    hard_negatives: list[str] = Field(default_factory=list)
    description: str = ""
    description_fa: str = ""


class Scenario(BaseModel):
    scenario_id: str
    title: str
    description: str
    description_fa: str
    doc_ids: list[str] = Field(default_factory=list)
    split: str = "mixed"


class MethodScore(BaseModel):
    method: str
    n_docs: int = 0
    n_pred: int = 0
    n_gold: int = 0
    precision: float = 0.0
    recall: float = 0.0
    exact_precision: float = 0.0
    exact_recall: float = 0.0
    over_redaction: float = 0.0
    residual_leak: float = 0.0
    leftover_exports: int = 0
    metadata_leaks: int = 0
    hardneg_hits: int = 0
    by_type: dict[str, dict[str, float]] = Field(default_factory=dict)
    by_language: dict[str, dict[str, float]] = Field(default_factory=dict)


class Kpis(BaseModel):
    n_docs: int = 0
    n_spans: int = 0
    n_review: int = 0
    n_redacted: int = 0
    policy_precision: float = 0.0
    policy_recall: float = 0.0
    baseline_precision: float = 0.0
    baseline_recall: float = 0.0
    residual_leak: float = 0.0
    over_redaction: float = 0.0
    leftover_exports: int = 0
    metadata_leaks: int = 0
    elapsed_ms: int = 0
    engine_profile: str = ""
    policy_action: str = PolicyAction.MASK.value
    pages: int = 0
    chars: int = 0


class CatalogRow(BaseModel):
    scenario_id: str
    method: str
    precision: float = 0.0
    recall: float = 0.0
    over_redaction: float = 0.0
    residual_leak: float = 0.0
    leftover_exports: int = 0
    metadata_leaks: int = 0
    hardneg_hits: int = 0
    n_docs: int = 0


class Finding(BaseModel):
    finding_id: str
    doc_id: str
    entity_type: str
    start: int
    end: int
    surface_preview: str
    confidence: float
    method: str
    rule_id: str
    workflow: str
    reason: str
    language: str = "en"
    observed: str = ""
    inference: str = ""
    action: str = ""


class RunReport(BaseModel):
    run_id: str
    product: str
    schema_id: str
    ruleset_id: str
    code_version: str
    scenario_id: str
    verdict: Verdict
    status_label: str
    kpis: dict[str, Any]
    notes: list[str] = Field(default_factory=list)
    input_hash: str = ""
    method: str = Method.POLICY.value
    policy_action: str = PolicyAction.MASK.value