from __future__ import annotations

import logging
from typing import Any

from fastapi import APIRouter, Depends, HTTPException, Query, Response

from app.modules.auth.presentation.auth import get_current_user, require_role
from app.core.postgres.erp_client import ErpDatabaseClient
from app.modules.core.domain.document_taxonomy import (
    DOCUMENT_GROUPS,
    DOCUMENT_TYPES,
    get_taxonomy_grouped,
)

from .schemas import (
    DocumentApproveRequest,
    DocumentCreateRequest,
    DocumentUpdateRequest,
    SignatureStatusUpdateRequest,
)

logger = logging.getLogger("dscons.api.erp.documents_crud")
router = APIRouter()
erp_client = ErpDatabaseClient()


@router.get("/documents/taxonomy")
def get_document_taxonomy_endpoint(
    current_user: dict[str, Any] = Depends(get_current_user),
) -> dict[str, Any]:
    """Lấy danh mục phân loại văn bản 2 cấp (Mega-Groups & Sub-types)."""
    return {
        "groups": DOCUMENT_GROUPS,
        "types": DOCUMENT_TYPES,
        "hierarchy": get_taxonomy_grouped(),
    }


@router.get("/documents")
def list_documents(
    response: Response,
    category: str | None = None,
    document_group: str | None = None,
    document_type: str | None = None,
    project_id: str | None = None,
    search: str | None = None,
    project_stage: str | None = None,
    signature_status: str | None = None,
    quarantine_status: str | None = None,
    active_only: bool = True,
    year: int | None = None,
    limit: int | None = Query(None, ge=1, le=500),
    offset: int = Query(0, ge=0),
    current_user: dict[str, Any] = Depends(get_current_user),
) -> list[dict[str, Any]]:
    """Tra cứu văn bản đến, văn bản đi, văn bản nội bộ và pháp lý công trình kèm phân trang quy mô lớn."""
    rows = erp_client.list_documents(
        category=category,
        document_group=document_group,
        document_type=document_type,
        project_id=project_id,
        search=search,
        project_stage=project_stage,
        signature_status=signature_status,
        quarantine_status=quarantine_status,
        active_only=active_only,
        year=year,
        limit=limit,
        offset=offset,
    )
    total_count = rows[0].get("full_count", len(rows)) if rows else 0
    response.headers["X-Total-Count"] = str(total_count)
    return rows


@router.get("/documents/audit-readiness")
def get_audit_readiness_endpoint(
    project_id: str | None = None,
    current_user: dict[str, Any] = Depends(get_current_user),
) -> dict[str, Any]:
    """Báo cáo chấm điểm và phân tích mức độ sẵn sàng kiểm toán/quyết toán hồ sơ."""
    return erp_client.get_audit_readiness_report(project_id=project_id)


@router.get("/documents/next-number")
def get_next_document_number(
    doc_type: str = Query("CV", description="Loại văn bản: CV, TTr, QD, BB, TB, HD"),
    year: int | None = Query(None, description="Năm quản lý"),
    current_user: dict[str, Any] = Depends(get_current_user),
) -> dict[str, Any]:
    """Lấy số thứ tự văn bản tiếp theo được cấp phát tự động."""
    return erp_client.get_next_document_code(doc_type=doc_type, year=year)


@router.get("/documents/{doc_id}")
def get_document_endpoint(
    doc_id: str, current_user: dict[str, Any] = Depends(get_current_user)
) -> dict[str, Any]:
    """Lấy chi tiết văn bản theo ID phục vụ real-time status watcher."""
    doc = erp_client.get_document(doc_id)
    if not doc:
        raise HTTPException(status_code=404, detail="Không tìm thấy văn bản.")
    return doc


@router.post("/documents")
def create_document(
    req: DocumentCreateRequest,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "pm", "site_engineer", "accountant"])
    ),
) -> dict[str, Any]:
    """Tạo mới văn bản (tự cấp số tiếp theo hoặc yêu cầu chèn số chờ duyệt)."""
    try:
        return erp_client.create_document(req.model_dump())
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@router.post("/documents/{doc_id}/approve-insertion")
def approve_document_insertion(
    doc_id: str,
    req: DocumentApproveRequest,
    current_user: dict[str, Any] = Depends(require_role(["superadmin"])),
) -> dict[str, Any]:
    """Super Admin duyệt hoặc từ chối yêu cầu chèn số văn bản."""
    try:
        return erp_client.approve_document_insertion(
            doc_id=doc_id,
            approved=req.approved,
            admin_email=current_user.get("email", "unknown_admin@dscons.vn"),
        )
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@router.post("/documents/{doc_id}/signature-status")
def update_signature_status_endpoint(
    doc_id: str,
    req: SignatureStatusUpdateRequest,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "pm", "site_engineer", "accountant"])
    ),
) -> dict[str, Any]:
    """Cập nhật nhanh trạng thái ký & con dấu pháp lý của văn bản."""
    try:
        audit_score = (
            100
            if req.signature_status == "fully_executed"
            else (75 if req.signature_status == "signed_unsigned_seal" else 50)
        )
        return erp_client.update_document(
            doc_id,
            {
                "signature_status": req.signature_status,
                "audit_readiness_score": audit_score,
            },
        )
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@router.put("/documents/{doc_id}")
def update_document_endpoint(
    doc_id: str,
    req: DocumentUpdateRequest,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "pm", "site_engineer", "accountant"])
    ),
) -> dict[str, Any]:
    """Cập nhật thông tin văn bản thủ công (nhân viên điều chỉnh trước khi duyệt)."""
    try:
        payload = req.model_dump(exclude_none=True)
        return erp_client.update_document(doc_id, payload)
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@router.post("/documents/{doc_id}/approve")
def approve_document_endpoint(
    doc_id: str,
    req: DocumentUpdateRequest | None = None,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "pm", "site_engineer", "accountant"])
    ),
) -> dict[str, Any]:
    """Phê duyệt kết quả phân loại văn bản của AI, giải tỏa cách ly và ghi nhận dấu vết người duyệt."""
    try:
        from datetime import datetime

        payload = req.model_dump(exclude_none=True) if req else {}
        payload["status"] = "valid"
        payload["verification_status"] = "verified"
        payload["quarantine_status"] = "approved"
        payload["verified_by_user_id"] = (
            current_user.get("email")
            or current_user.get("user_id")
            or "Cán bộ thẩm duyệt"
        )
        payload["verified_at"] = datetime.now().isoformat()
        return erp_client.update_document(doc_id, payload)
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))


@router.delete("/documents/{doc_id}")
def delete_document_endpoint(
    doc_id: str,
    delete_all_versions: bool = Query(
        False,
        description="Xóa toàn bộ chùm phiên bản (Root + Sub-versions) hay chỉ xóa bản ghi này",
    ),
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "pm", "site_engineer", "accountant"])
    ),
) -> dict[str, Any]:
    """Xóa văn bản sai hoặc trùng lặp khỏi hệ thống."""
    try:
        return erp_client.delete_document(
            doc_id, delete_all_versions=delete_all_versions
        )
    except ValueError as ve:
        raise HTTPException(status_code=404, detail=str(ve))
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))