#!/usr/bin/env python3
"""Manage JSRPC server and Flask proxy lifecycle.

Supports the legacy flag interface and the state-file subcommand interface.
Includes PID identity verification to avoid killing wrong processes.

Usage (legacy flag interface):
  python3 scripts/manage_services.py --service jsrpc --analysis analysis_result.json --output artifacts/jsrpc_status.json --action start --force
  python3 scripts/manage_services.py --service flask --analysis analysis_result.json --flask-file generated/flask_proxy.py --output artifacts/flask_status.json --action start --force
  python3 scripts/manage_services.py --service jsrpc --analysis analysis_result.json --output artifacts/jsrpc_status.json --action stop

Usage (state-file subcommand):
  python3 scripts/manage_services.py start --kind jsrpc --state artifacts/jsrpc_state.json
  python3 scripts/manage_services.py stop --state artifacts/jsrpc_state.json
"""
from __future__ import annotations

import argparse
import json
import os
import signal
import socket
import subprocess
import sys
import time
from pathlib import Path
from shutil import which

from common import dump_json, load_json

# Common JSRPC binary names and paths to search
JSRPC_SEARCH_NAMES = ["jsrpc", "jsrpc-mac", "jsrpc-linux", "mac_m_arm64", "mac_x64", "linux_amd64"]
JSRPC_SEARCH_DIRS = [
    Path.home() / "jsrpc",
    Path.home() / "jstest",
    Path.home() / "hacker" / "jstest",
    Path.home() / "tools" / "jsrpc",
    Path.home() / ".local" / "bin",
    Path("/usr/local/bin"),
    Path("/opt/jsrpc"),
]


def find_jsrpc_binary() -> str | None:
    """Auto-discover JSRPC binary from common locations and PATH."""
    # 1. Check PATH
    for name in JSRPC_SEARCH_NAMES:
        found = which(name)
        if found:
            return found
    # 2. Check common directories
    for search_dir in JSRPC_SEARCH_DIRS:
        if not search_dir.exists():
            continue
        for name in JSRPC_SEARCH_NAMES:
            candidate = search_dir / name
            if candidate.is_file() and os.access(candidate, os.X_OK):
                return str(candidate)
        for subdir in search_dir.iterdir():
            if subdir.is_dir():
                for name in JSRPC_SEARCH_NAMES:
                    candidate = subdir / name
                    if candidate.is_file() and os.access(candidate, os.X_OK):
                        return str(candidate)
    # 3. Check current directory and parent
    cwd = Path.cwd()
    for name in JSRPC_SEARCH_NAMES:
        candidate = cwd / name
        if candidate.is_file() and os.access(candidate, os.X_OK):
            return str(candidate)
        candidate = cwd.parent / name
        if candidate.is_file() and os.access(candidate, os.X_OK):
            return str(candidate)
    return None


def process_identity(pid: int) -> dict:
    """Get process identity info for PID verification."""
    result = {"pid": pid, "alive": False, "exe": None, "started": None, "command": None}
    try:
        os.kill(pid, 0)
        result["alive"] = True
    except OSError:
        return result
    proc = Path(f"/proc/{pid}")
    if proc.exists():
        try:
            result["exe"] = str((proc / "exe").resolve())
        except OSError:
            pass
        try:
            result["started"] = (proc / "stat").read_text().split()[21]
        except Exception:
            pass
        try:
            result["command"] = (proc / "cmdline").read_bytes().replace(b"\x00", b" ").decode(errors="replace").strip()
        except Exception:
            pass
    else:
        try:
            result["command"] = subprocess.run(
                ["ps", "-p", str(pid), "-o", "command="],
                text=True, capture_output=True, timeout=2
            ).stdout.strip() or None
            result["started"] = subprocess.run(
                ["ps", "-p", str(pid), "-o", "lstart="],
                text=True, capture_output=True, timeout=2
            ).stdout.strip() or None
        except Exception:
            pass
    return result


def is_port_in_use(port: int, host: str = "127.0.0.1") -> bool:
    for family in [socket.AF_INET, socket.AF_INET6]:
        try:
            with socket.socket(family, socket.SOCK_STREAM) as s:
                s.settimeout(1)
                h = "127.0.0.1" if family == socket.AF_INET else "::1"
                if s.connect_ex((h, port)) == 0:
                    return True
        except Exception:
            pass
    return False


def get_pid_on_port(port: int) -> int | None:
    try:
        result = subprocess.run(["lsof", "-i", f":{port}", "-t"], capture_output=True, text=True, timeout=5)
        for pid in result.stdout.strip().split("\n"):
            pid = pid.strip()
            if pid.isdigit():
                return int(pid)
    except Exception:
        pass
    return None


def find_available_port(start: int, host: str = "127.0.0.1", attempts: int = 30) -> int | None:
    """Find an available local port without touching an unrelated process."""
    for candidate in range(int(start), int(start) + attempts):
        if not is_port_in_use(candidate, host):
            return candidate
    return None


def kill_process(pid: int) -> bool:
    try:
        os.kill(pid, signal.SIGTERM)
        time.sleep(1)
        try:
            os.kill(pid, 0)
            os.kill(pid, signal.SIGKILL)
        except ProcessLookupError:
            pass
        return True
    except ProcessLookupError:
        return True
    except Exception:
        return False


def check_health(host: str, port: int) -> bool:
    try:
        import urllib.request
        req = urllib.request.urlopen(f"http://{host}:{port}/healthz", timeout=3)
        return req.status == 200
    except Exception:
        return False


# === Legacy flag interface ===

def legacy_jsrpc_start(binary_path: str, port: int) -> dict:
    proc = subprocess.Popen([binary_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
    for _ in range(10):
        time.sleep(0.5)
        if is_port_in_use(port):
            identity = process_identity(proc.pid)
            return {"status": "started", "pid": proc.pid, "binary_path": str(Path(binary_path).resolve()), "port": port,
                    "started": identity.get("started"), "observed_command": identity.get("command"),
                    "stop_hint": "使用同一状态文件执行 manage_services.py --action stop"}
    return {"status": "start_failed", "pid": proc.pid, "binary_path": binary_path, "port": port}


def legacy_flask_start(flask_file: str, host: str, port: int, route: str = "/autodecoder") -> dict:
    requested_port = int(port)
    actual_port = requested_port
    if is_port_in_use(actual_port, host):
        actual_port = find_available_port(actual_port + 1, host)
        if actual_port is None:
            existing_pid = get_pid_on_port(requested_port)
            return {"status": "port_occupied", "port": requested_port, "existing_pid": existing_pid, "hint": f"端口 {requested_port} 已被占用，且没有找到可用备用端口"}
    if not os.path.isfile(flask_file):
        return {"status": "file_not_found", "flask_file": flask_file, "hint": "Flask 代理文件不存在，先运行代码生成"}
    log_file = Path(flask_file).parent / "flask_proxy.log"
    environment = os.environ.copy()
    environment["JSRA_FLASK_PORT"] = str(actual_port)
    with open(log_file, "w") as lf:
        proc = subprocess.Popen([sys.executable, flask_file], stdout=lf, stderr=subprocess.STDOUT, start_new_session=True, env=environment)
    for _ in range(10):
        time.sleep(0.5)
        if is_port_in_use(actual_port, host):
            healthy = check_health(host, actual_port)
            identity = process_identity(proc.pid)
            return {
                "status": "started", "pid": proc.pid, "host": host, "port": actual_port,
                "requested_port": requested_port, "port_fallback": actual_port != requested_port,
                "flask_file": str(Path(flask_file).resolve()),
                "started": identity.get("started"), "observed_command": identity.get("command"),
                "url": f"http://{host}:{actual_port}{route}", "healthz": f"http://{host}:{actual_port}/healthz",
                "encode_url": f"http://{host}:{actual_port}/encode", "decode_url": f"http://{host}:{actual_port}/decode",
                "healthy": healthy, "log_file": str(log_file),
                "stop_hint": "使用同一状态文件执行 manage_services.py --action stop"
            }
    return {"status": "start_failed", "pid": proc.pid, "port": actual_port, "requested_port": requested_port,
            "flask_file": str(Path(flask_file).resolve()), "log_file": str(log_file)}


def legacy_status(path: str) -> dict:
    """Load a previously written legacy status file without guessing a PID."""
    try:
        return load_json(Path(path), {})
    except (OSError, ValueError, TypeError):
        return {}


def managed_pid_matches(status: dict, kind: str) -> bool:
    """Verify that a legacy status PID still belongs to this service.

    The legacy interface predates state files, so only a recorded PID and a
    recorded executable/script identity are accepted.  A port occupant alone
    is never sufficient evidence for a kill operation.
    """
    pid = status.get("pid")
    if not pid:
        return False
    try:
        identity = process_identity(int(pid))
    except (TypeError, ValueError):
        return False
    if not identity.get("alive"):
        return False
    expected = str(status.get("flask_file" if kind == "flask" else "binary_path", ""))
    command = str(identity.get("command") or "")
    if not expected or not command:
        return False
    if status.get("started") and identity.get("started") and status["started"] != identity["started"]:
        return False
    return Path(expected).name in command or expected in command


def stop_legacy_service(kind: str, status_path: str, configured_port: int) -> dict:
    """Stop only a process recorded by this skill's own status artifact."""
    status = legacy_status(status_path)
    if not status:
        return {"status": "not_running", "port": configured_port, "hint": "没有可验证的服务状态文件，未尝试按端口杀进程"}
    if not managed_pid_matches(status, kind):
        return {"status": "identity_mismatch", "pid": status.get("pid"), "port": status.get("port", configured_port),
                "hint": "状态文件中的进程身份无法验证，未执行停止操作"}
    pid = int(status["pid"])
    if kill_process(pid):
        return {"status": "stopped", "pid": pid, "port": status.get("port", configured_port)}
    return {"status": "stop_failed", "pid": pid, "port": status.get("port", configured_port)}


def legacy_mode(args: argparse.Namespace) -> dict:
    """Legacy flag-based interface."""
    analysis = load_json(Path(args.analysis))
    if args.service == "jsrpc":
        config = analysis.get("jsrpc_server", {})
        port = config.get("port", 12080)
        if args.action == "stop":
            return stop_legacy_service("jsrpc", args.output, port)
        elif args.action == "status":
            if not is_port_in_use(port):
                return {"status": "not_running", "port": port}
            pid = get_pid_on_port(port)
            return {"status": "already_running", "pid": pid, "port": port,
                    "stop_command": f"python3 scripts/manage_services.py --service jsrpc --analysis {args.analysis} --output {args.output} --action stop" if pid else None}
        else:  # start
            if is_port_in_use(port):
                pid = get_pid_on_port(port)
                status = legacy_status(args.output)
                if status.get("status") in {"started", "already_running"} and managed_pid_matches(status, "jsrpc"):
                    return {"status": "already_running", "pid": status.get("pid", pid), "port": port,
                            "stop_command": f"python3 scripts/manage_services.py --service jsrpc --analysis {args.analysis} --output {args.output} --action stop"}
                return {"status": "port_occupied", "pid": pid, "port": port,
                        "hint": f"端口 {port} 已被其他进程占用，未执行强制终止；请释放端口或更换 JSRPC 端口"}
            binary_path = config.get("binary_path", "")
            if binary_path == "auto" or not binary_path:
                binary_path = find_jsrpc_binary()
            if binary_path and os.path.isfile(binary_path):
                return legacy_jsrpc_start(binary_path, port)
            return {"status": "not_found", "port": port, "hint": "请在 analysis_result.json 的 jsrpc_server.binary_path 中提供 JSRPC 服务器二进制路径，或手动启动后重试"}
    else:  # flask
        config = analysis.get("flask_server", analysis.get("flask", {}))
        host = config.get("listen_host", config.get("host", "127.0.0.1"))
        port = config.get("listen_port", config.get("port", 5000))
        if args.action == "stop":
            return stop_legacy_service("flask", args.output, port)
        elif args.action == "status":
            if not is_port_in_use(port, host):
                return {"status": "not_running", "port": port}
            pid = get_pid_on_port(port)
            healthy = check_health(host, port)
            flask_config = analysis.get("flask", {})
            route = flask_config.get("route", "/autodecoder")
            return {"status": "running", "pid": pid, "port": port, "healthy": healthy, "url": f"http://{host}:{port}{route}",
                    "stop_command": f"python3 scripts/manage_services.py --service flask --analysis {args.analysis} --output {args.output} --action stop" if pid else None}
        else:  # start
            flask_config = analysis.get("flask", {})
            route = flask_config.get("route", "/autodecoder")
            # The legacy Flask start deliberately selects a free fallback port.  Do
            # not pre-emptively kill an arbitrary occupant here; --force is
            # retained for CLI compatibility but never authorizes that kill.
            return legacy_flask_start(args.flask_file, host, port, route)
    return {"status": "error", "hint": "unknown action"}


# === State-file subcommand interface ===

def start_process(command: list[str], state_path: Path, kind: str) -> int:
    environment = None
    requested_port = None
    actual_port = None
    if kind == "flask":
        requested_port = int(os.environ.get("JSRA_FLASK_PORT", "5000"))
        actual_port = find_available_port(requested_port)
        if actual_port is None:
            print(json.dumps({"status": "port_occupied", "requested_port": requested_port}, ensure_ascii=False))
            return 2
        environment = os.environ.copy()
        environment["JSRA_FLASK_PORT"] = str(actual_port)
    process = subprocess.Popen(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True, env=environment)
    time.sleep(.3)
    identity = process_identity(process.pid)
    dump_json(state_path, {
        "kind": kind, "command": command, "pid": process.pid,
        "exe": identity.get("exe"), "started": identity.get("started"),
        "observed_command": identity.get("command"), "created_at": time.time(),
        "requested_port": requested_port, "port": actual_port,
        "port_fallback": actual_port is not None and actual_port != requested_port
    })
    print(json.dumps({"status": "started", "kind": kind, "pid": process.pid, "state": str(state_path), "port": actual_port}, ensure_ascii=False))
    return 0


def stop_process(state_path: Path, kill_unknown: bool) -> int:
    state = load_json(state_path)
    identity = process_identity(int(state["pid"]))
    if not identity["alive"]:
        state_path.unlink(missing_ok=True)
        print("[OK] process already stopped")
        return 0
    expected = (state.get("exe"), state.get("started"), state.get("observed_command"))
    actual = (identity.get("exe"), identity.get("started"), identity.get("command"))
    verifiable = any(value is not None for value in expected)
    if (not verifiable or expected != actual) and not kill_unknown:
        print(f"[ERROR] process identity cannot be verified; expected={expected}, actual={actual}")
        return 3
    os.kill(int(state["pid"]), signal.SIGTERM)
    state_path.unlink(missing_ok=True)
    print(f"[OK] stopped pid {state['pid']}")
    return 0


def main() -> int:
    # Detect the legacy flag interface or the state-file subcommand interface.
    if len(sys.argv) > 1 and sys.argv[1] in ("start", "stop", "status"):
        # State-file subcommand mode
        parser = argparse.ArgumentParser(description="Safe service manager for JSRA.")
        sub = parser.add_subparsers(dest="command", required=True)
        start = sub.add_parser("start")
        start.add_argument("--kind", choices=["jsrpc", "flask"], required=True)
        start.add_argument("--state", required=True)
        start.add_argument("--jsrpc-binary")
        start.add_argument("--flask-script")
        stop = sub.add_parser("stop")
        stop.add_argument("--state", required=True)
        stop.add_argument("--kill-unknown", action="store_true")
        status = sub.add_parser("status")
        status.add_argument("--state", required=True)
        args = parser.parse_args()
        state = Path(args.state)

        if args.command == "start":
            if args.kind == "jsrpc":
                binary_path = args.jsrpc_binary
                if not binary_path:
                    binary_path = find_jsrpc_binary()
                    if not binary_path:
                        parser.error("--jsrpc-binary is required; auto-discovery failed.")
                    print(f"[INFO] Auto-discovered JSRPC binary: {binary_path}")
                binary = Path(binary_path).expanduser().resolve()
                if not binary.is_file() or not os.access(binary, os.X_OK):
                    parser.error("invalid executable: " + str(binary))
                return start_process([str(binary)], state, "jsrpc")
            if not args.flask_script:
                parser.error("--flask-script is required")
            return start_process([sys.executable, str(Path(args.flask_script).resolve())], state, "flask")
        if args.command == "stop":
            return stop_process(state, args.kill_unknown)
        info = load_json(state, {})
        print(json.dumps({
            "state": info,
            "process": process_identity(int(info["pid"])) if info.get("pid") else None
        }, ensure_ascii=False, indent=2))
        return 0
    else:
        # Legacy flag-based mode
        parser = argparse.ArgumentParser()
        parser.add_argument("--service", required=True, choices=["jsrpc", "flask"])
        parser.add_argument("--analysis", required=True)
        parser.add_argument("--output", required=True)
        parser.add_argument("--flask-file", default="")
        parser.add_argument("--action", choices=["start", "stop", "status"], default="start")
        parser.add_argument("--force", action="store_true")
        args = parser.parse_args()
        result = legacy_mode(args)
        dump_json(Path(args.output), result)
        print(json.dumps(result, ensure_ascii=False))
        return 0 if result.get("status") in ("already_running", "started", "running", "stopped", "not_running") else 1


if __name__ == "__main__":
    raise SystemExit(main())