"""Small, read-only GenieACS NBI client for customer ONT integration."""
from __future__ import annotations

import base64
import json
import os
from urllib.error import HTTPError, URLError
from urllib.parse import quote, urlencode
from urllib.request import Request, urlopen


class GenieACSUnavailable(RuntimeError):
    pass


def _base_url() -> str:
    return os.getenv("GENIEACS_NBI_URL", "http://127.0.0.1:7557").rstrip("/")


def _request(path: str, *, query: dict | None = None, body: dict | None = None, timeout: int = 8, base_url: str | None = None, method: str | None = None):
    url = (base_url or _base_url()).rstrip("/") + path
    if query is not None:
        url += "?" + urlencode({"query": json.dumps(query, separators=(",", ":"))})
    headers = {"Accept": "application/json"}
    username = os.getenv("GENIEACS_NBI_USERNAME")
    password = os.getenv("GENIEACS_NBI_PASSWORD")
    if username and password:
        token = base64.b64encode(f"{username}:{password}".encode()).decode()
        headers["Authorization"] = f"Basic {token}"
    data = json.dumps(body).encode() if body is not None else None
    if data is not None:
        headers["Content-Type"] = "application/json"
    request = Request(url, data=data, headers=headers, method=method or ("POST" if data is not None else "GET"))
    try:
        with urlopen(request, timeout=timeout) as response:
            payload = response.read()
            return response.status, json.loads(payload) if payload else None
    except HTTPError as exc:
        try:
            payload = exc.read().decode(errors="replace")[:300]
        except Exception:
            payload = ""
        raise GenieACSUnavailable(f"GenieACS NBI HTTP {exc.code}: {payload}") from exc
    except (URLError, TimeoutError, OSError, ValueError) as exc:
        raise GenieACSUnavailable(f"GenieACS NBI tidak dapat dijangkau: {exc}") from exc


def _device_for_serial(serial_number: str, *, base_url: str | None = None) -> dict | None:
    serial = (serial_number or "").strip().upper()
    if not serial:
        return None
    _, records = _request("/devices/", query={"_deviceId._SerialNumber": serial}, base_url=base_url)
    if not isinstance(records, list):
        raise GenieACSUnavailable("Respons GenieACS NBI tidak valid.")
    return records[0] if records else None


def _walk_values(node, path=""):
    if isinstance(node, dict):
        if "_value" in node:
            yield path, node.get("_value")
            return
        for key, value in node.items():
            yield from _walk_values(value, f"{path}.{key}" if path else key)
    elif isinstance(node, list):
        for value in node:
            yield from _walk_values(value, path)


_DHCP_SERVER_PARAMETERS = (
    # TR-098 InternetGatewayDevice model used by many ONTs.
    "InternetGatewayDevice.LANDevice.1.LANHostConfigManagement.DHCPServerEnable",
    # TR-181 Device model exposed by newer ONTs.
    "Device.DHCPv4.Server.1.Enable",
)


def _parameter_node(device: dict, wanted: str) -> dict | None:
    def walk(node, path=""):
        if isinstance(node, dict):
            if "_value" in node:
                return node if path == wanted else None
            for key, child in node.items():
                found = walk(child, f"{path}.{key}" if path else key)
                if found is not None:
                    return found
        elif isinstance(node, list):
            for child in node:
                found = walk(child, path)
                if found is not None:
                    return found
        return None

    return walk(device)



def verify_default_pppoe_route(serial_number: str, username: str, *, fresh_minutes: int = 15) -> dict:
    """Verify GenieACS sees this ONT selecting its active customer PPPoE WAN."""
    from datetime import datetime, timedelta, timezone

    device = _device_for_serial(serial_number)
    if not device:
        return {"status": "unavailable", "detail": "ONT tidak ditemukan di GenieACS."}

    def stamp(raw):
        try:
            value = datetime.fromisoformat(str(raw).replace("Z", "+00:00"))
            return value.replace(tzinfo=timezone.utc) if value.tzinfo is None else value.astimezone(timezone.utc)
        except (TypeError, ValueError):
            return None

    last_inform = stamp(device.get("_lastInform"))
    if last_inform is None or datetime.now(timezone.utc) - last_inform > timedelta(minutes=max(1, fresh_minutes)):
        return {"status": "stale", "detail": "Inform ONT ACS belum terbaru."}

    values = dict(_walk_values(device))
    connection = None
    for path, value in values.items():
        if "WANPPPConnection." in path and path.endswith(".Username") and str(value or "").strip() == str(username).strip():
            connection = path.rsplit(".", 1)[0]
            break
    if not connection:
        return {"status": "waiting", "detail": "WAN PPPoE pelanggan belum terdeteksi oleh ACS."}

    default_node = _parameter_node(device, "InternetGatewayDevice.Layer3Forwarding.DefaultConnectionService")
    if not default_node:
        return {"status": "unavailable", "detail": "ONT tidak mengekspos pilihan WAN default."}
    if str(default_node.get("_value") or "").strip() != connection:
        return {"status": "mismatch", "detail": "WAN default ONT belum menunjuk ke sesi PPPoE pelanggan."}
    prefix = connection + "."
    if str(values.get(prefix + "Enable", "")).casefold() not in {"true", "1", "enabled"}:
        return {"status": "waiting", "detail": "WAN PPPoE pelanggan belum aktif pada ONT."}
    if str(values.get(prefix + "ConnectionStatus", "")).casefold() != "connected":
        return {"status": "waiting", "detail": "Sesi PPPoE pada ONT belum tersambung."}
    if str(values.get(prefix + "ExternalIPAddress", "")).strip() in {"", "0.0.0.0"}:
        return {"status": "waiting", "detail": "WAN PPPoE ONT belum memperoleh alamat IP."}
    return {"status": "ready", "detail": "ONT memilih WAN PPPoE pelanggan sebagai jalur default."}


def _dhcp_server_state(device: dict) -> dict:
    readonly_fallback = None
    for path in _DHCP_SERVER_PARAMETERS:
        node = _parameter_node(device, path)
        if node is None:
            continue
        raw = node.get("_value")
        if isinstance(raw, bool):
            enabled = raw
        elif str(raw).strip().casefold() in {"1", "true", "enabled"}:
            enabled = True
        elif str(raw).strip().casefold() in {"0", "false", "disabled"}:
            enabled = False
        else:
            enabled = None
        state = {
            "available": enabled is not None,
            "enabled": enabled,
            "writable": node.get("_writable") is True,
            "parameter": path,
        }
        if enabled is None:
            continue
        if state["writable"]:
            return state
        if readonly_fallback is None:
            readonly_fallback = state
    return readonly_fallback or {"available": False, "enabled": None, "writable": False, "parameter": None}


def configure_pppoe_wan(serial_number: str, *, username: str, password: str, vlan: int, nbi_url: str | None = None, wait_seconds: int = 75, reuse_vlan: bool = False) -> dict:
    """Idempotently ensure a TR-069 WAN PPP connection through GenieACS."""
    import re, time
    from datetime import datetime, timedelta, timezone
    if not username or not password or not 1 <= int(vlan) <= 4094:
        raise GenieACSUnavailable("Incomplete PPPoE data for ACS configuration.")
    base_url = (nbi_url or "").strip().rstrip("/") or None
    device = _device_for_serial(serial_number, base_url=base_url)
    if not device or not device.get("_id"):
        raise GenieACSUnavailable("ONT is not registered in GenieACS; ACS management path is unavailable.")
    device_id = device["_id"]
    table_re = re.compile(r"^(.*?WANPPPConnection)\.(\d+)\.(.+)$", re.I)
    def rows_for(record):
        rows = {}
        for path, value in _walk_values(record):
            match = table_re.match(path)
            if match: rows.setdefault((match.group(1), match.group(2)), {})[match.group(3)] = value
        return rows
    def parameter(record, wanted):
        def walk(node, path=""):
            if isinstance(node, dict):
                if "_value" in node: return node if path == wanted else None
                for key, child in node.items():
                    found = walk(child, f"{path}.{key}" if path else key)
                    if found is not None: return found
            elif isinstance(node, list):
                for child in node:
                    found = walk(child, path)
                    if found is not None: return found
            return None
        return walk(record)
    def pending_tasks():
        try:
            _, tasks = _request("/tasks/", query={"device": device_id}, base_url=base_url)
        except GenieACSUnavailable as exc:
            raise GenieACSUnavailable("Tidak dapat memeriksa antrean task ACS; pembuatan WAN dihentikan agar tidak duplikat.") from exc
        if not isinstance(tasks, list):
            raise GenieACSUnavailable("Respons antrean task ACS tidak valid; pembuatan WAN dihentikan.")
        return tasks
    def pending_add():
        _, tasks = _request("/tasks/", query={"device": device_id}, base_url=base_url)
        if not isinstance(tasks, list):
            raise GenieACSUnavailable("Respons antrean task ACS tidak valid; pembuatan WAN dihentikan.")
        from datetime import datetime, timezone, timedelta
        def stamp(raw):
            try:
                parsed = datetime.fromisoformat(str(raw).replace("Z", "+00:00"))
                return parsed.replace(tzinfo=timezone.utc) if parsed.tzinfo is None else parsed.astimezone(timezone.utc)
            except (TypeError, ValueError):
                return None
        last_inform = stamp(device.get("_lastInform"))
        now = datetime.now(timezone.utc)
        found_pending = False
        for task in tasks:
            if (not isinstance(task, dict)
                    or str(task.get("name", "")).casefold() != "addobject"
                    or "wanpppconnection" not in str(task.get("objectName", "")).casefold()):
                continue
            created = stamp(task.get("timestamp"))
            # If a later Inform arrived and the same AddObject is still queued,
            # GenieACS did not deliver it. Remove only that stale task and let
            # the idempotent WAN check queue one fresh task below.
            if (created is not None and last_inform is not None
                    and now - created > timedelta(minutes=2)
                    and last_inform > created):
                task_id = task.get("_id")
                if not task_id:
                    raise GenieACSUnavailable("ACS task PPPoE kedaluwarsa tidak memiliki ID; pembuatan ulang ditahan.")
                try:
                    _request(f"/tasks/{quote(str(task_id), safe='')}", method="DELETE", base_url=base_url)
                except GenieACSUnavailable as exc:
                    raise GenieACSUnavailable("Task PPPoE ACS kedaluwarsa tidak dapat dibersihkan; pembuatan WAN baru ditahan.") from exc
                continue
            found_pending = True
        return found_pending
    rows = rows_for(device)
    table = next((k[0] for k in rows), "InternetGatewayDevice.WANDevice.1.WANConnectionDevice.1.WANPPPConnection")
    matching = next((k for k,v in rows.items() if str(v.get("Username", "")).strip() == username), None)
    if matching is None and reuse_vlan:
        candidates = [k for k, v in rows.items()
            if str(v.get("X_ZTE-COM_VLANID", "")).strip() == str(int(vlan))
            and str(v.get("ConnectionType", "")).casefold() in {"ip_routed", "routed"}
            and bool(v.get("Enable"))
            and str(v.get("ExternalIPAddress", "")).strip() not in {"", "0.0.0.0"}]
        if len(candidates) != 1:
            raise GenieACSUnavailable("ACS tidak menemukan tepat satu WAN PPPoE aktif pada VLAN layanan; WAN ONT tidak diubah.")
        matching = candidates[0]
    if matching is None:
        matching = next((k for k,v in rows.items() if not str(v.get("Username", "") or "").strip()), None)
        if matching is None:
            if not pending_add():
                path = f"/devices/{quote(device_id, safe='')}/tasks?timeout=5000"
                try:
                    _request(path, body={"name": "addObject", "objectName": table}, base_url=base_url)
                except GenieACSUnavailable as exc:
                    raise GenieACSUnavailable("GenieACS gagal menerima task pembuatan WAN PPPoE.") from exc
            deadline = time.monotonic() + max(10, min(int(wait_seconds), 90))
            while time.monotonic() < deadline:
                time.sleep(3)
                device = _device_for_serial(serial_number, base_url=base_url)
                if not device: continue
                rows = rows_for(device)
                matching = next((k for k,v in rows.items() if str(v.get("Username", "")).strip() == username), None)
                if matching is None: matching = next((k for k,v in rows.items() if k[0].casefold() == table.casefold() and not str(v.get("Username", "") or "").strip()), None)
                if matching: break
            if matching is None: raise GenieACSUnavailable("ACS addObject task is waiting for an ONT Inform; held to prevent duplicate WAN objects.")
    table_path, instance = matching
    root = f"{table_path}.{instance}"
    default_service_path = "InternetGatewayDevice.Layer3Forwarding.DefaultConnectionService"
    default_service = parameter(device, default_service_path)
    if default_service is None:
        raise GenieACSUnavailable("ACS does not expose the default routed WAN parameter; refusing to report WAN synchronization as complete.")
    if default_service.get("_writable") is not True:
        raise GenieACSUnavailable("ACS marks the default routed WAN parameter as not writable.")
    default_service_value = f"{table_path}.{instance}"
    dns_servers = os.getenv("BESTWEB_PPPOE_DNS_SERVERS", "170.100.100.1,8.8.8.8").strip()
    if not dns_servers:
        raise GenieACSUnavailable("DNS PPPoE kosong; WAN ONT tidak akan dianggap siap.")
    connection_name = os.getenv("BESTWEB_PPPOE_CONNECTION_NAME", "DEV.IP.IF5").strip()
    fields = [("Enable",True,"xsd:boolean",True),("Username",username,"xsd:string",True),("Password",password,"xsd:string",True),("ConnectionType","IP_Routed","xsd:string",False),("ConnectionTrigger","AlwaysOn","xsd:string",False),("Name",connection_name,"xsd:string",False),("MaxMTUSize",1492,"xsd:unsignedInt",False),("NATEnabled",True,"xsd:boolean",False),("X_ZTE-COM_VLANEnable",True,"xsd:boolean",False),("X_ZTE-COM_VLANID",int(vlan),"xsd:unsignedInt",False),("DNSEnabled",True,"xsd:boolean",False),("DNSOverrideAllowed",False,"xsd:boolean",False),("DNSServers",dns_servers,"xsd:string",True)]
    changes = []
    for leaf,value,kind,required in fields:
        path = root+"."+leaf
        node = parameter(device,path)
        if node is None:
            if required: raise GenieACSUnavailable(f"ACS data model does not expose PPPoE parameter {leaf}.")
            continue
        if node.get("_value") == value:
            continue
        if node.get("_writable") is not True:
            if required: raise GenieACSUnavailable(f"ACS marks PPPoE parameter {leaf} as not writable.")
            continue
        changes.append([path,value,kind])
    def stamp(raw):
        try:
            value = datetime.fromisoformat(str(raw).replace("Z", "+00:00"))
            return value.replace(tzinfo=timezone.utc) if value.tzinfo is None else value.astimezone(timezone.utc)
        except (TypeError, ValueError):
            return None
    last_inform_stamp = stamp(device.get("_lastInform"))
    default_stamp = stamp(default_service.get("_timestamp"))
    selector_stale = (default_stamp is None or
        (last_inform_stamp is not None and last_inform_stamp - default_stamp > timedelta(minutes=15)))
    if default_service.get("_value") != default_service_value or selector_stale:
        changes.append([default_service_path,default_service_value,"xsd:string"])
    pending_config = any(
        str(task.get("name", "")).casefold() == "setparametervalues"
        and any(isinstance(item, list) and item and (str(item[0]).startswith(root + ".") or str(item[0]) == default_service_path) for item in task.get("parameterValues", []))
        for task in pending_tasks() if isinstance(task, dict)
    )
    if changes and not pending_config:
        path = f"/devices/{quote(device_id, safe='')}/tasks?timeout=5000"
        try:
            _request(path, body={"name":"setParameterValues","parameterValues":changes}, base_url=base_url)
        except GenieACSUnavailable as exc:
            raise GenieACSUnavailable("GenieACS gagal menerima konfigurasi WAN PPPoE.") from exc
    deadline = time.monotonic() + max(0, min(int(wait_seconds), 90))
    verified = False
    while True:
        latest = _device_for_serial(serial_number, base_url=base_url)
        latest_rows = rows_for(latest or {})
        current = latest_rows.get((table_path, instance), {})
        if (str(current.get("Username", "")).strip() == username
                and bool(current.get("Enable"))
                and bool(current.get("NATEnabled"))
                and str(current.get("X_ZTE-COM_VLANID", "")).strip() == str(int(vlan))
                and str(current.get("ExternalIPAddress", "")).strip() not in {"", "0.0.0.0"}
                and str(current.get("ConnectionStatus", "")).casefold() == "connected"
                and str(current.get("DNSServers", "")).replace(" ", "") == dns_servers.replace(" ", "")):
            latest_default = parameter(latest or {}, default_service_path)
            latest_inform_stamp = stamp((latest or {}).get("_lastInform"))
            latest_default_stamp = stamp(latest_default.get("_timestamp")) if latest_default else None
            selector_fresh = (latest_default_stamp is not None
                and datetime.now(timezone.utc) - latest_default_stamp <= timedelta(minutes=15)
                and (latest_inform_stamp is None or latest_inform_stamp - latest_default_stamp <= timedelta(minutes=15)))
            if latest_default and latest_default.get("_value") == default_service_value and selector_fresh:
                verified = True
                break
        if time.monotonic() >= deadline:
            break
        time.sleep(3)
    return {"accepted":True,"queued":bool(changes) or pending_config,"instance":instance,
            "changed_parameters":len(changes),"connected":verified,
            "message":"ONT PPPoE WAN and default routed connection synchronized via ACS; PPP session and internet are still verified on MikroTik."}


def get_customer_device(serial_number: str) -> dict | None:
    """Return safe status/telemetry; never returns credentials or request URLs."""
    device = _device_for_serial(serial_number)
    if device is None:
        return None
    values = list(_walk_values(device))
    by_path = {path: value for path, value in values}
    optical = []
    markers = ("optical", "rxpower", "receivepower", "signallevel", "receivedpower")
    for path, value in values:
        if any(marker in path.casefold() for marker in markers) and value not in (None, ""):
            optical.append({"parameter": path, "value": value})
    def first(suffixes):
        for path, value in values:
            if any(path.casefold().endswith(s.casefold()) for s in suffixes) and value not in (None, ""):
                return value
        return None
    return {
        "device_id": device.get("_id"),
        "last_inform": device.get("_lastInform"),
        "last_boot": device.get("_lastBoot"),
        "manufacturer": first(("DeviceInfo.Manufacturer", "DeviceInfo.ManufacturerName")),
        "model": first(("DeviceInfo.ModelName",)),
        "serial_number": serial_number,
        "optical_parameters": optical[:20],
        "parameter_count": len(values),
    }


def request_ont_ip_ping(serial_number: str, *, host: str = "1.1.1.1", fresh_minutes: int = 15, result_ttl_seconds: int = 300) -> dict:
    """Use the ONT's TR-098 IPPingDiagnostics as an automatic, customer-free check.

    A stale CPE or a device with an existing task backlog is left untouched so
    this check cannot pile up behind older WiFi/configuration tasks.
    """
    from datetime import datetime, timedelta, timezone

    if host not in {"1.1.1.1", "8.8.8.8"}:
        raise GenieACSUnavailable("Host diagnostik ONT tidak diizinkan.")
    device = _device_for_serial(serial_number)
    if not device or not device.get("_id"):
        return {"status": "unavailable", "detail": "ONT belum terdaftar di GenieACS."}

    def stamp(raw):
        try:
            value = datetime.fromisoformat(str(raw).replace("Z", "+00:00"))
            return value.replace(tzinfo=timezone.utc) if value.tzinfo is None else value.astimezone(timezone.utc)
        except (TypeError, ValueError):
            return None

    now = datetime.now(timezone.utc)
    last_inform = stamp(device.get("_lastInform"))
    if last_inform is None or now - last_inform > timedelta(minutes=max(1, fresh_minutes)):
        return {"status": "unavailable", "detail": "ONT belum mengirim Inform ACS terbaru; tes otomatis menunggu koneksi GenieACS."}

    device_id = device["_id"]
    try:
        _, faults = _request("/faults/", query={"device": device_id})
    except GenieACSUnavailable:
        faults = []
    for fault in faults or []:
        code = str(fault.get("code", "")).casefold()
        if code in {"cwmp.9002", "cwmp.9003"} and "IPPingDiagnostics." in json.dumps(fault, sort_keys=True):
            return {"status": "unsupported", "detail": "ONT menolak IPPingDiagnostics; task ping tidak diulang."}

    prefix = "InternetGatewayDevice.IPPingDiagnostics."
    state_node = _parameter_node(device, prefix + "DiagnosticsState")
    state = str(state_node.get("_value", "")).strip().casefold() if state_node else ""
    diag_stamp = stamp(state_node.get("_timestamp")) if state_node else None
    recent = diag_stamp is not None and now - diag_stamp <= timedelta(seconds=max(30, result_ttl_seconds))
    if recent and state in {"complete", "completed"}:
        success_node = _parameter_node(device, prefix + "SuccessCount")
        failures_node = _parameter_node(device, prefix + "FailureCount")
        try:
            successes = int(success_node.get("_value") or 0) if success_node else 0
            failures = int(failures_node.get("_value") or 0) if failures_node else 0
        except (TypeError, ValueError):
            successes, failures = 0, 0
        return {"status": "success" if successes > 0 else "failed", "success_count": successes,
                "failure_count": failures, "checked_at": diag_stamp.isoformat(),
                "detail": "ONT berhasil ping internet via GenieACS." if successes > 0 else "Tes ping internet dari ONT selesai tanpa balasan."}
    if state.startswith("error_") and recent:
        return {"status": "failed", "checked_at": diag_stamp.isoformat(),
                "detail": "Tes ping ONT gagal: " + state}
    if state == "requested":
        return {"status": "pending", "detail": "ONT sedang menjalankan tes ping internet via GenieACS."}

    device_id = device["_id"]
    _, tasks = _request("/tasks/", query={"device": device_id})
    if not isinstance(tasks, list):
        return {"status": "unavailable", "detail": "Antrean task GenieACS tidak dapat dibaca."}
    if tasks:
        return {"status": "unavailable", "detail": f"Tes ONT ditahan karena ada {len(tasks)} task GenieACS lama yang belum tersinkron."}

    required = {
        "Host": (host, "xsd:string"),
        "NumberOfRepetitions": (3, "xsd:unsignedInt"),
        "Timeout": (2000, "xsd:unsignedInt"),
        "DiagnosticsState": ("Requested", "xsd:string"),
    }
    parameters = []
    for leaf, (value, kind) in required.items():
        node = _parameter_node(device, prefix + leaf)
        if node is None or node.get("_writable") is not True:
            return {"status": "unsupported", "detail": f"ONT tidak menyediakan field diagnostik writable: {leaf}."}
        parameters.append([prefix + leaf, value, kind])

    path = f"/devices/{quote(device_id, safe='')}/tasks?timeout=5000"
    try:
        _request(path, body={"name": "setParameterValues", "parameterValues": parameters})
    except GenieACSUnavailable as exc:
        return {"status": "unavailable", "detail": str(exc)[:240]}
    return {"status": "pending", "detail": "Tes ping otomatis dikirim ke ONT; menunggu hasil dari Inform GenieACS."}


def refresh_customer_device(serial_number: str) -> dict:
    """Queue a read-only model refresh and ask GenieACS to connection-request the ONT."""
    device = _device_for_serial(serial_number)
    if device is None:
        raise GenieACSUnavailable("ONT belum terdaftar di GenieACS.")
    device_id = device.get("_id")
    if not device_id:
        raise GenieACSUnavailable("GenieACS tidak mengembalikan ID perangkat.")
    path = f"/devices/{quote(device_id, safe='')}/tasks?timeout=5000"
    status, task = _request(path, body={"name": "refreshObject", "objectName": "InternetGatewayDevice"}, timeout=8)
    return {"accepted": status in (200, 202), "queued": status == 202, "task_id": (task or {}).get("_id")}


def _wifi_fields(device: dict) -> list[dict]:
    import re
    fields = {}
    for path, value in _walk_values(device):
        match = re.search(r"(?:WLANConfiguration|SSID|AccessPoint)\.(\d+)\.", path)
        if not match: continue
        leaf = path.rsplit(".", 1)[-1]
        # Do not confuse WLANConfiguration.N.Enable with WLANConfiguration.N.WPS.Enable.
        if leaf == "Enable" and not re.search(r"(?:WLANConfiguration|AccessPoint)\.\d+\.Enable$", path):
            continue
        if leaf in ("SSID", "Enable", "KeyPassphrase", "PreSharedKey", "ModeEnabled", "BeaconType", "BasicEncryptionModes", "BasicAuthenticationMode", "IEEE11iEncryptionModes", "IEEE11iAuthenticationMode", "WPAEncryptionModes", "WPAAuthenticationMode"):
            fields[(match.group(1), leaf)] = {"path": path, "value": value}
    profiles = {}
    for (index, leaf), item in fields.items():
        row = profiles.setdefault(index, {"wlan": int(index), "paths": {}, "values": {}})
        row["paths"][leaf] = item["path"]; row["values"][leaf] = item["value"]
    for row in profiles.values():
        row["ssid"] = row["values"].get("SSID"); row["enabled"] = row["values"].get("Enable")
        row["security"] = row["values"].get("ModeEnabled", row["values"].get("BeaconType"))
        secret = row["values"].get("KeyPassphrase", row["values"].get("PreSharedKey"))
        if secret and str(secret).strip() not in ("", "********", "**********"): row["password"] = secret
        row.pop("values", None)
    return sorted(profiles.values(), key=lambda x: x["wlan"])


def get_wifi_configuration(serial_number: str) -> dict:
    device = _device_for_serial(serial_number)
    if device is None: return {"found": False, "message": "ONT not found in GenieACS."}
    dhcp_server = _dhcp_server_state(device)
    rows = _wifi_fields(device)
    if not rows: return {"found": True, "last_inform": device.get("_lastInform"), "data": [], "dhcp_server": dhcp_server, "message": "WLAN parameters are not reported to ACS yet."}
    return {"found": True, "last_inform": device.get("_lastInform"), "data": rows, "dhcp_server": dhcp_server}


def set_dhcp_server_configuration(serial_number: str, *, enabled: bool) -> dict:
    """Queue a LAN DHCP server toggle only when the ONT exposes it as writable."""
    if not isinstance(enabled, bool):
        raise GenieACSUnavailable("DHCP server state must be true or false.")
    device = _device_for_serial(serial_number)
    if device is None:
        raise GenieACSUnavailable("ONT is not registered in GenieACS.")
    device_id = device.get("_id")
    if not device_id:
        raise GenieACSUnavailable("GenieACS did not return a device ID.")
    state = _dhcp_server_state(device)
    if not state["available"]:
        raise GenieACSUnavailable("ACS does not report a supported LAN DHCP server parameter for this ONT.")
    if not state["writable"]:
        raise GenieACSUnavailable("ACS marks the LAN DHCP server parameter as not writable.")
    if state["enabled"] == enabled:
        return {"accepted": True, "queued": False, "changed": False, "enabled": enabled, "parameter": state["parameter"]}
    path = f"/devices/{quote(device_id, safe='')}/tasks?timeout=5000&connection_request"
    status, task = _request(path, body={
        "name": "setParameterValues",
        "parameterValues": [[state["parameter"], enabled, "xsd:boolean"]],
    })
    return {
        "accepted": status in (200, 202), "queued": status == 202,
        "changed": True, "enabled": enabled, "parameter": state["parameter"],
        "task_id": (task or {}).get("_id"),
    }


def set_wifi_configuration(serial_number: str, *, wlan: int, ssid: str | None = None, password: str | None = None, open_network: bool | None = None) -> dict:
    device = _device_for_serial(serial_number)
    if device is None: raise GenieACSUnavailable("ONT is not registered in GenieACS.")
    row = next((item for item in _wifi_fields(device) if item["wlan"] == wlan), None)
    if row is None: raise GenieACSUnavailable(f"WLAN {wlan} is not present in the ACS data model.")
    # Queue changes even when the cached Inform is old. GenieACS will request
    # a connection and apply the task when the ONT becomes reachable.
    def writable(wanted):
        def walk(node, path=""):
            if isinstance(node, dict):
                if "_value" in node and path == wanted: return node.get("_writable") is True
                for key, val in node.items():
                    found = walk(val, f"{path}.{key}" if path else key)
                    if found is not None: return found
            elif isinstance(node, list):
                for val in node:
                    found = walk(val, path)
                    if found is not None: return found
        return walk(device)
    changes = []
    def queue_change(path, value, kind="xsd:string"):
        node = _parameter_node(device, path)
        if node is not None and node.get("_value") == value:
            return
        if not writable(path):
            raise GenieACSUnavailable(f"ACS marks WiFi parameter {path.rsplit('.', 1)[-1]} as not writable.")
        changes.append([path, value, kind])
    def add_parameter(leaf, value, kind="xsd:string", *, required=True):
        path = row["paths"].get(leaf)
        if not path:
            if required: raise GenieACSUnavailable(f"ACS does not expose required WiFi parameter {leaf}.")
            return
        queue_change(path, value, kind)
    if ssid is not None:
        add_parameter("SSID", ssid)
    if open_network is True:
        mode_path = row["paths"].get("ModeEnabled") or row["paths"].get("BeaconType")
        if not mode_path or not writable(mode_path):
            raise GenieACSUnavailable("Writable WiFi security-mode parameter was not found in ACS.")
        is_legacy = mode_path.endswith(".BeaconType")
        queue_change(mode_path, "Basic" if is_legacy else "None", "xsd:string")
        if is_legacy:
            for leaf, value in (("BasicEncryptionModes", "None"), ("BasicAuthenticationMode", "None"), ("WPAEncryptionModes", "None"), ("WPAAuthenticationMode", "None"), ("IEEE11iEncryptionModes", "None"), ("IEEE11iAuthenticationMode", "None")):
                legacy_path = row["paths"].get(leaf)
                if legacy_path and writable(legacy_path):
                    queue_change(legacy_path, value, "xsd:string")
        key = row["paths"].get("KeyPassphrase") or row["paths"].get("PreSharedKey")
        if key and writable(key):
            queue_change(key, "", "xsd:string")
    elif open_network is False:
        if not password:
            raise GenieACSUnavailable("Masukkan password WiFi untuk mengaktifkan WPA2.")
        mode_path = row["paths"].get("ModeEnabled") or row["paths"].get("BeaconType")
        if not mode_path or not writable(mode_path):
            raise GenieACSUnavailable("Writable WiFi security-mode parameter was not found in ACS.")
        is_legacy = mode_path.endswith(".BeaconType")
        if is_legacy:
            # Values verified against the selected ZTE WLAN data model.
            add_parameter("IEEE11iEncryptionModes", "AESEncryption")
            add_parameter("IEEE11iAuthenticationMode", "PSKAuthentication")
            queue_change(mode_path, "11i", "xsd:string")
        else:
            queue_change(mode_path, "WPA2-Personal", "xsd:string")
        key = row["paths"].get("KeyPassphrase") or row["paths"].get("PreSharedKey")
        if not key or not writable(key):
            raise GenieACSUnavailable("ACS tidak menyediakan parameter password WLAN yang dapat ditulis.")
        queue_change(key, password, "xsd:string")
    elif password is not None:
        key = row["paths"].get("KeyPassphrase") or row["paths"].get("PreSharedKey")
        if not key or not writable(key): raise GenieACSUnavailable("Writable WLAN password parameter was not found.")
        queue_change(key, password, "xsd:string")
    if not changes:
        return {"accepted": True, "queued": False, "changed": False, "wlan": wlan, "parameters": []}
    path = f"/devices/{quote(device.get('_id'), safe='')}/tasks?timeout=5000&connection_request"
    status, task = _request(path, body={"name": "setParameterValues", "parameterValues": changes})
    return {"accepted": status in (200, 202), "queued": status == 202, "changed": True, "task_id": (task or {}).get("_id"), "parameters": [x[0] for x in changes], "wlan": wlan}

def sync_psb_internet_wan(serial_number: str, *, username: str, password: str, vlan: int, customer_created_at=None, dry_run: bool = False) -> dict:
    """Synchronize one ZTE Internet WAN without creating duplicate ACS tasks.

    This operation changes Internet WAN parameters only. ACS enrollment,
    SSIDs and passwords remain controlled by the separate customer workflow.
    """
    import re
    from datetime import datetime, timedelta, timezone

    serial = (serial_number or "").strip().upper()
    if not re.fullmatch(r"ZTE[A-Z0-9_-]{5,61}", serial) or not username or not password or not 1 <= int(vlan) <= 4094:
        raise GenieACSUnavailable("Data serial, PPPoE, atau VLAN tidak valid.")
    _, records = _request("/devices/", query={"_deviceId._SerialNumber": serial})
    if not isinstance(records, list) or len(records) != 1 or not records[0].get("_id"):
        return {"ready": False, "state": "waiting", "message": "Menunggu ONT yang tepat terhubung untuk sinkronisasi WAN."}
    device = records[0]
    device_id = device["_id"]

    def timestamp(value):
        try:
            result = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
            return result.replace(tzinfo=timezone.utc) if result.tzinfo is None else result.astimezone(timezone.utc)
        except (ValueError, TypeError):
            return None

    now = datetime.now(timezone.utc)
    inform = timestamp(device.get("_lastInform"))
    if inform is None or now - inform > timedelta(minutes=15):
        return {"ready": False, "state": "waiting", "message": "Menunggu ONT kembali terhubung agar WAN dapat disinkronkan."}
    cutoff = timestamp(customer_created_at)
    if cutoff is not None and inform < cutoff:
        return {"ready": False, "state": "waiting", "message": "Menunggu ONT mengirim pembaruan setelah pendaftaran pelanggan."}

    def obj(path):
        node = device
        for part in path.split("."):
            if not isinstance(node, dict):
                return None
            node = node.get(part)
        return node if isinstance(node, dict) else None

    def val(path):
        node = _parameter_node(device, path)
        return node.get("_value") if node else None

    def flag(value):
        return value is True or str(value).strip().casefold() in {"true", "1", "yes"}

    table = "InternetGatewayDevice.WANDevice.1.WANConnectionDevice.1.WANPPPConnection"
    routing = "InternetGatewayDevice.Layer3Forwarding"
    binding = "InternetGatewayDevice.X_ZTE-COM_PortBinding"
    lanhost = "InternetGatewayDevice.LANDevice.1.LANHostConfigManagement"
    default_path = routing + ".DefaultConnectionService"
    paths = (table, routing, binding, lanhost)
    _, tasks = _request("/tasks/", query={"device": device_id})
    if not isinstance(tasks, list):
        raise GenieACSUnavailable("Antrean perangkat tidak dapat dibaca; konfigurasi ditahan.")
    _, faults = _request("/faults/", query={"device": device_id})
    if not isinstance(faults, list):
        raise GenieACSUnavailable("Status kesalahan perangkat tidak dapat dibaca.")

    # Failed configuration tasks left by a deleted subscriber must not be
    # replayed against the new subscriber. Remove only faulted tasks for this
    # exact device that predate this customer's creation and touch service WAN
    # or WLAN settings. Current-customer tasks and unrelated tasks are kept.
    fault_channels = {str(f.get("channel", "")) for f in faults if isinstance(f, dict)}
    stale_failed = []
    if cutoff is not None:
        for task in tasks:
            if not isinstance(task, dict) or str(task.get("name", "")).casefold() != "setparametervalues":
                continue
            task_id = task.get("_id")
            created = timestamp(task.get("timestamp"))
            if not task_id or created is None or created >= cutoff or "task_" + str(task_id) not in fault_channels:
                continue
            params = task.get("parameterValues", [])
            if any(isinstance(item, list) and item and (
                    str(item[0]).startswith(table + ".")
                    or str(item[0]) == default_path
                    or str(item[0]).startswith(binding + ".")
                    or str(item[0]).startswith("InternetGatewayDevice.LANDevice.1.WLANConfiguration.")
                    or str(item[0]) == lanhost + ".DHCPServerEnable") for item in params):
                stale_failed.append(str(task_id))
    if stale_failed:
        if dry_run:
            return {"ready": False, "state": "cleanup", "message": "Task gagal dari pelanggan sebelumnya perlu dibersihkan.", "count": len(stale_failed)}
        for task_id in stale_failed:
            _request("/tasks/" + quote(task_id, safe=""), method="DELETE")
        return {"ready": False, "state": "waiting", "message": "Task gagal milik konfigurasi pelanggan sebelumnya dibersihkan."}

    related = []
    for task in tasks:
        if not isinstance(task, dict):
            continue
        kind = str(task.get("name", "")).casefold()
        object_name = str(task.get("objectName", ""))
        params = task.get("parameterValues", [])
        is_related = (
            kind in {"refreshobject", "addobject"} and object_name in paths
        ) or (
            kind == "setparametervalues" and any(
                isinstance(item, list) and item and
                (str(item[0]).startswith(table + ".") or str(item[0]) == default_path
                 or (str(item[0]).startswith(binding + ".") and str(item[0]).endswith(".WANInterface"))
                 or str(item[0]).startswith("InternetGatewayDevice.LANDevice.1.WLANConfiguration.")
                 or str(item[0]) == lanhost + ".DHCPServerEnable")
                for item in params
            )
        )
        if is_related:
            related.append(task)
    if related:
        channels = {"task_" + str(task.get("_id")) for task in related if task.get("_id")}
        fault = next((f for f in faults if isinstance(f, dict) and str(f.get("channel", "")) in channels), None)
        if fault:
            return {"ready": False, "state": "failed", "message": "ONT menolak sinkronisasi WAN (" + str(fault.get("code", "error"))[:40] + "); data pelanggan tetap tersimpan."}
        return {"ready": False, "state": "waiting", "message": "Menunggu ONT menyelesaikan sinkronisasi WAN yang sudah dikirim."}

    # Refresh all relevant trees before using a previous customer's cached WAN.
    stale = []
    for path in paths:
        node = obj(path)
        stamp = timestamp(node.get("_timestamp")) if node else None
        if node is None or stamp is None or now - stamp > timedelta(minutes=15) or (cutoff is not None and stamp < cutoff):
            stale.append(path)
    if stale:
        if dry_run:
            return {"ready": False, "state": "refresh", "message": "Pembacaan perangkat perlu diperbarui.", "refresh": stale}
        for path in stale:
            _request(f"/devices/{quote(device_id, safe='')}/tasks?timeout=5000",
                     body={"name": "refreshObject", "objectName": path})
        return {"ready": False, "state": "waiting", "message": "Memperbarui pembacaan WAN dan pengikatan Wi-Fi ONT."}

    table_node = obj(table)
    if table_node is None or table_node.get("_object") is not True:
        raise GenieACSUnavailable("Tabel WAN PPPoE tidak tersedia pada ONT.")
    row_keys = [str(key) for key, value in table_node.items()
                if str(key).isdigit() and isinstance(value, dict) and value.get("_object") is True]
    def root(key):
        return table + "." + key
    rows = {root(key): {leaf: val(root(key) + "." + leaf) for leaf in
        ("Username", "ConnectionStatus", "ConnectionType", "Enable", "NATEnabled",
         "ExternalIPAddress", "X_ZTE-COM_VLANID", "X_ZTE-COM_VLANEnable", "X_ZTE-COM_ServiceList")}
        for key in row_keys}
    real_rows = {path: data for path, data in rows.items()
                 if (_parameter_node(device, path + ".Username") or {}).get("_writable") is True}
    exact = [path for path, data in real_rows.items() if str(data["Username"] or "").strip() == username]
    if len(exact) > 1:
        raise GenieACSUnavailable("Lebih dari satu WAN memakai username pelanggan; konfigurasi ditahan.")
    if exact:
        selected = exact[0]
    else:
        eligible = [path for path, data in real_rows.items()
            if str(data["X_ZTE-COM_VLANID"] or "").strip() == str(int(vlan))
            and str(data["ConnectionType"] or "").strip().casefold() in {"ip_routed", "routed"}
            and str(data["ConnectionStatus"] or "").strip().casefold() not in {"connected"}]
        if len(eligible) > 1:
            raise GenieACSUnavailable("Lebih dari satu WAN cocok dengan VLAN pelanggan; konfigurasi ditahan.")
        if eligible:
            selected = eligible[0]
        else:
            blank = [path for path, data in real_rows.items()
                     if not str(data["Username"] or "").strip()
                     and str(data["ConnectionStatus"] or "").strip().casefold() in {"", "unconfigured", "disconnected"}
                     and str(data["X_ZTE-COM_VLANID"] or "0").strip() in {"", "0"}]
            if len(blank) > 1:
                raise GenieACSUnavailable("Lebih dari satu WAN kosong; konfigurasi ditahan.")
            if blank:
                selected = blank[0]
            elif any(str(data["ConnectionStatus"] or "").casefold() == "connected" for data in real_rows.values()):
                raise GenieACSUnavailable("WAN lain masih aktif dan tidak cocok; konfigurasi ditahan.")
            elif table_node.get("_writable") is not True:
                raise GenieACSUnavailable("ONT tidak mendukung pembuatan WAN PPPoE.")
            else:
                if dry_run:
                    return {"ready": False, "state": "add", "message": "Satu WAN perlu dibuat."}
                _request(f"/devices/{quote(device_id, safe='')}/tasks?timeout=5000",
                         body={"name": "addObject", "objectName": table})
                return {"ready": False, "state": "waiting", "message": "Membuat satu WAN PPPoE untuk pelanggan."}

    selected_row = real_rows[selected]
    changes = []
    def set_if_needed(path, desired, kind):
        node = _parameter_node(device, path)
        if node is None:
            raise GenieACSUnavailable("Parameter WAN yang diperlukan tidak ditemukan: " + path.rsplit(".", 1)[-1])
        old = node.get("_value")
        same = flag(old) == desired if isinstance(desired, bool) else str(old or "").strip() == str(desired)
        if not same:
            if node.get("_writable") is not True:
                raise GenieACSUnavailable("Parameter WAN yang diperlukan tidak dapat diubah: " + path.rsplit(".", 1)[-1])
            changes.append([path, desired, kind])

    old_user = str(selected_row["Username"] or "").strip()
    set_if_needed(selected + ".Enable", True, "xsd:boolean")
    set_if_needed(selected + ".Username", username, "xsd:string")
    if old_user != username:
        password_node = _parameter_node(device, selected + ".Password")
        if not password_node or password_node.get("_writable") is not True:
            raise GenieACSUnavailable("Password WAN PPPoE tidak dapat diperbarui dengan aman.")
        changes.append([selected + ".Password", password, "xsd:string"])
    set_if_needed(selected + ".ConnectionType", "IP_Routed", "xsd:string")
    set_if_needed(selected + ".NATEnabled", True, "xsd:boolean")
    set_if_needed(selected + ".X_ZTE-COM_VLANEnable", True, "xsd:boolean")
    set_if_needed(selected + ".X_ZTE-COM_VLANID", int(vlan), "xsd:unsignedInt")
    dns_enabled = _parameter_node(device, selected + ".DNSEnabled")
    if dns_enabled is not None:
        set_if_needed(selected + ".DNSEnabled", True, "xsd:boolean")
    dns_node = _parameter_node(device, selected + ".DNSServers")
    if dns_node is None:
        raise GenieACSUnavailable("DNS WAN ONT tidak dapat dibaca.")
    if not str(dns_node.get("_value") or "").strip():
        dns = os.getenv("BESTWEB_PPPOE_DNS_SERVERS", "170.100.100.1,8.8.8.8").strip()
        if not dns:
            raise GenieACSUnavailable("DNS WAN pelanggan belum tersedia.")
        set_if_needed(selected + ".DNSServers", dns, "xsd:string")
    dhcp_node = _parameter_node(device, lanhost + ".DHCPServerEnable")
    if dhcp_node is None or not flag(dhcp_node.get("_value")):
        raise GenieACSUnavailable("DHCP LAN ONT belum aktif atau belum dapat diverifikasi.")
    service = str(selected_row["X_ZTE-COM_ServiceList"] or "").upper()
    if "INTERNET" not in service:
        # Do not remove the only TR-069 path while changing a shared WAN.
        if "TR069" in service:
            alternate = any(
                "WANIPConnection." in path and path.endswith(".X_ZTE-COM_ServiceList")
                and "TR069" in str(value or "").upper()
                and str(val(path.rsplit(".", 1)[0] + ".ConnectionStatus") or "").casefold() == "connected"
                for path, value in _walk_values(device)
            )
            if not alternate:
                raise GenieACSUnavailable("WAN manajemen terpisah belum terverifikasi; tipe layanan tidak diubah.")
        set_if_needed(selected + ".X_ZTE-COM_ServiceList", "INTERNET", "xsd:string")

    set_if_needed(default_path, selected, "xsd:string")
    bind_tree = obj(binding) or {}
    for index, bnode in bind_tree.items():
        if not str(index).isdigit() or not isinstance(bnode, dict):
            continue
        b_root = binding + "." + str(index)
        lans = str(val(b_root + ".LANInterface") or "")
        if not re.search(r"WLANConfiguration\.(?:1|5)(?:,|$)", lans):
            continue
        old_wan = str(val(b_root + ".WANInterface") or "").strip()
        if not old_wan or old_wan == selected:
            continue
        old_row = real_rows.get(old_wan)
        if not old_row or str(old_row["ConnectionStatus"] or "").casefold() == "connected" or "INTERNET" not in str(old_row["X_ZTE-COM_ServiceList"] or "").upper():
            raise GenieACSUnavailable("Pengikatan Wi-Fi menunjuk ke WAN lain yang belum aman untuk diganti.")
        set_if_needed(b_root + ".WANInterface", selected, "xsd:string")

    if changes:
        # Set WAN credentials and mode first. Some ZTE CPEs reject binding
        # changes in the same transaction that changes the WAN identity.
        wan_changes = [item for item in changes if item[0].startswith(selected + ".")]
        identity_fields = {selected + ".Username", selected + ".Password", selected + ".X_ZTE-COM_ServiceList"}
        identity_changes = [item for item in wan_changes if item[0] in identity_fields]
        default_changes = [item for item in changes if item[0] == default_path]
        binding_changes = [item for item in changes if item[0].startswith(binding + ".")]
        next_changes = identity_changes or wan_changes or default_changes or binding_changes[:1]
        if dry_run:
            return {"ready": False, "state": "configure", "message": "WAN perlu diselaraskan.", "changed_parameters": len(next_changes)}
        _request(f"/devices/{quote(device_id, safe='')}/tasks?timeout=5000",
                 body={"name": "setParameterValues", "parameterValues": next_changes})
        return {"ready": False, "state": "waiting",
                "message": "Konfigurasi WAN Internet dikirim ke ONT." if wan_changes else "Rute dan pengikatan Wi-Fi dikirim ke ONT."}

    ip = str(selected_row["ExternalIPAddress"] or "").strip()
    connected = str(selected_row["ConnectionStatus"] or "").casefold() == "connected" and ip not in {"", "-", "0.0.0.0"}
    return {"ready": connected, "state": "ready" if connected else "waiting",
            "message": "WAN Internet ONT terverifikasi." if connected else "Konfigurasi WAN tersimpan; menunggu sesi PPPoE."}
