"""Helper employee log cho workflow persistence."""

from __future__ import annotations

from datetime import date
from typing import Any

from app.models.schemas import (
    WorkflowReviewEmployeeActionRequest,
    WorkflowReviewEmployeeLogSummary,
    WorkflowReviewStartRequest,
)


class WorkflowPersistenceEmployeeLogsMixin:
    """Mixin xử lý log việc."""

    def _persist_employee_logs(
        self,
        *,
        request: WorkflowReviewStartRequest,
        review_id: str,
        review_code: str,
        workflow_employee_actions: list[WorkflowReviewEmployeeActionRequest]
        | None = None,
    ) -> list[WorkflowReviewEmployeeLogSummary]:
        """Tạo log việc cho nhân sự."""
        grouped_actions: dict[str, list[dict[str, Any]]] = {}
        action_stream = workflow_employee_actions or list(
            request.participating_employees
        )

        if not workflow_employee_actions:
            for finding in request.findings:
                action_stream.extend(finding.employee_actions)

        for item in action_stream:
            payload = item.model_dump(exclude_none=True)
            grouped_actions.setdefault(item.employee_code, []).append(payload)

        summaries: list[WorkflowReviewEmployeeLogSummary] = []
        shift_date = date.today().isoformat()

        for employee_code, actions in grouped_actions.items():
            persona = self._resolve_persona_from_actions(actions)
            session_payload = self._build_employee_log_session_payload(
                request=request,
                employee_code=employee_code,
                review_id=review_id,
                review_code=review_code,
                shift_date=shift_date,
                actions=actions,
                persona=persona,
                normalize_work_log_status=self._normalize_work_log_status,
            )
            work_log_session = self._postgres_client.upsert_employee_work_log_session(
                session_payload
            )

            for index, action in enumerate(actions):
                action_timestamp = self._normalize_action_timestamp(
                    action.get("action_timestamp"), fallback_index=index
                )
                metadata = {
                    **dict(action.get("metadata") or {}),
                    "review_id": review_id,
                    "review_code": review_code,
                    "project_code": request.project_code,
                    "department_code": action.get("department_code"),
                    "agent_code": action.get("agent_code")
                    or (persona["agent_code"] if persona else None),
                    "finding_code": action.get("finding_code"),
                    "finding_title": action.get("finding_title"),
                }
                action_external_ref = self._build_action_external_ref(
                    review_id=review_id,
                    employee_code=employee_code,
                    action=action,
                    fallback_index=index,
                )
                metadata["external_ref"] = action_external_ref
                try:
                    self._postgres_client.append_employee_work_log_action(
                        {
                            "work_log_session_id": work_log_session[
                                "work_log_session_id"
                            ],
                            "action_timestamp": action_timestamp,
                            "action_type": self._normalize_work_log_action_type(
                                action.get("metadata", {}).get("action_type"),
                                action.get("action"),
                            ),
                            "action": action.get("action"),
                            "ai_request": action.get("ai_request"),
                            "ai_result": action.get("ai_result") or [],
                            "findings": action.get("findings") or [],
                            "notes": action.get("notes") or [],
                            "external_ref": action_external_ref,
                            "metadata": metadata,
                        }
                    )
                except Exception as exc:
                    if "uq_employee_work_log_actions_dedup" not in str(exc):
                        raise

            summaries.append(
                WorkflowReviewEmployeeLogSummary(
                    employee_code=employee_code,
                    work_log_session_id=work_log_session["work_log_session_id"],
                    status=work_log_session["status"],
                    action_count=len(actions),
                    project_code=work_log_session["project_code"],
                    shift_date=work_log_session["shift_date"],
                )
            )

        return summaries