from __future__ import annotations

from typing import Any

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


class WorkflowPersistenceFindingOutcomesMixin:
    """Outcome finalization for individual finding remediation steps."""

    def _finalize_finding_phase(
        self,
        *,
        request: WorkflowReviewStartRequest,
        session: dict[str, Any],
        review_code: str,
        finding: WorkflowReviewFindingRequest,
        created_finding: dict[str, Any],
        created_assignment: dict[str, Any] | None,
        finding_policy: WorkflowReviewPolicyCheckResult | None,
        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:
        """Chốt từng finding."""
        assignment_id = (
            created_assignment["assignment_id"] if created_assignment else None
        )
        assignment_status = created_assignment["status"] if created_assignment else None
        manual_required_for_finding = False

        if created_assignment:
            counters["assigned_findings_count"] += 1
            lifecycle_outcomes.extend(
                [
                    WorkflowReviewStepOutcome(
                        step="assign",
                        executed=True,
                        succeeded=True,
                        target_type="finding",
                        target_id=created_finding["finding_id"],
                        target_code=finding.finding_code,
                        status=created_assignment.get("status"),
                        reason="Đã tự động tạo assignment cho finding.",
                        metadata={"assignment_id": created_assignment["assignment_id"]},
                    ),
                    WorkflowReviewStepOutcome(
                        step="submit",
                        executed=True,
                        succeeded=True,
                        target_type="finding",
                        target_id=created_finding["finding_id"],
                        target_code=finding.finding_code,
                        status="submitted",
                        reason="Đã tự động nộp bổ sung cho finding.",
                        metadata={"assignment_id": created_assignment["assignment_id"]},
                    ),
                    WorkflowReviewStepOutcome(
                        step="verify",
                        executed=True,
                        succeeded=True,
                        target_type="finding",
                        target_id=created_finding["finding_id"],
                        target_code=finding.finding_code,
                        status="verified",
                        reason="Đã tự động verify finding.",
                        metadata={
                            "assignment_id": created_assignment["assignment_id"],
                            "assigned_findings_count": counters[
                                "assigned_findings_count"
                            ],
                            "submitted_findings_count": counters[
                                "submitted_findings_count"
                            ]
                            + 1,
                            "verified_findings_count": counters[
                                "verified_findings_count"
                            ]
                            + 1,
                            "escalated_findings_count": counters[
                                "escalated_findings_count"
                            ],
                            "manual_follow_up_count": counters[
                                "manual_follow_up_count"
                            ],
                            "manual_required_for_finding": False,
                        },
                    ),
                ]
            )
            self._postgres_client.submit_dossier_review_supplement(
                session["review_id"],
                created_finding["finding_id"],
                {
                    **self._build_auto_submission(
                        request=request,
                        finding=finding,
                        assignment=created_assignment,
                    ).model_dump(exclude_none=True),
                    "assignment_id": created_assignment["assignment_id"],
                },
                connection=connection,
            )
            counters["submitted_findings_count"] += 1
            self._postgres_client.verify_dossier_review_finding(
                session["review_id"],
                created_finding["finding_id"],
                {
                    **self._build_auto_verification(
                        request=request,
                        finding=finding,
                        assignment=created_assignment,
                    ).model_dump(exclude_none=True),
                    "assignment_id": created_assignment["assignment_id"],
                },
                connection=connection,
            )
            counters["verified_findings_count"] += 1
            workflow_employee_actions.extend(
                self._build_automation_employee_actions(
                    finding=finding,
                    assignment=created_assignment,
                    request=request,
                )
            )
        else:
            manual_required_for_finding = True
            counters["manual_follow_up_count"] += 1
            lifecycle_outcomes.append(
                WorkflowReviewStepOutcome(
                    step="assign",
                    executed=not blocking_policy,
                    succeeded=False,
                    requires_manual_intervention=True,
                    blocked=True,
                    target_type="finding",
                    target_id=created_finding["finding_id"],
                    target_code=finding.finding_code,
                    status="manual_follow_up_required",
                    reason=self._build_manual_follow_up_reason(
                        finding, finding_policy, blocking_policy
                    ),
                    metadata={
                        "policy_scope": finding_policy.scope
                        if finding_policy
                        else None,
                        "blocking_policy": blocking_policy,
                        "assigned_findings_count": counters["assigned_findings_count"],
                        "submitted_findings_count": counters[
                            "submitted_findings_count"
                        ],
                        "verified_findings_count": counters["verified_findings_count"],
                        "escalated_findings_count": counters[
                            "escalated_findings_count"
                        ],
                        "manual_follow_up_count": counters["manual_follow_up_count"],
                        "manual_required_for_finding": True,
                    },
                )
            )
            if finding_policy and not finding_policy.allowed:
                workflow_employee_actions.extend(
                    self._build_policy_employee_actions(
                        review_code=review_code,
                        policy_checks=[finding_policy],
                        project_code=request.project_code,
                        lead_agent_code=request.lead_agent_code,
                        lead_reviewer_employee_code=request.lead_reviewer_employee_code,
                    )
                )

        next_actions.extend(
            self._build_next_actions(
                request=request,
                finding=finding,
                finding_id=created_finding["finding_id"],
                assignment=created_assignment,
            )
        )
        finding_summaries.append(
            WorkflowReviewFindingSummary(
                finding_id=created_finding["finding_id"],
                finding_code=created_finding["finding_code"],
                status="resolved" if created_assignment else created_finding["status"],
                responsible_department_code=created_finding[
                    "responsible_department_code"
                ],
                assignment_id=assignment_id,
                assignment_status="verified"
                if created_assignment
                else assignment_status,
                employee_action_count=len(finding.employee_actions),
            )
        )

        if not lifecycle_outcomes or lifecycle_outcomes[-1].metadata is None:
            return
        lifecycle_outcomes[-1].metadata["manual_required_for_finding"] = (
            manual_required_for_finding
        )