from __future__ import annotations

from typing import Any

from app.models.schemas import (
    WorkflowReviewEmployeeActionRequest,
    WorkflowReviewFindingRequest,
    WorkflowReviewFindingSummary,
    WorkflowReviewNextActionItem,
    WorkflowReviewPolicyCheckResult,
    WorkflowReviewStepOutcome,
)

from .finding_outcomes import WorkflowPersistenceFindingOutcomesMixin


class WorkflowPersistenceFindingLifecycleMixin(WorkflowPersistenceFindingOutcomesMixin):
    """Finding write phase step execution."""

    def _process_finding_write_phase(
        self,
        *,
        request: WorkflowReviewStartRequest,
        session: dict[str, Any],
        review_code: str,
        finding: WorkflowReviewFindingRequest,
        policy_checks: list[WorkflowReviewPolicyCheckResult],
        workflow_employee_actions: list[WorkflowReviewEmployeeActionRequest],
        finding_summaries: list[WorkflowReviewFindingSummary],
        next_actions: list[WorkflowReviewNextActionItem],
        lifecycle_outcomes: list[WorkflowReviewStepOutcome],
        counters: dict[str, int],
        blocking_policy: bool,
        connection: Any,
    ) -> None:
        """Xử lý từng finding cho gọn."""
        created_finding = self._postgres_client.create_dossier_review_finding(
            session["review_id"],
            {
                **finding.model_dump(
                    exclude={"assignment", "employee_actions"}, exclude_none=True
                ),
                "actor_type": "agent",
                "actor_employee_code": request.lead_reviewer_employee_code
                or request.initiated_by_employee_code,
                "actor_agent_code": request.lead_agent_code,
                "action_summary": f"Ghi nhận finding {finding.finding_code} trong đợt rà soát {review_code}.",
            },
            connection=connection,
        )
        workflow_employee_actions.extend(finding.employee_actions)
        finding_policy = self._find_policy_for_finding(
            policy_checks, finding.finding_code
        )

        if finding_policy and finding_policy.requires_escalation:
            escalation_items = self._build_escalation_next_actions(
                finding=finding,
                finding_id=created_finding["finding_id"],
                policy_result=finding_policy,
            )
            counters["escalated_findings_count"] += len(escalation_items)
            next_actions.extend(escalation_items)

        created_assignment = None
        finding_blocked = bool(
            finding_policy
            and (
                not finding_policy.allowed
                or finding_policy.requires_manual_review
                or finding_policy.circuit_breaker_triggered
            )
        )
        if not blocking_policy and not finding_blocked:
            created_assignment = self._ensure_assignment(
                request=request,
                review_id=session["review_id"],
                finding_id=created_finding["finding_id"],
                finding=finding,
                connection=connection,
            )

        self._finalize_finding_phase(
            request=request,
            session=session,
            review_code=review_code,
            finding=finding,
            created_finding=created_finding,
            created_assignment=created_assignment,
            finding_policy=finding_policy,
            workflow_employee_actions=workflow_employee_actions,
            finding_summaries=finding_summaries,
            next_actions=next_actions,
            lifecycle_outcomes=lifecycle_outcomes,
            counters=counters,
            blocking_policy=blocking_policy,
            connection=connection,
        )