from __future__ import annotations

from typing import Any

from app.models.schemas import DossierCoverageResponse

from .coverage import (
    build_fallback_project_coverage_response,
    coverage_project_payload,
    load_coverage_index_with_status,
    load_coverage_manifest,
)


class ServiceCoverageHelpersMixin:
    """Session loaders, manifest readers, and coverage response builders."""

    def _build_fallback_project_coverage_response(
        self,
        *,
        project_code: str,
        message: str,
    ) -> DossierCoverageResponse:
        return build_fallback_project_coverage_response(
            project_code=project_code,
            manifest_path=self._manifest_path,
            message=message,
            ensure_list=self._ensure_list,
            string_int_dict=self._string_int_dict,
        )

    def _load_sessions(
        self, project_code: str | None = None
    ) -> tuple[list[dict[str, Any]], str, bool, str]:
        """Đọc session an toàn."""
        if not self._postgres_client.is_enabled():
            return (
                [],
                "fallback",
                True,
                "DATABASE_URL chưa được cấu hình; remediation planning đang trả danh sách rỗng an toàn.",
            )
        try:
            sessions = self._postgres_client.fetch_dossier_review_sessions(
                project_code=project_code
            )
        except Exception as exc:
            return (
                [],
                "fallback",
                True,
                f"Không thể tải dossier review sessions từ PostgreSQL: {exc}",
            )
        return (
            sessions,
            "postgres",
            False,
            "Remediation planning baseline đang được suy diễn từ dossier review workflow trong PostgreSQL.",
        )

    def _load_coverage_manifest(self) -> dict[str, Any]:
        return load_coverage_manifest(self._manifest_path)

    def _load_coverage_index_with_status(
        self,
    ) -> tuple[dict[str, dict[str, Any]], bool, str | None]:
        return load_coverage_index_with_status(self._manifest_path, self._ensure_list)

    def _coverage_project_payload(self, item: dict[str, Any]):
        return coverage_project_payload(item, self._ensure_list, self._string_int_dict)

    def _matches_build_request(
        self, *, finding: dict[str, Any], payload: RemediationBuildRequest
    ) -> bool:
        """Kiểm tra finding có match request."""
        if (
            payload.finding_id
            and str(finding.get("finding_id") or "") != payload.finding_id
        ):
            return False
        if (
            payload.finding_code
            and str(finding.get("finding_code") or "") != payload.finding_code
        ):
            return False
        if (
            payload.document_type
            and str(finding.get("document_type") or "") != payload.document_type
        ):
            return False
        return True