from __future__ import annotations

import logging
from collections.abc import Mapping
from typing import Any

from .coercion_helpers import PayloadCoercionHelpersMixin

logger = logging.getLogger("dscons.generation_payload.sections")


class PayloadSectionBuildersMixin(PayloadCoercionHelpersMixin):
    """Section payload builders for legal signatories, organization info, and readiness."""

    def _build_organization_info(
        self,
        source_data: Mapping[str, Any],
        primary_path: str,
        fallback_paths: tuple[str, ...],
        default_name: str | None,
        default_address: str | None,
        default_representative_name: str | None,
        default_representative_title: str | None,
    ) -> GenerationOrganizationInfo | None:
        """Dựng thông tin tổ chức từ object lồng nhau hoặc các field rời."""
        organization_data = self._pick_first_mapping(
            source_data, primary_path, *fallback_paths
        )

        name = self._pick_first_str_from_mapping(
            organization_data, "name", "organization_name"
        )
        short_name = self._pick_first_str_from_mapping(
            organization_data, "short_name", "abbr"
        )
        department = self._pick_first_str_from_mapping(
            organization_data, "department", "unit"
        )
        address = self._pick_first_str_from_mapping(organization_data, "address")
        representative_name = self._pick_first_str_from_mapping(
            organization_data,
            "representative_name",
            "full_name",
            "contact_name",
        )
        representative_title = self._pick_first_str_from_mapping(
            organization_data,
            "representative_title",
            "title",
            "position",
        )

        name = name or default_name
        address = address or default_address
        representative_name = representative_name or default_representative_name
        representative_title = representative_title or default_representative_title

        if not any(
            [
                self._has_meaningful_value(name),
                self._has_meaningful_value(address),
                self._has_meaningful_value(representative_name),
                self._has_meaningful_value(representative_title),
            ]
        ):
            return None

        return GenerationOrganizationInfo(
            name=name or "[[suggested]] Chưa xác định đơn vị",
            short_name=short_name,
            department=department,
            address=address,
            representative_name=representative_name,
            representative_title=representative_title,
        )

    def _build_signatory_info(
        self,
        source_data: Mapping[str, Any],
        primary_path: str,
        fallback_paths: tuple[str, ...],
        default_full_name: str | None,
        default_title: str | None,
        organization: GenerationOrganizationInfo | None,
        default_signing_place: str | None,
        default_signing_date_text: str | None,
    ) -> GenerationSignatoryInfo | None:
        """Dựng thông tin người ký từ object lồng nhau và tổ chức liên quan."""
        signatory_data = self._pick_first_mapping(
            source_data, primary_path, *fallback_paths
        )

        full_name = self._pick_first_str_from_mapping(
            signatory_data, "full_name", "name"
        )
        title = self._pick_first_str_from_mapping(signatory_data, "title", "position")
        organization_name = self._pick_first_str_from_mapping(
            signatory_data,
            "organization_name",
            "company_name",
        )
        signing_place = self._pick_first_str_from_mapping(
            signatory_data, "signing_place"
        )
        signing_date_text = self._pick_first_str_from_mapping(
            signatory_data,
            "signing_date_text",
            "date_text",
        )

        full_name = full_name or default_full_name
        title = title or default_title
        organization_name = organization_name or (
            organization.name if organization else None
        )
        signing_place = signing_place or default_signing_place
        signing_date_text = signing_date_text or default_signing_date_text

        if not any(
            [
                self._has_meaningful_value(full_name),
                self._has_meaningful_value(title),
                organization is not None,
            ]
        ):
            return None

        return GenerationSignatoryInfo(
            full_name=full_name or "[[suggested]] Chưa xác định người ký",
            title=title,
            organization_name=organization_name,
            organization=organization,
            signing_place=signing_place,
            signing_date_text=signing_date_text,
        )

    def _build_extra_context(
        self,
        source_data: Mapping[str, Any],
        template: GenerationTemplateRegistryEntry,
        project_name: str | None,
        dossier_code: str | None,
        handover_date_text: str | None,
        handover_location: str | None,
        site_description: str | None,
    ) -> dict[str, str | int | float | bool | None]:
        """Tổng hợp ngữ cảnh phụ để UI hoặc bước render sử dụng tiếp."""
        existing_context = self._pick_first_mapping(source_data, "extra_context")
        extra_context: dict[str, str | int | float | bool | None] = {}

        for key, value in existing_context.items():
            if isinstance(value, (str, int, float, bool)) or value is None:
                extra_context[key] = value
            else:
                extra_context[key] = str(value)

        defaults: dict[str, str | int | float | bool | None] = {
            "document_title": "BIÊN BẢN BÀN GIAO MẶT BẰNG",
            "handover_scope_summary": site_description,
            "handover_notes": self._pick_first_str(
                source_data,
                "handover_notes",
                "handover.notes",
                "notes",
            ),
            "legal_basis_summary": self._pick_first_str(
                source_data,
                "legal_basis_summary",
                "legal_basis.summary",
                "approval_decision.summary",
                "project.approval_decisions.0.summary",
                "contract.contract_name",
            ),
            "template_key": template.template_key,
            "template_name": template.template_name,
            "template_version": template.version,
            "project_name": project_name,
            "dossier_code": dossier_code,
            "handover_date_text": handover_date_text,
            "handover_location": handover_location,
        }

        for key, value in defaults.items():
            if key not in extra_context:
                extra_context[key] = value

        return extra_context

    def _build_initial_readiness(self) -> GenerationReadinessStatus:
        """Tạo readiness tạm để khởi tạo payload trước khi tính chính thức."""
        return GenerationReadinessStatus(
            status="not_ready",
            missing_required_fields=[],
            unresolved_review_fields=[],
            summary="Payload đang được khởi tạo.",
        )

    def _build_default_review_workflow(self) -> GenerationReviewWorkflowStatus:
        """Tạo trạng thái review mặc định cho payload mới assemble."""
        return GenerationReviewWorkflowStatus(
            status="draft_generated",
            reviewer_name=None,
            reviewed_at=None,
            review_notes=None,
        )