from __future__ import annotations

from typing import Any

from .builders import (
    attach_supported_optional_fields,
    build_policy_overview,
    build_project_state,
    build_remediation_plan_summary,
    build_response_message,
    build_risks,
    build_source_status_list,
    build_state_summaries,
    build_summary,
    build_workforce,
)
from .helpers import merge_messages
from .review_items import (
    build_backlog,
    build_backlog_from_review,
    build_blocked_items,
    build_blocked_items_from_review,
    collect_review_follow_ups,
)


class CompanyStateDelegationsMixin:
    """Delegation helpers mapping to modular builders."""

    def _build_summary(self, **kwargs: Any):
        return build_summary(**kwargs)

    def _build_source_status_list(self, **kwargs: Any):
        return build_source_status_list(**kwargs)

    @staticmethod
    def _build_response_message(*messages: str | None) -> str | None:
        return build_response_message(*messages)

    @staticmethod
    def _build_project_state(item: Any):
        return build_project_state(item)

    def _build_risks(self, projects: list[Any], dossier_reviews: list[dict[str, Any]]):
        return build_risks(projects, dossier_reviews)

    def _build_blocked_items(self, **kwargs: Any):
        return build_blocked_items(self, **kwargs)

    def _build_backlog(self, **kwargs: Any):
        return build_backlog(self, **kwargs)

    @staticmethod
    def _build_workforce(items: list[Any]):
        return build_workforce(items)

    def _build_blocked_items_from_review(self, review: dict[str, Any]):
        return build_blocked_items_from_review(self, review)

    def _build_backlog_from_review(self, review: dict[str, Any]):
        return build_backlog_from_review(self, review)

    def _collect_review_follow_ups(
        self, *, review: dict[str, Any], finding: dict[str, Any]
    ) -> list[dict[str, Any]]:
        return collect_review_follow_ups(review=review, finding=finding)

    def _build_optional_top_level_payload(
        self,
        *,
        summary: Any,
        operations_cases_response: Any,
        operations_actions_response: Any,
        operations_blockers_response: Any,
        remediation_response: Any,
        dossier_response: list[dict[str, Any]],
    ) -> tuple[dict[str, Any], str | None]:
        """Tạo payload optional an toàn."""
        payload: dict[str, Any] = {
            "operations_cases": list(
                getattr(operations_cases_response, "items", []) or []
            ),
            "operations_actions": list(
                getattr(operations_actions_response, "items", []) or []
            ),
            "operations_blockers": list(
                getattr(operations_blockers_response, "items", []) or []
            ),
            "dossier_reviews": dossier_response,
        }
        messages: list[str] = []
        try:
            payload["remediation_plans"] = [
                self._build_remediation_plan_summary(item)
                for item in getattr(remediation_response, "items", []) or []
            ]
        except Exception as exc:
            payload["remediation_plans"] = []
            messages.append(
                f"Không thể build remediation plan summaries cho operational state; đã trả fallback rỗng an toàn. Chi tiết: {exc}"
            )
        try:
            payload["policy_overview"] = self._build_policy_overview(
                dossier_reviews=dossier_response
            )
        except Exception as exc:
            payload["policy_overview"] = {}
            messages.append(
                f"Không thể build policy overview cho operational state; đã trả fallback rỗng an toàn. Chi tiết: {exc}"
            )
        try:
            payload["remediation_summary"] = self._build_state_summaries(
                summary=summary,
                operations_cases_count=len(
                    getattr(operations_cases_response, "items", []) or []
                ),
                operations_actions_count=len(
                    getattr(operations_actions_response, "items", []) or []
                ),
                operations_blockers_count=len(
                    getattr(operations_blockers_response, "items", []) or []
                ),
                remediation_plans_count=len(
                    getattr(remediation_response, "items", []) or []
                ),
            )
        except Exception as exc:
            payload["remediation_summary"] = []
            messages.append(
                f"Không thể build remediation summary cho operational state; đã trả fallback rỗng an toàn. Chi tiết: {exc}"
            )
        return payload, merge_messages(*messages)

    @staticmethod
    def _attach_supported_optional_fields(
        response_payload: dict[str, Any], optional_payload: dict[str, Any]
    ) -> None:
        attach_supported_optional_fields(response_payload, optional_payload)

    def _build_policy_overview(
        self, *, dossier_reviews: list[dict[str, Any]]
    ) -> dict[str, Any]:
        return build_policy_overview(dossier_reviews=dossier_reviews)

    @staticmethod
    def _build_remediation_plan_summary(item: Any) -> dict[str, Any]:
        return build_remediation_plan_summary(item)

    @staticmethod
    def _build_state_summaries(**kwargs: Any):
        return build_state_summaries(**kwargs)