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 and_, func, or_, select
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()
        acs = (customer.acs_wifi_status or "").casefold()
        acs_ready = acs in {"connected", "available"}
        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" or provision == "waiting_internet":
            state = "waiting_internet"
        elif (olt == "provisioned" and mikrotik == "provisioned"
              and status == "active" and provision == "provisioned" and not acs_ready):
            state = "waiting_acs"
        elif status == "active" and provision == "provisioned" and olt == "provisioned" and mikrotik == "provisioned" and acs_ready:
            state = "online"
        elif status == "active" and provision == "provisioned":
            state = "waiting_internet"
        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,
            "acs": acs or "not_configured",
        })
    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),
    device_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:
        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)
        device_filters = {
            "los": Customer.olt_provisioning_status == "los",
            "dying_gasp": Customer.olt_provisioning_status == "dying_gasp",
            "offline": or_(Customer.olt_provisioning_status == "offline", Customer.status == "offline"),
            "waiting": or_(
                Customer.status.in_(("waiting_session", "waiting_internet", "pending_configuration")),
                Customer.provisioning_status.in_(("waiting_session", "waiting_internet", "pending_configuration")),
                Customer.mikrotik_provisioning_status.in_(("waiting_session", "waiting_internet", "pending_configuration")),
            ),
            "provisioned": and_(Customer.status == "active", Customer.provisioning_status == "provisioned"),
            "failed": or_(Customer.status == "failed", Customer.provisioning_status == "failed", Customer.olt_provisioning_status == "failed", Customer.mikrotik_provisioning_status == "failed"),
            "unknown": Customer.status == "unknown",
        }
        if device_status in device_filters:
            filters.append(device_filters[device_status])
        total = await db.scalar(select(func.count(Customer.id)).where(*filters)) or 0
        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(), Customer.id.desc())
        )
        customers = result.scalars().all()
        return templates.TemplateResponse(
            request=request, name="customers.html",
            context={
                "customers": customers, "type_filter": type, "status_filter": status,
                "device_status_filter": device_status, "total": total,
            },
        )
    except Exception:
        traceback.print_exc()
        return HTMLResponse(content="Gagal memuat data pelanggan.", status_code=500)
