from __future__ import annotations

"""Post completion, close and verification actions."""

from typing import Any

from app.models.schemas import OperationsActionItem


class ActionsPostCompletionMixin:
    """Post completion, close and verification actions mixin."""

    def _build_post_completion_actions(
        self,
        *,
        session: dict[str, Any],
        finding: dict[str, Any],
        case_id: str,
    ) -> list[OperationsActionItem]:
        """Project post-close or post-verification follow-up actions into the operations queue."""
        items: list[OperationsActionItem] = []
        project_code = str(session.get("project_code") or "")
        review_id = str(session.get("review_id") or "")
        finding_code = str(finding.get("finding_code") or "") or None

        for index, action in enumerate(
            self._collect_post_close_actions(session=session, finding=finding), start=1
        ):
            items.append(
                OperationsActionItem(
                    action_id=str(
                        action.get("action_id") or f"{case_id}:post_close:{index}"
                    ),
                    action_code=str(
                        action.get("action_code") or f"{case_id}:post_close:{index}"
                    ),
                    case_id=case_id,
                    project_code=project_code,
                    review_session_id=review_id or None,
                    finding_code=finding_code,
                    action_type=str(
                        action.get("action_type") or "post_close_follow_up"
                    ),
                    title=str(
                        action.get("title")
                        or f"Theo dõi sau đóng review: {finding.get('title') or 'Dossier finding'}"
                    ),
                    description=action.get("description") or action.get("reason"),
                    owner_department_code=action.get("department_code")
                    or finding.get("responsible_department_code"),
                    owner_employee_code=action.get("owner_employee_code"),
                    priority=str(
                        action.get("priority")
                        or self._derive_priority(
                            finding.get("severity"),
                            finding.get("impact_level"),
                            finding.get("is_blocking"),
                        )
                    ),
                    due_date=action.get("due_date"),
                    status=str(action.get("status") or "pending"),
                    dependency_refs=[str(finding.get("finding_id"))]
                    if finding.get("finding_id")
                    else [],
                    expected_outcome=str(
                        action.get("expected_outcome")
                        or "Hoàn tất hành động follow-up sau khi review đã đóng."
                    ),
                    success_criteria=self._ensure_string_list(
                        action.get("success_criteria")
                    )
                    or self._build_success_criteria(finding),
                    requires_human_confirmation=bool(
                        action.get("requires_human_confirmation", True)
                    ),
                    completion_note=action.get("completion_note"),
                    created_at=action.get("created_at")
                    or session.get("closed_at")
                    or finding.get("resolved_at"),
                    completed_at=action.get("completed_at"),
                    metadata=self._merge_metadata(
                        action.get("metadata"),
                        {
                            "finding_status": finding.get("status"),
                            "trigger_phase": action.get("trigger_phase")
                            or "post_close",
                            "source": action.get("source") or "workflow_metadata",
                        },
                    ),
                )
            )

        for index, action in enumerate(
            self._collect_post_verification_actions(session=session, finding=finding),
            start=1,
        ):
            items.append(
                OperationsActionItem(
                    action_id=str(
                        action.get("action_id")
                        or f"{case_id}:post_verification:{index}"
                    ),
                    action_code=str(
                        action.get("action_code")
                        or f"{case_id}:post_verification:{index}"
                    ),
                    case_id=case_id,
                    project_code=project_code,
                    review_session_id=review_id or None,
                    finding_code=finding_code,
                    action_type=str(
                        action.get("action_type") or "post_verification_follow_up"
                    ),
                    title=str(
                        action.get("title")
                        or f"Theo dõi sau xác minh: {finding.get('title') or 'Dossier finding'}"
                    ),
                    description=action.get("description") or action.get("reason"),
                    owner_department_code=action.get("department_code")
                    or finding.get("responsible_department_code"),
                    owner_employee_code=action.get("owner_employee_code"),
                    priority=str(
                        action.get("priority")
                        or self._derive_priority(
                            finding.get("severity"),
                            finding.get("impact_level"),
                            finding.get("is_blocking"),
                        )
                    ),
                    due_date=action.get("due_date"),
                    status=str(action.get("status") or "pending"),
                    dependency_refs=[str(finding.get("finding_id"))]
                    if finding.get("finding_id")
                    else [],
                    expected_outcome=str(
                        action.get("expected_outcome")
                        or "Hoàn tất hành động follow-up sau xác minh bổ sung."
                    ),
                    success_criteria=self._ensure_string_list(
                        action.get("success_criteria")
                    )
                    or self._build_success_criteria(finding),
                    requires_human_confirmation=bool(
                        action.get("requires_human_confirmation", False)
                    ),
                    completion_note=action.get("completion_note"),
                    created_at=action.get("created_at") or finding.get("resolved_at"),
                    completed_at=action.get("completed_at"),
                    metadata=self._merge_metadata(
                        action.get("metadata"),
                        {
                            "finding_status": finding.get("status"),
                            "trigger_phase": action.get("trigger_phase")
                            or "post_verification",
                            "source": action.get("source") or "workflow_metadata",
                        },
                    ),
                )
            )

        return items

    def _collect_post_close_actions(
        self, *, session: dict[str, Any], finding: dict[str, Any]
    ) -> list[dict[str, Any]]:
        """Collect post-close actions from finding/session metadata and actions."""
        return self._collect_follow_up_actions(
            session=session,
            finding=finding,
            metadata_keys=(
                "post_close_actions",
                "post_close_backlog",
                "close_follow_ups",
            ),
            action_types={
                "session_closed",
                "session_close_follow_up",
                "close_follow_up_created",
            },
            default_trigger_phase="post_close",
        )

    def _collect_post_verification_actions(
        self,
        *,
        session: dict[str, Any],
        finding: dict[str, Any],
    ) -> list[dict[str, Any]]:
        """Collect post-verification actions from finding/session metadata and actions."""
        return self._collect_follow_up_actions(
            session=session,
            finding=finding,
            metadata_keys=(
                "post_verification_actions",
                "verification_follow_ups",
                "post_verify_actions",
            ),
            action_types={
                "verification_completed",
                "verification_follow_up_created",
                "supplement_verified",
            },
            default_trigger_phase="post_verification",
        )