"""FastAPI Presentation Routes for Smart Debt Clearing and Auto-Settlement."""

from __future__ import annotations

import logging
from typing import Any, Optional
from uuid import UUID

from fastapi import APIRouter, Depends, HTTPException, Query

from app.modules.auth.presentation.auth import require_role
from app.modules.financial.application.smart_clearing_service import SmartClearingService
from app.modules.financial.presentation.clearing_schemas import (
    BatchClearingRequest,
    BatchClearingResponse,
    ManualClearingRequest,
    SettlementResponseItem,
)

logger = logging.getLogger("dscons.api.finance.clearing")
router = APIRouter(prefix="/v1/erp/finance/clearing", tags=["Finance - Smart Debt Clearing"])


def get_clearing_service() -> SmartClearingService:
    return SmartClearingService()


@router.post(
    "/batch-run",
    response_model=BatchClearingResponse,
    summary="Chạy quét khớp nối nợ tự động hàng loạt (Hỗ trợ Dry-run)",
)
def run_batch_auto_clearing(
    payload: BatchClearingRequest,
    service: SmartClearingService = Depends(get_clearing_service),
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "accountant"])
    ),
) -> BatchClearingResponse:
    """Quét toàn bộ giao dịch ngân hàng chưa khớp và cấn trừ tự động vào hóa đơn còn nợ."""
    try:
        res = service.batch_auto_clearing(
            dry_run=payload.dry_run,
            min_confidence=payload.min_confidence,
            limit=payload.limit,
        )
        return BatchClearingResponse(
            status="success",
            dry_run=res.dry_run,
            total_transactions_scanned=res.total_transactions_scanned,
            matched_count=res.matched_count,
            total_cleared_amount_vnd=res.total_cleared_amount_vnd,
            invoices_settled_count=res.invoices_settled_count,
            settlements=[
                SettlementResponseItem(
                    id=s.id,
                    bank_transaction_id=s.bank_transaction_id,
                    invoice_id=s.invoice_id,
                    partner_name=s.partner_name,
                    partner_tax_code=s.partner_tax_code,
                    account_code=s.account_code,
                    settlement_amount_vnd=s.settlement_amount_vnd,
                    settlement_date=s.settlement_date,
                    clearing_method=s.clearing_method.value
                    if hasattr(s.clearing_method, "value")
                    else str(s.clearing_method),
                    confidence_score=s.confidence_score,
                    status=s.status.value if hasattr(s.status, "value") else str(s.status),
                    notes=s.notes,
                    created_at=s.created_at,
                )
                for s in res.settlements
            ],
        )
    except Exception as e:
        logger.error("Batch auto clearing failed: %s", e)
        raise HTTPException(status_code=500, detail=str(e))


@router.get(
    "/summary",
    summary="Báo cáo tổng hợp tình hình gạch nợ và công nợ toàn hệ thống",
)
def get_clearing_summary(
    service: SmartClearingService = Depends(get_clearing_service),
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "accountant"])
    ),
) -> dict[str, Any]:
    """Tổng hợp số tiền đã cấn trừ, phân loại nợ 331, 131 và các giao dịch chưa khớp."""
    try:
        return service.get_clearing_summary()
    except Exception as e:
        logger.error("Failed to get clearing summary: %s", e)
        raise HTTPException(status_code=500, detail=str(e))


@router.get(
    "/settlements",
    summary="Danh sách các bản ghi cấn trừ gạch nợ",
)
def list_settlements(
    status: Optional[str] = Query(None, description="Lọc theo trạng thái: settled, tentative, reversed"),
    partner_tax_code: Optional[str] = Query(None, description="Lọc theo MST đối tác"),
    limit: int = Query(100, ge=1, le=500),
    offset: int = Query(0, ge=0),
    service: SmartClearingService = Depends(get_clearing_service),
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "accountant"])
    ),
) -> dict[str, Any]:
    """Tra cứu lịch sử các bút toán cấn trừ gạch nợ."""
    try:
        items = service.list_settlements(
            status=status,
            partner_tax_code=partner_tax_code,
            limit=limit,
            offset=offset,
        )
        return {
            "status": "success",
            "total": len(items),
            "limit": limit,
            "offset": offset,
            "data": items,
        }
    except Exception as e:
        logger.error("Failed to list settlements: %s", e)
        raise HTTPException(status_code=500, detail=str(e))


@router.post(
    "/manual-match",
    summary="Kế toán gạch nợ thủ công một giao dịch với hóa đơn",
)
def manual_clear_debt(
    payload: ManualClearingRequest,
    service: SmartClearingService = Depends(get_clearing_service),
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "accountant"])
    ),
) -> dict[str, Any]:
    """Cho phép kế toán gạch nợ thủ công với số tiền chỉ định."""
    try:
        user_email = current_user.get("email", "accountant@dscons.vn")
        settle = service.manual_clear(
            transaction_id=payload.bank_transaction_id,
            invoice_id=payload.invoice_id,
            settlement_amount=payload.settlement_amount_vnd,
            notes=payload.notes or "",
            user_email=user_email,
        )
        return {
            "status": "success",
            "message": "Gạch nợ thủ công thành công.",
            "settlement_id": str(settle.id),
            "settlement_amount_vnd": float(settle.settlement_amount_vnd),
        }
    except ValueError as val_err:
        raise HTTPException(status_code=400, detail=str(val_err))
    except Exception as e:
        logger.error("Manual clearing failed: %s", e)
        raise HTTPException(status_code=500, detail=str(e))


@router.post(
    "/{settlement_id}/reverse",
    summary="Hủy bút toán gạch nợ và phục hồi số dư nợ hóa đơn",
)
def reverse_settlement(
    settlement_id: UUID,
    service: SmartClearingService = Depends(get_clearing_service),
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director"])
    ),
) -> dict[str, Any]:
    """Hủy một bút toán gạch nợ (chỉ dành cho superadmin / director)."""
    try:
        res = service.reverse_settlement(settlement_id)
        return res
    except ValueError as val_err:
        raise HTTPException(status_code=400, detail=str(val_err))
    except Exception as e:
        logger.error("Reverse settlement failed: %s", e)
        raise HTTPException(status_code=500, detail=str(e))