"""POS Analytics router — Pertamina Excel import and report endpoints."""

from datetime import date

from fastapi import APIRouter, BackgroundTasks, Depends, File, Form, HTTPException, UploadFile
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.database import get_db
from app.dependencies import get_current_user
from app.models.user import User
from app.schemas.pos_analytics import (
    PosUploadResponse,
    PosCompareResponse, PosAnomaliResponse, PosGoldenHoursResponse,
    PosBatchListItem, PosBatchTransaksiResponse,
    GoldenHoursInsightRequest, GoldenHoursInsightResponse,
)
from app.services import pos_analytics_service
from app.services.telegram_service import notify_pos_upload

router = APIRouter(prefix="/spbus/{spbu_id}/pos-analytics", tags=["pos-analytics"])


def _service_error(e: Exception) -> HTTPException:
    msg = str(e)
    if msg.startswith("duplicate_batch::"):
        parts = msg.split("::")
        return HTTPException(status_code=409, detail={
            "detail": "duplicate_batch",
            "existing": {
                "batch_id": int(parts[1]),
                "total_rows": int(parts[2]),
                "tanggal_mulai": parts[3],
                "tanggal_selesai": parts[4],
                "uploaded_at": parts[5],
            }
        })
    return HTTPException(status_code=400, detail=msg)


@router.post("/upload", response_model=PosUploadResponse)
async def upload_pos(
    spbu_id: int,
    background_tasks: BackgroundTasks,
    file: UploadFile = File(...),
    produk_id: int = Form(...),
    force_replace: bool = Form(False),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> PosUploadResponse:
    """Upload Pertamina POS .xlsx or .csv file."""
    if not file.filename:
        raise HTTPException(status_code=400, detail="Nama file tidak valid")
    fname = file.filename.lower()
    if fname.endswith(".xlsx"):
        file_ext = "xlsx"
    elif fname.endswith(".csv"):
        file_ext = "csv"
    else:
        raise HTTPException(status_code=400, detail="File harus berformat .xlsx atau .csv")
    content = await file.read()
    try:
        result = await pos_analytics_service.upload_pos_xlsx(
            db, spbu_id, produk_id, content, current_user.id, force_replace, file_ext
        )
    except ValueError as e:
        raise _service_error(e)
    background_tasks.add_task(notify_pos_upload, spbu_id, result.batch_id)
    return result


@router.get("/batches", response_model=list[PosBatchListItem])
async def list_batches(
    spbu_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> list[PosBatchListItem]:
    return await pos_analytics_service.list_batches(db, spbu_id)


@router.delete("/batches/{batch_id}", response_model=dict)
async def delete_batch(
    spbu_id: int,
    batch_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> dict:
    try:
        await pos_analytics_service.delete_batch(db, spbu_id, batch_id, current_user.id)
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    return {"message": "Batch berhasil dihapus"}


@router.get("/batches/{batch_id}/transactions", response_model=PosBatchTransaksiResponse)
async def get_batch_transactions(
    spbu_id: int,
    batch_id: int,
    page: int = 1,
    per_page: int = 50,
    search: str | None = None,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> PosBatchTransaksiResponse:
    try:
        return await pos_analytics_service.get_batch_transactions(
            db, spbu_id, batch_id, page, per_page, search
        )
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))


@router.get("/compare", response_model=PosCompareResponse)
async def compare(
    spbu_id: int,
    tanggal_mulai: date,
    tanggal_selesai: date,
    produk_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> PosCompareResponse:
    return await pos_analytics_service.get_compare(db, spbu_id, produk_id, tanggal_mulai, tanggal_selesai)


@router.get("/anomali", response_model=PosAnomaliResponse)
async def anomali(
    spbu_id: int,
    tanggal: date,
    produk_id: int | None = None,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> PosAnomaliResponse:
    return await pos_analytics_service.get_anomali(db, spbu_id, tanggal, produk_id)


@router.get("/golden-hours", response_model=PosGoldenHoursResponse)
async def golden_hours(
    spbu_id: int,
    tanggal_mulai: date,
    tanggal_selesai: date,
    produk_id: int | None = None,
    shift_id: int | None = None,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> PosGoldenHoursResponse:
    return await pos_analytics_service.get_golden_hours(
        db, spbu_id, tanggal_mulai, tanggal_selesai, produk_id, shift_id
    )


@router.post("/golden-hours-insight", response_model=GoldenHoursInsightResponse)
async def golden_hours_insight(
    spbu_id: int,
    body: GoldenHoursInsightRequest,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
) -> GoldenHoursInsightResponse:
    return await pos_analytics_service.get_golden_hours_insight(
        db, spbu_id, body.tanggal_mulai, body.tanggal_selesai, body.produk_id
    )