from __future__ import annotations

"""Operations Case Management service derived from dossier review workflow data."""

from typing import Any

from app.core.postgres import PostgresClient
from app.models.schemas import (
    OperationsActionsResponse,
    OperationsBlockersResponse,
    OperationsCasesResponse,
)

from .actions_builder import ActionsBuilderMixin
from .blockers_builder import BlockersBuilderMixin
from .cases_builder import CasesBuilderMixin
from .follow_up_collector import FollowUpCollectorMixin
from .helpers import CaseHelpersMixin


class OperationsCaseManagementService(
    CaseHelpersMixin,
    FollowUpCollectorMixin,
    BlockersBuilderMixin,
    ActionsBuilderMixin,
    CasesBuilderMixin,
):
    """Build Phase 1 operations cases/actions/blockers from dossier review sessions."""

    def __init__(self, postgres_client: PostgresClient | None = None) -> None:
        self._postgres_client = postgres_client or PostgresClient()

    def list_cases(
        self,
        project_code: str | None = None,
        status: str | None = None,
    ) -> OperationsCasesResponse:
        """Return operational cases derived from dossier review findings."""
        sessions, source, used_fallback, message = self._load_sessions(
            project_code=project_code
        )
        items = [
            case
            for session in sessions
            for case in self._build_cases_from_session(session)
        ]

        if status:
            normalized_status = status.strip().lower()
            items = [
                item
                for item in items
                if (item.current_status or "").strip().lower() == normalized_status
            ]

        return OperationsCasesResponse(
            items=items,
            source=source,
            used_fallback=used_fallback,
            message=message,
        )

    def list_actions(
        self,
        project_code: str | None = None,
        status: str | None = None,
    ) -> OperationsActionsResponse:
        """Return operational action queue derived from dossier review assignments."""
        sessions, source, used_fallback, message = self._load_sessions(
            project_code=project_code
        )
        items = [
            action
            for session in sessions
            for action in self._build_actions_from_session(session)
        ]

        if status:
            normalized_status = status.strip().lower()
            items = [
                item
                for item in items
                if (item.status or "").strip().lower() == normalized_status
            ]

        return OperationsActionsResponse(
            items=items,
            source=source,
            used_fallback=used_fallback,
            message=message,
        )

    def list_blockers(
        self, project_code: str | None = None
    ) -> OperationsBlockersResponse:
        """Return blocker queue derived from blocking dossier review findings."""
        sessions, source, used_fallback, message = self._load_sessions(
            project_code=project_code
        )
        items = [
            blocker
            for session in sessions
            for blocker in self._build_blockers_from_session(session)
        ]

        return OperationsBlockersResponse(
            items=items,
            source=source,
            used_fallback=used_fallback,
            message=message,
        )

    def _load_sessions(
        self,
        project_code: str | None = None,
    ) -> tuple[list[dict[str, Any]], str, bool, str]:
        """Load dossier review sessions with safe fallback behavior."""
        if not self._postgres_client.is_enabled():
            return (
                [],
                "fallback",
                True,
                "DATABASE_URL chưa được cấu hình; operations case management đ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:  # pragma: no cover
            return (
                [],
                "fallback",
                True,
                f"Không thể tải dossier review sessions từ PostgreSQL: {exc}",
            )

        return (
            sessions,
            "postgres",
            False,
            "Operations case management đang được suy diễn từ dossier review workflow trong PostgreSQL.",
        )