#!/usr/bin/env python3
# ==============================================================================
# HomeLab All-in-One 专属中控台后端服务 (Port 3002)
# 提供 Apple/Shadcn 风格单页应用与全屋设备实时遥测 API (/api/telemetry, /api/action)
# ==============================================================================
import json
import os
import re
import socket
import subprocess
import threading
import time
import urllib.request
import mimetypes
from concurrent.futures import ThreadPoolExecutor
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path

PORT = int(os.environ.get("PORT", "3004"))
BASE_DIR = Path(__file__).resolve().parent
DIST_DIR = BASE_DIR / "dist"
INDEX_FILE = BASE_DIR / "index.html"

_cache = {"data": None, "ts": 0.0}
_cache_lock = threading.Lock()


def run_cmd(cmd: str, timeout: float = 2.0) -> str:
    try:
        env = os.environ.copy()
        env["PATH"] = "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
        res = subprocess.run(
            cmd, shell=True, capture_output=True, text=True, timeout=timeout, env=env
        )
        return res.stdout.strip()
    except Exception:
        return ""


def check_tcp(host: str, port: int, timeout: float = 0.8) -> tuple[bool, int]:
    t0 = time.monotonic()
    try:
        with socket.create_connection((host, port), timeout=timeout):
            ms = int((time.monotonic() - t0) * 1000)
            return True, max(1, ms)
    except Exception:
        return False, -1


def get_mac_mini_stats() -> dict:
    # 1. CPU Load & Core count
    load_str = run_cmd("sysctl -n vm.loadavg")
    # Format: "{ 1.42 1.18 1.05 }"
    loads = [float(x) for x in re.findall(r"[0-9]+\.[0-9]+", load_str)] or [0.0, 0.0, 0.0]
    cores = int(run_cmd("sysctl -n hw.ncpu") or "12")
    cpu_pct = min(100, round((loads[0] / max(1, cores)) * 100, 1))

    # 2. Memory (24GB total)
    total_bytes = int(run_cmd("sysctl -n hw.memsize") or str(24 * 1024**3))
    total_gb = round(total_bytes / (1024**3), 1)
    vm_out = run_cmd("vm_stat")
    page_size = 16384
    m_ps = re.search(r"page size of (\d+) bytes", vm_out)
    if m_ps:
        page_size = int(m_ps.group(1))
    pages = {}
    for line in vm_out.splitlines():
        if ":" in line:
            k, v = line.split(":", 1)
            v_clean = re.sub(r"[^0-9]", "", v)
            if v_clean:
                pages[k.strip()] = int(v_clean)
    used_pages = (
        pages.get("Pages active", 0)
        + pages.get("Pages wired down", 0)
        + pages.get("Pages occupied by compressor", 0)
    )
    used_gb = round((used_pages * page_size) / (1024**3), 1)
    mem_pct = min(100, round((used_gb / max(1.0, total_gb)) * 100, 1))

    # 3. Disk (/System/Volumes/Data or /)
    df_out = run_cmd("df -k /System/Volumes/Data || df -k /")
    disk_total_gb, disk_used_gb, disk_pct = 512.0, 40.0, 8.0
    lines = df_out.splitlines()
    if len(lines) >= 2:
        parts = lines[-1].split()
        if len(parts) >= 5:
            total_k = int(parts[1])
            avail_k = int(parts[3])
            used_k = total_k - avail_k
            disk_total_gb = round(total_k / (1024**2), 1)
            disk_used_gb = round(used_k / (1024**2), 1)
            disk_pct = round((used_k / max(1, total_k)) * 100, 1)

    # 4. Uptime
    boot_out = run_cmd("sysctl -n kern.boottime")
    m_sec = re.search(r"sec = (\d+)", boot_out)
    uptime_str = "运行中"
    if m_sec:
        up_sec = max(0, int(time.time()) - int(m_sec.group(1)))
        days = up_sec // 86400
        hours = (up_sec % 86400) // 3600
        mins = (up_sec % 3600) // 60
        uptime_str = f"{days}天 {hours}小时" if days > 0 else f"{hours}小时 {mins}分"

    # 5. Docker Containers
    containers = []
    docker_out = run_cmd("docker ps --format '{{.Names}}|{{.Status}}|{{.Image}}'")
    for line in docker_out.splitlines():
        if "|" in line:
            name, status, img = line.split("|", 2)
            containers.append({"name": name, "status": status, "image": img})

    # 6. AGY tmux session
    tmux_out = run_cmd("tmux list-sessions 2>/dev/null")
    agy_running = "agy:" in tmux_out

    return {
        "chip": "Apple M6 (12核)",
        "ip": "192.168.31.164",
        "tailscale_ip": "100.108.205.40",
        "cpu_pct": cpu_pct,
        "load_1m": loads[0],
        "cores": cores,
        "mem_used_gb": used_gb,
        "mem_total_gb": total_gb,
        "mem_pct": mem_pct,
        "disk_used_gb": disk_used_gb,
        "disk_total_gb": disk_total_gb,
        "disk_pct": disk_pct,
        "uptime": uptime_str,
        "containers": containers,
        "agy_tmux": agy_running,
    }


def get_nas_stats() -> dict:
    nas_path = Path("/Users/ixvii0iv/nas/个人空间")
    mounted = nas_path.exists() and os.path.ismount("/Users/ixvii0iv/nas/个人空间")
    total_tb, used_tb, free_tb, pct = 20.0, 2.9, 17.1, 15.0
    if mounted:
        df_out = run_cmd("df -k /Users/ixvii0iv/nas/个人空间")
        lines = df_out.splitlines()
        if len(lines) >= 2:
            parts = lines[-1].split()
            if len(parts) >= 5:
                total_k = int(parts[1])
                avail_k = int(parts[3])
                used_k = total_k - avail_k
                total_tb = round(total_k / (1024**3), 2)
                free_tb = round(avail_k / (1024**3), 2)
                used_tb = round(used_k / (1024**3), 2)
                pct = round((used_k / max(1, total_k)) * 100, 1)

    latest_backup = "已就绪"
    backup_count = 1
    b_log = Path("/Users/ixvii0iv/homelab/logs/nas-backup.log")
    if b_log.exists():
        lines = [l for l in b_log.read_text(errors="ignore").splitlines() if "homelab_backup_" in l]
        backup_count = len(lines)
        if lines:
            last_line = lines[-1]
            m = re.search(r"homelab_backup_(\d{4})(\d{2})(\d{2})_(\d{2})(\d{2})", last_line)
            if m:
                latest_backup = f"{m.group(2)}-{m.group(3)} {m.group(4)}:{m.group(5)}"

    return {
        "name": "极空间 Z4",
        "ip": "192.168.31.185",
        "online": mounted,
        "latency_ms": 1 if mounted else -1,
        "mounted": mounted,
        "total_tb": total_tb,
        "used_tb": used_tb,
        "free_tb": free_tb,
        "pct": pct,
        "latest_backup": latest_backup,
        "backup_count": backup_count,
    }


def get_network_and_edge_stats() -> dict:
    # 1. Home Public IP from DDNS log
    home_ip = "124.90.142.21"
    ddns_log = Path("/Users/ixvii0iv/homelab/logs/cf-ddns.log")
    if ddns_log.exists():
        try:
            last_lines = ddns_log.read_text(errors="ignore").splitlines()[-10:]
            for line in reversed(last_lines):
                m = re.search(r"公网 IP:\s*([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)", line)
                if m:
                    home_ip = m.group(1)
                    break
        except Exception:
            pass

    # 2. Query Xiaomi Router Mihomo API (192.168.31.1:9999) for AI group & SG node delay
    ai_group = "狮城节点"
    sg_node = "coco-sea1-reality-sony"
    sg_delay_ms = -1
    router_online, router_ms = check_tcp("192.168.31.1", 9999)
    if router_online:
        try:
            with urllib.request.urlopen("http://192.168.31.1:9999/proxies", timeout=1.2) as r:
                pdata = json.loads(r.read().decode()).get("proxies", {})
                ai_group = pdata.get("Ai平台", {}).get("now", "狮城节点")
                sg_group = pdata.get("狮城节点", {})
                sg_node = sg_group.get("now", "coco-sea1-reality-sony")
                hist = pdata.get(sg_node, {}).get("history", [])
                if hist:
                    sg_delay_ms = hist[-1].get("delay", -1)
        except Exception:
            pass

    # 3. Check Azure Cloud Edge (104.43.105.243:443)
    azure_online, azure_ms = check_tcp("104.43.105.243", 443, timeout=1.2)

    return {
        "home_wan_ip": home_ip,
        "router_ip": "192.168.31.1",
        "router_online": router_online,
        "router_ms": router_ms,
        "ai_policy": f"Ai平台 → {ai_group}",
        "sg_node": sg_node,
        "sg_egress_ip": "104.43.105.243",
        "sg_delay_ms": sg_delay_ms,
        "azure_tailscale_ip": "100.115.204.51",
        "azure_online": azure_online,
        "azure_ms": azure_ms,
    }


def collect_telemetry() -> dict:
    now = time.time()
    with _cache_lock:
        if _cache["data"] and (now - _cache["ts"] < 2.0):
            return _cache["data"]

    with ThreadPoolExecutor(max_workers=4) as pool:
        f_mini = pool.submit(get_mac_mini_stats)
        f_nas = pool.submit(get_nas_stats)
        f_net = pool.submit(get_network_and_edge_stats)
        f_agy = pool.submit(check_tcp, "127.0.0.1", 7681)
        f_vw = pool.submit(check_tcp, "127.0.0.1", 8222)

        mini = f_mini.result()
        nas = f_nas.result()
        net = f_net.result()
        agy_ok, _ = f_agy.result()
        vw_ok, _ = f_vw.result()

    data = {
        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
        "mini": mini,
        "nas": nas,
        "network": net,
        "services": {
            "agy": agy_ok,
            "vaultwarden": vw_ok,
            "nas": nas["online"],
            "clash": net["router_online"],
            "router": net["router_online"],
            "uptime": net["azure_online"],
        },
    }
    with _cache_lock:
        _cache["data"] = data
        _cache["ts"] = now
    return data


class PortalHandler(BaseHTTPRequestHandler):
    def log_message(self, fmt, *args):
        pass

    def _send_json(self, obj: dict, status: int = 200):
        body = json.dumps(obj, ensure_ascii=False).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Cache-Control", "no-store")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        if self.path.startswith("/api/telemetry"):
            self._send_json(collect_telemetry())
            return

        # Serve static assets from Vite build output (dist/) if available
        clean_path = self.path.split("?", 1)[0].lstrip("/")
        if clean_path and DIST_DIR.exists():
            asset_file = (DIST_DIR / clean_path).resolve()
            if str(asset_file).startswith(str(DIST_DIR.resolve())) and asset_file.is_file():
                body = asset_file.read_bytes()
                mime, _ = mimetypes.guess_type(str(asset_file))
                self.send_response(200)
                self.send_header("Content-Type", mime or "application/octet-stream")
                self.send_header("Cache-Control", "public, max-age=86400")
                self.send_header("Content-Length", str(len(body)))
                self.end_headers()
                self.wfile.write(body)
                return

        # Serve SPA index.html from dist/index.html (React+Vite build) or fallback index.html
        spa_index = (DIST_DIR / "index.html") if (DIST_DIR / "index.html").exists() else INDEX_FILE
        if spa_index.exists():
            body = spa_index.read_bytes()
            self.send_response(200)
            self.send_header("Content-Type", "text/html; charset=utf-8")
            self.send_header("Cache-Control", "no-cache")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)
        else:
            self.send_error(404, "index.html not found")

    def do_POST(self):
        if self.path == "/api/action/backup_nas":
            out = run_cmd("/Users/ixvii0iv/homelab/scripts/backup-to-nas.sh", timeout=15.0)
            with _cache_lock:
                _cache["ts"] = 0.0
            self._send_json({"ok": True, "message": out or "备份已完成"})
            return
        if self.path == "/api/action/mount_nas":
            out = run_cmd("/Users/ixvii0iv/homelab/scripts/mount-zspace.sh", timeout=10.0)
            with _cache_lock:
                _cache["ts"] = 0.0
            self._send_json({"ok": True, "message": out or "极空间挂载巡检完成"})
            return
        if self.path == "/api/action/refresh_ddns":
            out = run_cmd("/Users/ixvii0iv/homelab/scripts/cloudflare-ddns.sh", timeout=10.0)
            with _cache_lock:
                _cache["ts"] = 0.0
            self._send_json({"ok": True, "message": out or "Cloudflare DDNS 已刷新"})
            return
        self._send_json({"ok": False, "message": "Unknown action"}, status=404)


if __name__ == "__main__":
    # 同时监听主入口 3002 (https://nav.961504.xyz) 与预览端口 3004
    srv_preview = ThreadingHTTPServer(("0.0.0.0", 3004), PortalHandler)
    threading.Thread(target=srv_preview.serve_forever, daemon=True).start()
    server = ThreadingHTTPServer(("0.0.0.0", 3002), PortalHandler)
    print("[HomeLab Portal V3] Listening on http://0.0.0.0:3002 and :3004")
    server.serve_forever()