from __future__ import annotations

from typing import Any

from .helpers import ReviewMemoryHelpersMixin


class ReviewSessionChunksMixin(ReviewMemoryHelpersMixin):
    """Chunk builders for dossier review sessions, findings, and actions."""

    def _build_review_session_summary_chunk(
        self, session: dict[str, Any], task_type: str
    ) -> dict[str, Any] | None:
        """Build a high-level summary chunk for one review session."""
        text = self._join_lines(
            [
                f"Phiên rà soát hồ sơ dự án {session.get('project_code') or ''}",
                self._prefixed("Mã review", session.get("review_code")),
                self._prefixed("Tên dự án", session.get("project_name")),
                self._prefixed("Phạm vi", session.get("dossier_scope")),
                self._prefixed("Nguồn kích hoạt", session.get("trigger_source")),
                self._prefixed("Agent phụ trách", session.get("lead_agent_code")),
                self._prefixed("Trạng thái", session.get("status")),
                self._prefixed("Lý do", session.get("review_reason")),
                self._prefixed("Tóm tắt", session.get("review_summary")),
                self._prefixed("Số lỗi mở", session.get("open_findings_count")),
                self._prefixed(
                    "Số lỗi đã xử lý", session.get("resolved_findings_count")
                ),
                self._prefixed(
                    "Bộ phận liên quan",
                    ", ".join(session.get("assigned_departments", []) or []),
                ),
            ]
        )
        if not text:
            return None

        metadata = self._base_metadata(
            task_type=task_type,
            project_code=session.get("project_code"),
            agent_scope=session.get("lead_agent_code"),
            document_type="dossier_review_session",
            knowledge_type=self.REVIEW_MEMORY_TYPE,
            source_table="dossier_review_sessions",
            review_id=session.get("review_id"),
        )
        metadata.update(self._normalize_metadata(session.get("metadata")))
        return {"text": text, "metadata": metadata}

    def _build_finding_memory_chunk(
        self,
        session: dict[str, Any],
        finding: dict[str, Any],
        task_type: str,
    ) -> dict[str, Any] | None:
        """Build a chunk that captures the problem state of one finding."""
        assignments = finding.get("assignments", []) or []
        latest_assignment = assignments[-1] if assignments else {}
        evidence_summary = "; ".join(
            [
                self._compact_sentence(
                    [
                        evidence.get("evidence_type"),
                        evidence.get("source_name"),
                        evidence.get("excerpt"),
                    ]
                )
                for evidence in (finding.get("evidences", []) or [])[:3]
                if isinstance(evidence, dict)
            ]
        )

        text = self._join_lines(
            [
                f"Ghi nhớ finding cho dự án {session.get('project_code') or ''}",
                self._prefixed("Mã finding", finding.get("finding_code")),
                self._prefixed("Tiêu đề", finding.get("title")),
                self._prefixed("Nhóm", finding.get("finding_group")),
                self._prefixed("Loại", finding.get("finding_type")),
                self._prefixed("Tài liệu liên quan", finding.get("document_type")),
                self._prefixed("Giai đoạn hồ sơ", finding.get("dossier_stage")),
                self._prefixed("Mức độ", finding.get("severity")),
                self._prefixed("Ảnh hưởng", finding.get("impact_level")),
                self._prefixed(
                    "Bộ phận phụ trách", finding.get("responsible_department_code")
                ),
                self._prefixed("Trạng thái bổ sung", finding.get("supplement_status")),
                self._prefixed("Trạng thái finding", finding.get("status")),
                self._prefixed("Mô tả", finding.get("description")),
                self._prefixed("Bằng chứng chính", evidence_summary),
                self._prefixed(
                    "Phân công gần nhất",
                    latest_assignment.get("assigned_department_code"),
                ),
                self._prefixed(
                    "Ghi chú phân công", latest_assignment.get("assignment_note")
                ),
            ]
        )
        if not text:
            return None

        metadata = self._base_metadata(
            task_type=task_type,
            project_code=session.get("project_code"),
            agent_scope=session.get("lead_agent_code"),
            document_type=finding.get("document_type"),
            knowledge_type=self.REVIEW_MEMORY_TYPE,
            source_table="dossier_review_findings",
            review_id=session.get("review_id"),
            finding_id=finding.get("finding_id"),
            assignment_id=latest_assignment.get("assignment_id"),
        )
        metadata["finding_status"] = finding.get("status")
        metadata["finding_severity"] = finding.get("severity")
        metadata.update(self._normalize_metadata(finding.get("metadata")))
        return {"text": text, "metadata": metadata}

    def _build_finding_resolution_chunk(
        self,
        session: dict[str, Any],
        finding: dict[str, Any],
        task_type: str,
    ) -> dict[str, Any] | None:
        """Build a chunk that captures the resolution of one finding."""
        resolution_note = finding.get("resolution_note")
        if not resolution_note and str(finding.get("status") or "").lower() not in {
            "resolved",
            "waived",
            "rejected",
        }:
            return None

        assignments = finding.get("assignments", []) or []
        latest_assignment = assignments[-1] if assignments else {}
        latest_submission = {}
        if latest_assignment.get("submissions"):
            latest_submission = latest_assignment["submissions"][-1]

        text = self._join_lines(
            [
                f"Kết quả xử lý finding dự án {session.get('project_code') or ''}",
                self._prefixed("Mã finding", finding.get("finding_code")),
                self._prefixed("Tiêu đề", finding.get("title")),
                self._prefixed("Trạng thái cuối", finding.get("status")),
                self._prefixed("Kết quả bổ sung", finding.get("supplement_status")),
                self._prefixed("Ghi chú xử lý", resolution_note),
                self._prefixed(
                    "Phòng ban xử lý", latest_assignment.get("assigned_department_code")
                ),
                self._prefixed(
                    "Nhân sự xử lý", latest_assignment.get("assigned_employee_name")
                ),
                self._prefixed(
                    "Loại nộp bổ sung", latest_submission.get("submission_type")
                ),
                self._prefixed(
                    "Ghi chú nộp bổ sung", latest_submission.get("submission_note")
                ),
                self._prefixed(
                    "Kết quả xác minh", latest_submission.get("verification_result")
                ),
                self._prefixed(
                    "Ghi chú xác minh", latest_submission.get("verification_note")
                ),
            ]
        )
        if not text:
            return None

        metadata = self._base_metadata(
            task_type=task_type,
            project_code=session.get("project_code"),
            agent_scope=session.get("lead_agent_code"),
            document_type=finding.get("document_type"),
            knowledge_type=self.PROJECT_MEMORY_TYPE,
            source_table="dossier_review_findings",
            review_id=session.get("review_id"),
            finding_id=finding.get("finding_id"),
            assignment_id=latest_assignment.get("assignment_id"),
        )
        metadata["finding_status"] = finding.get("status")
        metadata["resolution_state"] = finding.get("supplement_status")
        metadata.update(self._normalize_metadata(finding.get("metadata")))
        return {"text": text, "metadata": metadata}

    def _build_review_action_chunk(
        self,
        session: dict[str, Any],
        action: dict[str, Any],
        task_type: str,
    ) -> dict[str, Any] | None:
        """Build a chunk for important review workflow actions."""
        action_type = str(action.get("action_type") or "").strip()
        if action_type not in {
            "finding_assigned",
            "supplement_submitted",
            "verification_completed",
            "session_closed",
        }:
            return None

        text = self._join_lines(
            [
                f"Sự kiện vận hành review của dự án {session.get('project_code') or ''}",
                self._prefixed("Loại hành động", action_type),
                self._prefixed("Tóm tắt", action.get("action_summary")),
                self._prefixed("Agent thực hiện", action.get("actor_agent_code")),
                self._prefixed("Nhân sự thực hiện", action.get("actor_employee_name")),
                self._prefixed(
                    "Trước thay đổi", self._serialize_state(action.get("before_state"))
                ),
                self._prefixed(
                    "Sau thay đổi", self._serialize_state(action.get("after_state"))
                ),
            ]
        )
        if not text:
            return None

        payload = action.get("action_payload", {}) or {}
        metadata = self._base_metadata(
            task_type=task_type,
            project_code=session.get("project_code"),
            agent_scope=action.get("actor_agent_code")
            or session.get("lead_agent_code"),
            document_type=payload.get("document_type"),
            knowledge_type=self.PROJECT_MEMORY_TYPE,
            source_table="dossier_review_actions",
            review_id=session.get("review_id"),
            finding_id=payload.get("finding_id"),
            assignment_id=payload.get("assignment_id"),
        )
        metadata["action_type"] = action_type
        metadata.update(self._normalize_metadata(payload))
        return {"text": text, "metadata": metadata}