from fastapi import APIRouter, Request, Depends, Query, HTTPException
from fastapi.responses import HTMLResponse, RedirectResponse
from fastapi.templating import Jinja2Templates
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, func
from app.core.database import get_db
from app.core.security import require_roles, get_current_user
from app.models.models import Customer
import os
import traceback

router = APIRouter(dependencies=[Depends(require_roles("admin_cs", "teknisi", "agen_voucher"))])
BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
templates = Jinja2Templates(directory=os.path.join(BASE_DIR, "app/templates"))



@router.get("/api/customers/live")
async def customer_live_status(
    ids: str = Query(..., max_length=4000),
    db: AsyncSession = Depends(get_db),
    user=Depends(get_current_user),
):
    # The background monitor probes hardware; the browser reads its cached state.
    try:
        customer_ids = list(dict.fromkeys(int(value) for value in ids.split(",") if value.strip()))
    except ValueError as exc:
        raise HTTPException(status_code=422, detail="Daftar ID pelanggan tidak valid.") from exc
    if not customer_ids or len(customer_ids) > 25 or any(customer_id < 1 for customer_id in customer_ids):
        raise HTTPException(status_code=422, detail="Maksimal 25 ID pelanggan per permintaan.")

    rows = (await db.execute(
        select(Customer).where(Customer.id.in_(customer_ids), Customer.is_archived == False)
    )).scalars().all()
    result = []
    for customer in rows:
        olt = (customer.olt_provisioning_status or "").casefold()
        mikrotik = (customer.mikrotik_provisioning_status or "").casefold()
        status = (customer.status or "").casefold()
        provision = (customer.provisioning_status or "").casefold()
        if olt == "los":
            state = "los"
        elif olt == "dying_gasp":
            state = "dying_gasp"
        elif olt == "offline":
            state = "offline"
        elif mikrotik == "waiting_session" or status == "waiting_session":
            state = "waiting_session"
        elif mikrotik == "waiting_internet" or status == "waiting_internet":
            state = "waiting_internet"
        elif status == "active" and provision == "provisioned":
            state = "online"
        elif "failed" in (status, provision, olt, mikrotik):
            state = "failed"
        elif provision == "running":
            state = "provisioning"
        else:
            state = "unknown"
        result.append({"id": customer.id, "state": state, "power": customer.ont_rx_power})
    return {"customers": result}

@router.get("/customers", response_class=HTMLResponse)
async def list_customers(
    request: Request,
    type: str | None = Query(default=None),
    status: str | None = Query(default=None),
    page: int = Query(default=1, ge=1),
    db: AsyncSession = Depends(get_db),
    user = Depends(get_current_user),
):
    """Server-side pagination: safe for large customer populations."""
    if user.role == "teknisi":
        return RedirectResponse(url="/tasks", status_code=303)
    try:
        page_size = 25
        filters = [Customer.is_archived == False]
        if type:
            filters.append(Customer.type == type)
        if status == "pending":
            filters.append(Customer.status.in_(("request", "pending_provisioning")))
        elif status:
            filters.append(Customer.status == status)
        total = await db.scalar(select(func.count(Customer.id)).where(*filters)) or 0
        total_pages = max(1, (total + page_size - 1) // page_size)
        page = min(page, total_pages)
        from sqlalchemy.orm import selectinload
        result = await db.execute(
            select(Customer).options(selectinload(Customer.odp), selectinload(Customer.service_package), selectinload(Customer.olt_device)).where(*filters).order_by(Customer.created_at.desc()).offset((page - 1) * page_size).limit(page_size)
        )
        customers = result.scalars().all()
        return templates.TemplateResponse(
            request=request, name="customers.html",
            context={
                "customers": customers, "type_filter": type, "status_filter": status,
                "page": page, "page_size": page_size, "total": total, "total_pages": total_pages,
                "page_numbers": range(max(1, page - 2), min(total_pages, page + 2) + 1),
            },
        )
    except Exception:
        traceback.print_exc()
        return HTMLResponse(content="Gagal memuat data pelanggan.", status_code=500)
