from __future__ import annotations

"""Helper and normalization utilities for case management."""

from typing import Any


class CaseHelpersMixin:
    """Helper and normalization utilities for case management."""

    def _build_case_id(*, review_id: str, finding: dict[str, Any]) -> str:
        finding_id = str(finding.get("finding_id") or "")
        finding_code = str(finding.get("finding_code") or "")
        return finding_id or finding_code or f"{review_id}:finding"

    def _build_expected_outcome(finding: dict[str, Any]) -> str:
        document_type = finding.get("document_type")
        dossier_stage = finding.get("dossier_stage")
        if document_type and dossier_stage:
            return f"Bổ sung {document_type} hợp lệ để gỡ vướng tại giai đoạn {dossier_stage}."
        if document_type:
            return f"Bổ sung {document_type} hợp lệ."
        return "Gỡ thiếu sót hồ sơ và cập nhật trạng thái finding."

    def _build_success_criteria(finding: dict[str, Any]) -> list[str]:
        criteria = [
            "Có bằng chứng bổ sung hợp lệ",
            "Finding được chuyển sang trạng thái đã xử lý hoặc chờ xác minh",
        ]
        if finding.get("is_blocking"):
            criteria.append("Không còn chặn readiness hoặc luồng xử lý hồ sơ")
        return criteria

    def _derive_priority(severity: Any, impact_level: Any, is_blocking: Any) -> str:
        normalized_severity = str(severity or "").strip().lower()
        normalized_impact = str(impact_level or "").strip().lower()
        if (
            bool(is_blocking)
            or normalized_severity in {"critical", "high"}
            or normalized_impact in {"critical", "high"}
        ):
            return "high"
        if normalized_severity in {"medium", "moderate"} or normalized_impact in {
            "medium",
            "moderate",
        }:
            return "medium"
        return "low"

    def _derive_operational_impact(finding: dict[str, Any]) -> str:
        if bool(finding.get("is_blocking")):
            return "blocking"
        impact_level = str(finding.get("impact_level") or "").strip()
        return impact_level or "tracked"

    def _derive_confidence_score(finding: dict[str, Any]) -> float | None:
        evidences = finding.get("evidences") or []
        scores = [
            float(item.get("confidence_score"))
            for item in evidences
            if item.get("confidence_score") is not None
        ]
        if not scores:
            return None
        return round(sum(scores) / len(scores), 4)

    def _derive_evidence_strength(confidence_score: Any) -> str | None:
        if confidence_score is None:
            return None
        try:
            value = float(confidence_score)
        except (TypeError, ValueError):
            return None
        if value >= 0.85:
            return "strong"
        if value >= 0.6:
            return "medium"
        return "weak"

    def _merge_metadata(*parts: Any) -> dict[str, Any]:
        merged: dict[str, Any] = {}
        for part in parts:
            if isinstance(part, dict):
                merged.update(part)
        return merged

    def _ensure_list(value: Any) -> list[dict[str, Any]]:
        if isinstance(value, list):
            return [item for item in value if isinstance(item, dict)]
        return []

    def _ensure_dict(value: Any) -> dict[str, Any]:
        if isinstance(value, dict):
            return value
        return {}

    def _ensure_string_list(value: Any) -> list[str]:
        if isinstance(value, list):
            return [str(item) for item in value if str(item or "").strip()]
        if isinstance(value, str) and value.strip():
            return [value.strip()]
        return []