from fastapi import APIRouter, Depends, HTTPException, Request, Form
from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse
from fastapi.templating import Jinja2Templates
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
import asyncio
import os
from datetime import datetime, timedelta, timezone

from app.core.database import get_db
from app.core.security import require_roles, get_current_user
from app.models.models import OLTDevice, MikrotikDevice, DeviceCredential, ODP, AuditLog
from app.core.ssh_identity import test_pinned_ssh_identity
from app.core.mikrotik import RealMikrotikAdapter, MikrotikProvisioningError
from app.core.genieacs import GenieACSUnavailable, get_customer_device


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 = APIRouter(dependencies=[Depends(require_roles("admin"))])


async def _probe_tcp(host: str, port: int):
    writer = None
    try:
        _, writer = await asyncio.open_connection(host, port)
        return True, None
    except OSError as exc:
        return False, str(exc)
    finally:
        if writer is not None:
            writer.close()
            await writer.wait_closed()


def _json_probe(ok: bool, message: str):
    return JSONResponse({"ok": ok, "message": message, "detail": message})


def _acs_inventory_status(device: dict | None) -> dict:
    if device is None:
        return {"state": "not_registered", "label": "Belum terdaftar", "detail": "GenieACS belum pernah menerima Inform dari ONT ini."}
    raw = device.get("last_inform")
    try:
        stamp = datetime.fromisoformat(str(raw).replace("Z", "+00:00"))
        stamp = stamp.replace(tzinfo=timezone.utc) if stamp.tzinfo is None else stamp.astimezone(timezone.utc)
    except (TypeError, ValueError):
        stamp = None
    if stamp is None or datetime.now(timezone.utc) - stamp > timedelta(minutes=15):
        return {"state": "stale", "label": "Inform kedaluwarsa", "detail": "ONT pernah terdaftar, tetapi Inform belum terbaru.", "last_inform": raw}
    return {"state": "connected", "label": "Terhubung", "detail": "Inform GenieACS terbaru diterima.", "last_inform": raw}



@router.get("/devices", response_class=HTMLResponse)
async def devices_page(request: Request, db: AsyncSession = Depends(get_db)):
    from sqlalchemy.orm import selectinload
    mikrotiks = (await db.execute(select(MikrotikDevice).order_by(MikrotikDevice.name))).scalars().all()
    olts = (await db.execute(select(OLTDevice).order_by(OLTDevice.name))).scalars().all()
    credentials = (await db.execute(select(DeviceCredential).order_by(DeviceCredential.name))).scalars().all()
    odps = (await db.execute(select(ODP).options(selectinload(ODP.mikrotik_device)).order_by(ODP.code))).scalars().all()
    odp_mikrotiks = [item for item in mikrotiks if item.is_active and item.site_id]
    from urllib.parse import urlsplit
    nbi_url = os.getenv("GENIEACS_NBI_URL", "http://127.0.0.1:7557").rstrip("/")
    parsed_nbi = urlsplit(nbi_url)
    safe_nbi_url = f"{parsed_nbi.scheme}://{parsed_nbi.hostname or '127.0.0.1'}"
    if parsed_nbi.port:
        safe_nbi_url += f":{parsed_nbi.port}"
    safe_nbi_url += parsed_nbi.path.rstrip("/")
    return templates.TemplateResponse(
        request=request,
        name="devices.html",
        context={
            "mikrotiks": mikrotiks,
            "odp_mikrotiks": odp_mikrotiks,
            "odps": odps,
            "olts": olts,
            "credentials": credentials,
            "mikrotik_credentials": [c for c in credentials if c.protocol == "mikrotik-api" and not any(w in c.name.lower() for w in ("deployment", "portal", "bwdeploy"))],
            "olt_credentials": [c for c in credentials if c.protocol == "ssh" and not any(w in c.name.lower() for w in ("deployment", "portal", "bwdeploy"))],
            "vault_error": False,
            "genieacs_nbi_url": safe_nbi_url,
        },
    )


@router.post("/devices/odps")
async def add_odp_from_devices(
    code: str = Form(...), name: str = Form(...), latitude: str = Form(...), longitude: str = Form(...),
    port_count: int = Form(8), mikrotik_device_id: int = Form(...),
    db: AsyncSession = Depends(get_db), user=Depends(get_current_user),
):
    code, name = code.strip(), name.strip()
    if not code or len(code) > 64 or not name or len(name) > 128:
        raise HTTPException(422, "Kode ODP dan nama wajib diisi (maksimal 64/128 karakter).")
    if not 1 <= port_count <= 1024:
        raise HTTPException(422, "Jumlah port harus antara 1 dan 1024.")
    mikrotik = await db.get(MikrotikDevice, mikrotik_device_id)
    if not mikrotik or not mikrotik.is_active or not mikrotik.site_id:
        raise HTTPException(422, "Pilih MikroTik aktif yang sudah dipetakan ke site.")
    try:
        lat, lng = float(latitude.strip()), float(longitude.strip())
    except (AttributeError, ValueError):
        raise HTTPException(422, "Pilih titik koordinat ODP dari peta.")
    if not -90 <= lat <= 90 or not -180 <= lng <= 180:
        raise HTTPException(422, "Koordinat berada di luar rentang yang valid.")
    row = ODP(code=code, name=name, latitude=f"{lat:.7f}", longitude=f"{lng:.7f}",
              port_count=port_count, mikrotik_device_id=mikrotik.id, is_active=True)
    db.add(row)
    try:
        await db.flush()
    except Exception as exc:
        from sqlalchemy.exc import IntegrityError
        if isinstance(exc, IntegrityError):
            await db.rollback()
            raise HTTPException(409, "Kode ODP sudah digunakan.") from exc
        raise
    db.add(AuditLog(user_id=user.id, action="create", entity="odp", entity_id=row.id,
                    detail=f"{row.code} → {mikrotik.name}"))
    await db.commit()
    return RedirectResponse("/devices#odp-management", status_code=303)


@router.post("/devices/mikrotik")
async def add_mikrotik(
    name: str = Form(...), host: str = Form(...), api_port: int = Form(8728),
    area: str = Form(""), credential_id: int | None = Form(None), db: AsyncSession = Depends(get_db),
):
    db.add(MikrotikDevice(name=name.strip(), host=host.strip(), api_port=api_port, area=area.strip(), credential_id=credential_id))
    await db.commit()
    return RedirectResponse("/devices", status_code=303)


@router.post("/devices/olt")
async def add_olt(
    name: str = Form(...), host: str = Form(...), vendor: str = Form("C-DATA"),
    model: str = Form("FD1601S-B1"), location: str = Form(""), pop_name: str = Form(""),
    management_protocol: str = Form("ssh"), api_port: int | None = Form(None),
    credential_id: int | None = Form(None), db: AsyncSession = Depends(get_db),
):
    db.add(OLTDevice(name=name.strip(), host=host.strip(), vendor=vendor.strip(), model=model.strip(),
                     location=location.strip(), pop_name=pop_name.strip(),
                     management_protocol=management_protocol.strip(), api_port=api_port or 22,
                     credential_id=credential_id))
    await db.commit()
    return RedirectResponse("/devices", status_code=303)


@router.post("/devices/olt/{device_id}/update")
async def update_olt(device_id: int, vendor: str = Form(...), model: str = Form(...), db: AsyncSession = Depends(get_db)):
    device = await db.get(OLTDevice, device_id)
    if not device:
        raise HTTPException(404, "OLT tidak ditemukan")
    device.vendor, device.model = vendor.strip(), model.strip()
    await db.commit()
    return RedirectResponse("/devices", status_code=303)


@router.post("/devices/{device_kind}/{device_id}/credential")
async def assign_credential(device_kind: str, device_id: int, credential_id: int = Form(...), db: AsyncSession = Depends(get_db)):
    model = OLTDevice if device_kind == "olt" else MikrotikDevice if device_kind == "mikrotik" else None
    if model is None:
        raise HTTPException(400, "Jenis perangkat tidak valid")
    device = await db.get(model, device_id)
    credential = await db.get(DeviceCredential, credential_id)
    if not device or not credential:
        raise HTTPException(404, "Perangkat atau credential tidak ditemukan")
    device.credential_id = credential.id
    await db.commit()
    return RedirectResponse("/devices", status_code=303)


@router.post("/devices/credentials")
async def create_credential(
    name: str = Form(...), protocol: str = Form(...), username: str = Form(...),
    secret: str = Form(...), db: AsyncSession = Depends(get_db),
):
    from app.core.device_credentials import encrypt_secret
    db.add(DeviceCredential(name=name.strip(), protocol=protocol.strip(), username=username.strip(),
                            encrypted_secret=encrypt_secret(secret)))
    await db.commit()
    return RedirectResponse("/devices", status_code=303)


@router.get("/api/voucher-sync/health")
async def voucher_sync_health(db: AsyncSession = Depends(get_db)):
    """Live health of the voucher reconciliation path (device reachability)."""
    from app.core.status_monitor import voucher_reconcile_health
    return JSONResponse(voucher_reconcile_health())


@router.post("/devices/mikrotik/{device_id}/test-routeros")
async def test_routeros_login(device_id: int, db: AsyncSession = Depends(get_db)):
    """Verify the stored credential really authenticates against RouterOS API."""
    device = await db.get(MikrotikDevice, device_id)
    if not device:
        return _json_probe(False, "Perangkat MikroTik tidak ditemukan.")
    if not device.credential_id:
        return _json_probe(False, "Belum ada kredensial yang ditugaskan ke perangkat ini.")

    credential = await db.get(DeviceCredential, device.credential_id)
    if not (credential and credential.is_active):
        return _json_probe(False, "Kredensial perangkat tidak aktif.")

    from app.core.secrets import decrypt_secret_strict, SecretDecryptionError
    try:
        password = decrypt_secret_strict(
            credential.encrypted_secret, label=f"Kredensial {credential.name}"
        )
    except SecretDecryptionError as exc:
        return _json_probe(False, str(exc))

    adapter = RealMikrotikAdapter(
        host=device.host,
        username=credential.username,
        password=password,
        api_port=device.api_port or 8728,
    )
    try:
        rows = await asyncio.to_thread(adapter.list_hotspot_users)
    except MikrotikProvisioningError as exc:
        return _json_probe(False, f"Login RouterOS gagal: {exc}")
    except Exception as exc:
        return _json_probe(False, f"Gagal menghubungi perangkat: {exc}")
    return _json_probe(True, f"Login RouterOS berhasil. {len(rows)} hotspot user terbaca di {device.host}:{device.api_port or 8728}.")


@router.post("/devices/{device_kind}/{device_id}/test-connection")
async def test_connection(device_kind: str, device_id: int, db: AsyncSession = Depends(get_db)):
    model = OLTDevice if device_kind == "olt" else MikrotikDevice if device_kind == "mikrotik" else None
    if model is None:
        raise HTTPException(400, "Jenis perangkat tidak valid")
    device = await db.get(model, device_id)
    if not device:
        raise HTTPException(404, "Perangkat tidak ditemukan")
    port = device.api_port or (22 if device_kind == "olt" else 8728)
    ok, detail = await _probe_tcp(device.host, port)
    if ok:
        return _json_probe(True, f"{device.name}: port management {device.host}:{port} dapat dijangkau pada level TCP. Protokol dan login perangkat belum diuji.")
    return _json_probe(False, f"{device.name}: port management {device.host}:{port} tidak dapat dijangkau: {detail}")



@router.get("/devices/olt/identity", response_class=JSONResponse)
async def test_assigned_cdata_ssh_identity(db: AsyncSession = Depends(get_db)):
    olt = (await db.execute(select(OLTDevice).where(OLTDevice.is_active == True).order_by(OLTDevice.id))).scalars().first()
    if not olt or not olt.credential_id:
        return _json_probe(False, "OLT aktif atau credential SSH belum tersedia.")
    credential = await db.get(DeviceCredential, olt.credential_id)
    expected = os.getenv(f"OLT_{olt.id}_SSH_HOST_KEY_SHA256")
    from app.core.ssh_identity import test_pinned_ssh_identity
    result = test_pinned_ssh_identity(host=olt.host, port=olt.api_port or 22, username=credential.username,
        encrypted_secret=credential.encrypted_secret, expected_host_key_fingerprint=expected)
    return JSONResponse({"ok": result.ok, "message": result.message, "fingerprint": result.server_fingerprint})


@router.get("/devices/olt/{olt_id}/onts", response_class=HTMLResponse)
async def list_olt_onts(olt_id: int, request: Request, pon_port: str | None = None,
                        acs_message: str | None = None, db: AsyncSession = Depends(get_db)):
    olt = await db.get(OLTDevice, olt_id)
    if not olt:
        raise HTTPException(404, "OLT tidak ditemukan")
    pon_count = 2 if (olt.vendor or "").casefold() == "c-data" and (olt.model or "").casefold() == "fd1602s-b1" else 1
    pon_ports = [f"0/0/{number}" for number in range(1, pon_count + 1)]
    selected_pon = pon_port or pon_ports[0]
    cred = await db.get(DeviceCredential, olt.credential_id) if olt.credential_id else None
    error = None
    onts = []
    if selected_pon not in pon_ports:
        error = f"PON tidak valid untuk {olt.name}. Pilih salah satu port: {', '.join(pon_ports)}."
    elif (olt.vendor or "").casefold() != "c-data" or (olt.model or "").casefold() not in {"fd1601s-b1", "fd1602s-b1"}:
        error = "Auto discovery belum didukung untuk model OLT ini."
    elif not cred or not cred.is_active or (cred.protocol or "").casefold() != "ssh":
        error = "Credential SSH OLT belum tersedia atau tidak aktif."
    else:
        try:
            from app.core.cdata_fd1601s_discovery import discover_olt_onts
            onts = discover_olt_onts(host=olt.host, port=olt.api_port or 22,
                username=cred.username, encrypted_secret=cred.encrypted_secret,
                pinned_host_key=os.getenv(f"OLT_{olt_id}_SSH_HOST_KEY_SHA256"),
                pon_port=selected_pon)
        except Exception as exc:
            error = str(exc)
    async def acs_lookup(ont):
        try:
            device = await asyncio.to_thread(get_customer_device, ont.serial_number)
            return ont.serial_number, _acs_inventory_status(device)
        except GenieACSUnavailable:
            return ont.serial_number, {"state": "unavailable", "label": "ACS tidak tersedia", "detail": "Status tidak dapat dibaca; konfigurasi ONT tidak diubah."}
    acs_status = dict(await asyncio.gather(*(acs_lookup(ont) for ont in onts))) if onts else {}
    return templates.TemplateResponse(request=request, name="ont_list.html",
        context={"olt": olt, "onts": onts, "pon_port": selected_pon, "pon_ports": pon_ports,
                 "error": error, "acs_status": acs_status, "acs_message": acs_message})


@router.post("/devices/olt/{olt_id}/onts/{serial_number}/activate-acs")
async def activate_ont_acs(olt_id: int, serial_number: str, pon_port: str = Form(...), onu_id: int = Form(...),
                           db: AsyncSession = Depends(get_db)):
    """Enable and verify TR-069 for an already registered ONU; ACS registration remains CPE-driven."""
    olt = await db.get(OLTDevice, olt_id)
    if not olt:
        raise HTTPException(404, "OLT tidak ditemukan")
    if (olt.vendor or "").casefold() != "c-data" or (olt.model or "").casefold() not in {"fd1601s-b1", "fd1602s-b1"}:
        raise HTTPException(409, "Aktivasi ACS otomatis belum didukung untuk model OLT ini.")
    credential = await db.get(DeviceCredential, olt.credential_id) if olt.credential_id else None
    if not credential or not credential.is_active or (credential.protocol or "").casefold() != "ssh":
        raise HTTPException(409, "Credential SSH OLT belum tersedia atau tidak aktif.")
    clean_serial = (serial_number or "").strip().upper()
    if not clean_serial or len(clean_serial) > 64:
        raise HTTPException(422, "Serial ONT tidak valid.")
    from app.core.cdata_executor import CDataExecutionError, configure_cdata_acs
    # The CPE-facing address is deliberately configurable. Its default matches
    # the endpoint reported by the existing, successfully enrolled ONTs.
    acs_url = os.getenv("GENIEACS_CWMP_URL", "http://161.248.172.10:7547")
    try:
        result = await asyncio.to_thread(
            configure_cdata_acs, host=olt.host, port=olt.api_port or 22,
            username=credential.username, encrypted_secret=credential.encrypted_secret,
            pinned_host_key=os.getenv(f"OLT_{olt_id}_SSH_HOST_KEY_SHA256"),
            pon_port=pon_port, onu_id=onu_id, acs_url=acs_url,
        )
        message = result.message
    except CDataExecutionError as exc:
        message = f"Aktivasi ACS gagal: {str(exc)[:240]}"
    from urllib.parse import urlencode
    return RedirectResponse(f"/devices/olt/{olt_id}/onts?{urlencode({'pon_port': pon_port, 'acs_message': message})}", status_code=303)

@router.post("/devices/credentials/{credential_id}/delete")
async def delete_credential(credential_id: int, db: AsyncSession = Depends(get_db)):
    cred = await db.get(DeviceCredential, credential_id)
    if not cred:
        raise HTTPException(404, "Kredensial tidak ditemukan")
    mk_using = (await db.execute(select(MikrotikDevice).where(MikrotikDevice.credential_id == credential_id))).scalars().first()
    olt_using = (await db.execute(select(OLTDevice).where(OLTDevice.credential_id == credential_id))).scalars().first()
    if mk_using or olt_using:
        raise HTTPException(400, "Kredensial sedang digunakan oleh perangkat.")
    await db.delete(cred)
    await db.commit()
    return RedirectResponse("/devices", status_code=303)

@router.post("/devices/{device_kind}/{device_id}/delete")
async def delete_device(device_kind: str, device_id: int, db: AsyncSession = Depends(get_db)):
    model = OLTDevice if device_kind == "olt" else MikrotikDevice if device_kind == "mikrotik" else None
    if model is None:
        raise HTTPException(400, "Jenis perangkat tidak valid")
    device = await db.get(model, device_id)
    if not device:
        raise HTTPException(404, "Perangkat tidak ditemukan")

    # If the device has a credential, check if it should be deleted
    if device.credential_id:
        cred_id = device.credential_id
        await db.delete(device) # Delete device first to exclude it from checks
        await db.flush() # Flush to apply delete before query

        # Check if other devices are still using this credential
        mk_using = (await db.execute(select(MikrotikDevice).where(MikrotikDevice.credential_id == cred_id))).scalars().first()
        olt_using = (await db.execute(select(OLTDevice).where(OLTDevice.credential_id == cred_id))).scalars().first()

        if not mk_using and not olt_using:
            cred = await db.get(DeviceCredential, cred_id)
            if cred:
                await db.delete(cred)
    else:
        await db.delete(device)

    await db.commit()
    return RedirectResponse("/devices", status_code=303)

