"""Managed process lifecycle helpers for the web API runtime."""

from __future__ import annotations

import os
import subprocess
import sys
import threading
import time
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from typing import Any, Callable, Mapping

import requests
from loguru import logger

from apps.web_api.runtime.engine_registry import ENGINE_RUNTIME_REGISTRY
from apps.web_api.runtime.log_stream import read_process_output, write_log_to_file
from apps.web_api.runtime.process_registry import PROCESS_RUNTIME_REGISTRY, ProcessRuntimeRegistry

HEALTHCHECK_PATH = "/_stcore/health"
HEALTHCHECK_PROXIES = {"http": None, "https": None}
HEALTHCHECK_GRACE_SECONDS = 15


def get_default_streamlit_scripts() -> dict[str, str]:
    """Resolve the current Streamlit script table from the runtime engine registry."""

    return ENGINE_RUNTIME_REGISTRY.streamlit_scripts()


class _StreamlitScriptsCompatibilityView(Mapping[str, str]):
    """Live compatibility view over the current engine-registry script mapping."""

    def __getitem__(self, key: str) -> str:
        return get_default_streamlit_scripts()[key]

    def __iter__(self):
        return iter(get_default_streamlit_scripts())

    def __len__(self) -> int:
        return len(get_default_streamlit_scripts())

    def __repr__(self) -> str:
        return repr(get_default_streamlit_scripts())


# Compatibility export: resolves the current mapping at access time.
STREAMLIT_SCRIPTS: Mapping[str, str] = _StreamlitScriptsCompatibilityView()


@dataclass(frozen=True)
class ProcessCleanupPort:
    """Runtime callbacks required to clean up managed processes."""

    stop_forum_engine: Callable[[], Any]
    mark_system_stopped: Callable[[], None]


def log_shutdown_step(message: str) -> None:
    logger.info(f"[Shutdown] {message}")


def build_healthcheck_url(port: int) -> str:
    return f"http://127.0.0.1:{port}{HEALTHCHECK_PATH}"


class ProcessManager:
    """Object-oriented wrapper around managed process state and operations."""

    def __init__(
        self,
        *,
        process_registry: ProcessRuntimeRegistry | None = None,
        streamlit_scripts: Mapping[str, str] | None = None,
        write_log: Callable[[Path, str, str], None] = write_log_to_file,
        process_output_reader: Callable[..., None] = read_process_output,
        requests_get: Callable[..., Any] = requests.get,
        cwd_getter: Callable[[], str] = os.getcwd,
    ) -> None:
        self._process_registry = process_registry
        resolved_streamlit_scripts = (
            streamlit_scripts if streamlit_scripts is not None else get_default_streamlit_scripts()
        )
        self._streamlit_scripts = dict(resolved_streamlit_scripts)
        self._write_log = write_log
        self._process_output_reader = process_output_reader
        self._requests_get = requests_get
        self._cwd_getter = cwd_getter

    @property
    def process_registry(self) -> ProcessRuntimeRegistry:
        return self._process_registry if self._process_registry is not None else PROCESS_RUNTIME_REGISTRY

    @property
    def streamlit_scripts(self) -> Mapping[str, str]:
        return self._streamlit_scripts

    def describe_running_children(self) -> list[str]:
        running: list[str] = []
        for name, info in self.process_registry.items():
            proc = self.process_registry.get_process(name)
            if proc is not None and proc.poll() is None:
                port_desc = f", port={info.get('port')}" if info.get("port") else ""
                running.append(f"{name}(pid={proc.pid}{port_desc})")
        return running

    def healthcheck_grace_active(self, app_name: str) -> bool:
        if not self.process_registry.contains(app_name):
            return False
        started_at = self.process_registry.get_healthcheck_started_at(app_name)
        if not started_at:
            return False
        return (time.time() - started_at) < HEALTHCHECK_GRACE_SECONDS

    def log_healthcheck_failure(self, app_name: str, exc: Exception) -> None:
        if self.healthcheck_grace_active(app_name):
            logger.debug(f"Skipping transient healthcheck failure while {app_name} is starting: {exc}")
            return
        logger.warning(f"{app_name} healthcheck failed: {exc}")

    def start_streamlit_app(
        self,
        app_name: str,
        script_path: str,
        port: int,
        *,
        log_dir: Path,
        emit_output: Callable[[str, dict], None],
    ) -> tuple[bool, str]:
        try:
            if self.process_registry.get_process(app_name) is not None:
                return False, "application is already running"

            if not os.path.exists(script_path):
                return False, f"file does not exist: {script_path}"

            log_file_path = log_dir / f"{app_name}.log"
            if log_file_path.exists():
                log_file_path.unlink()

            start_msg = f"[{datetime.now().strftime('%H:%M:%S')}] starting {app_name} app..."
            self._write_log(log_dir, app_name, start_msg)

            cmd = [
                sys.executable,
                "-m",
                "streamlit",
                "run",
                script_path,
                "--server.port",
                str(port),
                "--server.headless",
                "true",
                "--browser.gatherUsageStats",
                "false",
                "--logger.level",
                "info",
                "--server.enableCORS",
                "false",
            ]

            env = os.environ.copy()
            env.update(
                {
                    "PYTHONIOENCODING": "utf-8",
                    "PYTHONUTF8": "1",
                    "LANG": "en_US.UTF-8",
                    "LC_ALL": "en_US.UTF-8",
                    "PYTHONUNBUFFERED": "1",
                    "STREAMLIT_BROWSER_GATHER_USAGE_STATS": "false",
                }
            )

            creationflags = 0
            if sys.platform == "win32":
                creationflags = getattr(subprocess, "CREATE_NO_WINDOW", 0)

            process = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                bufsize=0,
                universal_newlines=False,
                cwd=self._cwd_getter(),
                env=env,
                encoding=None,
                creationflags=creationflags,
            )

            self.process_registry.set_process(app_name, process)
            self.process_registry.set_status(app_name, "starting")
            self.process_registry.set_output(app_name, [])
            self.process_registry.set_healthcheck_started_at(app_name, time.time())

            output_thread = threading.Thread(
                target=self._process_output_reader,
                kwargs={
                    "process": process,
                    "log_dir": log_dir,
                    "emit_output": emit_output,
                    "app_name": app_name,
                },
                daemon=True,
            )
            output_thread.start()

            return True, f"{app_name} app is starting..."
        except Exception as exc:
            error_msg = f"start failed: {exc}"
            self._write_log(
                log_dir,
                app_name,
                f"[{datetime.now().strftime('%H:%M:%S')}] {error_msg}",
            )
            return False, error_msg

    def stop_streamlit_app(self, app_name: str) -> tuple[bool, str]:
        try:
            process = self.process_registry.get_process(app_name)
            if process is None:
                log_shutdown_step(f"{app_name} is not running; skip stop")
                return False, "application is not running"

            try:
                pid = process.pid
            except Exception:
                pid = "unknown"

            log_shutdown_step(f"Stopping {app_name} (pid={pid})")
            process.terminate()

            try:
                process.wait(timeout=5)
                log_shutdown_step(f"{app_name} exited cleanly, returncode={process.returncode}")
            except subprocess.TimeoutExpired:
                log_shutdown_step(f"{app_name} terminate timed out; forcing kill (pid={pid})")
                process.kill()
                process.wait()
                log_shutdown_step(f"{app_name} force-killed, returncode={process.returncode}")

            self.process_registry.reset_runtime(app_name, status="stopped")
            return True, f"{app_name} app stopped"
        except Exception as exc:
            log_shutdown_step(f"{app_name} stop failed: {exc}")
            return False, f"stop failed: {exc}"

    def check_app_status(self) -> None:
        for app_name, info in self.process_registry.items():
            port = info.get("port")
            if app_name == "forum":
                continue

            healthy = False
            if port:
                try:
                    response = self._requests_get(
                        build_healthcheck_url(port),
                        timeout=2,
                        proxies=HEALTHCHECK_PROXIES,
                    )
                    healthy = response.status_code == 200
                except Exception as exc:
                    self.log_healthcheck_failure(app_name, exc)

            proc = info.get("process")
            if healthy:
                self.process_registry.set_status(app_name, "running")
                if proc is not None and proc.poll() is not None:
                    self.process_registry.clear_process(app_name)
                    self.process_registry.set_healthcheck_started_at(app_name, None)
                continue

            if proc is not None:
                if proc.poll() is None:
                    self.process_registry.set_status(app_name, "starting")
                else:
                    self.process_registry.reset_runtime(app_name, status="stopped")
            else:
                self.process_registry.set_status(app_name, "stopped")

    def wait_for_app_startup(self, app_name: str, max_wait_time: int = 90) -> tuple[bool, str]:
        start_time = time.time()
        while time.time() - start_time < max_wait_time:
            info = self.process_registry.get_entry(app_name)
            if info["process"] is None:
                return False, "process stopped"

            if info["process"].poll() is not None:
                return False, "process startup failed"

            try:
                response = self._requests_get(
                    build_healthcheck_url(info["port"]),
                    timeout=2,
                    proxies=HEALTHCHECK_PROXIES,
                )
                if response.status_code == 200:
                    self.process_registry.set_status(app_name, "running")
                    return True, "startup succeeded"
            except Exception as exc:
                self.log_healthcheck_failure(app_name, exc)

            time.sleep(1)

        return False, "startup timed out"

    def cleanup_processes(
        self,
        *,
        cleanup: ProcessCleanupPort,
    ) -> None:
        log_shutdown_step("Starting serial process cleanup")
        for app_name in self._streamlit_scripts:
            self.stop_streamlit_app(app_name)

        self.process_registry.set_status("forum", "stopped")
        try:
            cleanup.stop_forum_engine()
        except Exception:
            logger.exception("Failed to stop ForumEngine during cleanup")
        log_shutdown_step("Serial process cleanup completed")
        cleanup.mark_system_stopped()

    def cleanup_processes_concurrent(
        self,
        *,
        cleanup: ProcessCleanupPort,
        timeout: float = 6.0,
    ) -> None:
        log_shutdown_step(f"Starting concurrent process cleanup (timeout={timeout}s)")
        running_before = self.describe_running_children()
        if running_before:
            log_shutdown_step("Tracked child processes before cleanup: " + ", ".join(running_before))
        else:
            log_shutdown_step("No tracked child processes detected before cleanup")

        threads: list[threading.Thread] = []

        for app_name in self._streamlit_scripts:
            thread = threading.Thread(target=self.stop_streamlit_app, args=(app_name,), daemon=True)
            threads.append(thread)
            thread.start()

        forum_thread = threading.Thread(target=cleanup.stop_forum_engine, daemon=True)
        threads.append(forum_thread)
        forum_thread.start()

        end_time = time.time() + timeout
        for thread in threads:
            remaining = end_time - time.time()
            if remaining <= 0:
                break
            thread.join(timeout=remaining)

        for app_name in self._streamlit_scripts:
            proc = self.process_registry.get_process(app_name)
            if proc is not None and proc.poll() is None:
                try:
                    log_shutdown_step(f"{app_name} still alive after cleanup; terminating again (pid={proc.pid})")
                    proc.terminate()
                    proc.wait(timeout=1)
                except Exception:
                    try:
                        log_shutdown_step(f"{app_name} terminate retry failed; killing process (pid={proc.pid})")
                        proc.kill()
                        proc.wait(timeout=1)
                    except Exception:
                        logger.warning(f"Failed to force-exit {app_name}; continuing shutdown")
                finally:
                    self.process_registry.reset_runtime(app_name, status="stopped")

        self.process_registry.set_status("forum", "stopped")
        log_shutdown_step("Concurrent process cleanup finished; marking system stopped")
        cleanup.mark_system_stopped()


def build_process_manager(
    *,
    process_registry: ProcessRuntimeRegistry | None = None,
    streamlit_scripts: Mapping[str, str] | None = None,
) -> ProcessManager:
    """Build a process manager bound to the provided runtime registry."""

    return ProcessManager(
        process_registry=process_registry,
        streamlit_scripts=streamlit_scripts,
    )


def describe_running_children(*, process_registry: ProcessRuntimeRegistry | None = None) -> list[str]:
    return build_process_manager(process_registry=process_registry).describe_running_children()


def healthcheck_grace_active(app_name: str) -> bool:
    return build_process_manager().healthcheck_grace_active(app_name)


def log_healthcheck_failure(app_name: str, exc: Exception) -> None:
    build_process_manager().log_healthcheck_failure(app_name, exc)


def start_streamlit_app(
    app_name: str,
    script_path: str,
    port: int,
    *,
    log_dir: Path,
    emit_output: Callable[[str, dict], None],
) -> tuple[bool, str]:
    return build_process_manager().start_streamlit_app(
        app_name,
        script_path,
        port,
        log_dir=log_dir,
        emit_output=emit_output,
    )


def stop_streamlit_app(app_name: str) -> tuple[bool, str]:
    return build_process_manager().stop_streamlit_app(app_name)


def check_app_status(
    *,
    process_registry: ProcessRuntimeRegistry | None = None,
) -> None:
    build_process_manager(process_registry=process_registry).check_app_status()


def wait_for_app_startup(app_name: str, max_wait_time: int = 90) -> tuple[bool, str]:
    return build_process_manager().wait_for_app_startup(app_name, max_wait_time=max_wait_time)


def cleanup_processes(
    *,
    cleanup: ProcessCleanupPort,
) -> None:
    build_process_manager().cleanup_processes(cleanup=cleanup)


def cleanup_processes_concurrent(
    *,
    cleanup: ProcessCleanupPort,
    timeout: float = 6.0,
) -> None:
    build_process_manager().cleanup_processes_concurrent(cleanup=cleanup, timeout=timeout)


__all__ = [
    "ProcessCleanupPort",
    "ProcessManager",
    "STREAMLIT_SCRIPTS",
    "build_healthcheck_url",
    "build_process_manager",
    "check_app_status",
    "cleanup_processes",
    "cleanup_processes_concurrent",
    "describe_running_children",
    "get_default_streamlit_scripts",
    "healthcheck_grace_active",
    "log_healthcheck_failure",
    "log_shutdown_step",
    "start_streamlit_app",
    "stop_streamlit_app",
    "wait_for_app_startup",
]