from __future__ import annotations

import argparse
import os
import re
import shutil
import subprocess
import sys
from pathlib import Path
from typing import Callable, Optional

from textual.app import App

from cobot.tui import SCREEN_CSS, InputScreen, LogScreen

_PROJECT_DIR = Path(__file__).parent.parent.parent

# The documentation source lives inside the project. We mount it into the container so
# MkDocs can pick up live edits without rebuilding the image.
# Исходники документации находятся внутри проекта. Монтируем директорию в контейнер, чтобы
# MkDocs мог подхватывать изменения вживую без пересборки образа.
_DOC_DIR = _PROJECT_DIR / "doc" / "lwc-doc"
_IMAGE_NAME = "lwc-docs"
_CONTAINER_NAME = "lwc-docs"
_DEFAULT_PORT = "8000"

Write = Callable[[str], None]


# Thin wrapper around docker so we do not repeat ["docker", ...] everywhere.
# Тонкая обёртка вокруг docker, чтобы не повторять ["docker", ...] везде.
def _docker(*args: str, capture: bool = False) -> subprocess.CompletedProcess:
    return subprocess.run(["docker", *args], capture_output=capture, text=True)


# Check whether the docs container is currently running.
# Проверяем, запущен ли сейчас контейнер с документацией.
def _is_running() -> bool:
    r = _docker("ps", "--filter", f"name={_CONTAINER_NAME}", "--format", "{{.Names}}", capture=True)
    return _CONTAINER_NAME in r.stdout


# Check whether the docs Docker image has already been built.
# Проверяем, был ли уже собран Docker-образ для документации.
def _image_exists() -> bool:
    return bool(_docker("images", "-q", _IMAGE_NAME, capture=True).stdout.strip())


# Build the MkDocs Docker image. Only needs to run once.
# Progress comes from parsing "Step X/Y" lines in the docker build output.
# Собираем Docker-образ MkDocs. Нужно сделать только один раз.
# Прогресс получаем, парся строки "Step X/Y" из вывода docker build.
def _build_docs_image(
    write: Write,
    on_progress: Optional[Callable[[float], None]] = None,
) -> bool:
    write("[cyan][*][/cyan] Building documentation image (runs once)...")
    # DOCKER_BUILDKIT=0 gives us "Step X/Y" lines that we can parse for progress.
    # DOCKER_BUILDKIT=0 даёт нам строки "Step X/Y", которые можно парсить для прогресса.
    env = {**os.environ, "DOCKER_BUILDKIT": "0"}
    proc = subprocess.Popen(
        ["docker", "build", "-t", _IMAGE_NAME, str(_DOC_DIR)],
        stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, env=env,
    )
    for line in proc.stdout:
        s = line.rstrip()
        if s:
            write(s)
        if on_progress:
            m = re.match(r"Step (\d+)/(\d+) :", line)
            if m:
                step, total = int(m.group(1)), int(m.group(2))
                on_progress(step / total * 100)
    proc.wait()
    if proc.returncode == 0:
        write("[green][ok][/green] Documentation image ready")
        return True
    write("[red]Image build failed.[/red]")
    return False


# Start the docs server. Builds the image first if it does not exist yet.
# Запускаем сервер документации. Сначала собирает образ, если он ещё не существует.
def _task_up(screen: LogScreen, port: str) -> None:
    try:
        if _is_running():
            screen.write(f"[green]Docs already running at:[/green] http://localhost:{port}")
            screen.write("  Stop with: [bold]cobot doc-setup down[/bold]")
            screen.finish(True)
            return

        if not _DOC_DIR.exists():
            screen.write(f"[red]Doc directory not found:[/red] {_DOC_DIR}")
            screen.finish(False)
            return

        if not _image_exists():
            screen.set_progress(0, "Building documentation image...")
            if not _build_docs_image(
                screen.write,
                on_progress=lambda p: screen.set_progress(p * 0.85, "Building documentation image..."),
            ):
                screen.finish(False)
                return
        else:
            screen.write("[dim]Documentation image already built, skipping.[/dim]")

        screen.set_progress(88, "Starting MkDocs server...")
        screen.write("\n[cyan][*][/cyan] Starting MkDocs server...")
        result = _docker(
            "run", "-d", "--name", _CONTAINER_NAME, "--rm",
            "-p", f"{port}:8000",
            # Mount the docs directory so edits appear live without restarting the container.
            # Монтируем директорию с документацией, чтобы изменения появлялись сразу без перезапуска.
            "-v", f"{_DOC_DIR}:/docs",
            _IMAGE_NAME, "serve", "--dev-addr=0.0.0.0:8000",
            capture=True,
        )
        if result.returncode != 0:
            screen.write(f"[red]Failed to start container.[/red]\n{result.stderr}")
            screen.finish(False)
            return

        screen.set_progress(100, "Server running")
        screen.write(f"\n[green]Docs running at:[/green] http://localhost:{port}")
        screen.write("  Edit files in [bold]doc/lwc-doc/docs/[/bold] — reloads automatically.")
        screen.write("  Stop with: [bold]cobot doc-setup down[/bold]")
        screen.finish(True)

    except Exception as exc:
        screen.write(f"[red]Error:[/red] {exc}")
        screen.finish(False)


# Stop the running docs container.
# Останавливаем работающий контейнер с документацией.
def _task_down(screen: LogScreen) -> None:
    try:
        if not _is_running():
            screen.write("[yellow]Docs container is not running.[/yellow]")
            screen.finish(True)
            return
        screen.set_progress(30, "Stopping container...")
        screen.write("[cyan][*][/cyan] Stopping documentation server...")
        _docker("stop", _CONTAINER_NAME)
        screen.set_progress(100, "Done")
        screen.write("[green][ok][/green] Container stopped.")
        screen.finish(True)
    except Exception as exc:
        screen.write(f"[red]Error:[/red] {exc}")
        screen.finish(False)


# Stop the container, remove the old image, rebuild it, and start a new container.
# Останавливаем контейнер, удаляем старый образ, пересобираем и запускаем новый контейнер.
def _task_rebuild(screen: LogScreen, port: str) -> None:
    try:
        if _is_running():
            screen.set_progress(5, "Stopping container...")
            screen.write("[cyan][*][/cyan] Stopping existing container...")
            _docker("stop", _CONTAINER_NAME)
            screen.write("[green][ok][/green] Stopped.")

        if _image_exists():
            screen.set_progress(15, "Removing old image...")
            screen.write("[cyan][*][/cyan] Removing old image...")
            _docker("rmi", "-f", _IMAGE_NAME)
            screen.write("[green][ok][/green] Image removed.")

        screen.set_progress(20, "Building documentation image...")
        if not _build_docs_image(
            screen.write,
            on_progress=lambda p: screen.set_progress(20 + p * 0.68, "Building documentation image..."),
        ):
            screen.finish(False)
            return

        screen.set_progress(90, "Starting MkDocs server...")
        screen.write("\n[cyan][*][/cyan] Starting MkDocs server...")
        result = _docker(
            "run", "-d", "--name", _CONTAINER_NAME, "--rm",
            "-p", f"{port}:8000",
            "-v", f"{_DOC_DIR}:/docs",
            _IMAGE_NAME, "serve", "--dev-addr=0.0.0.0:8000",
            capture=True,
        )
        if result.returncode != 0:
            screen.write(f"[red]Failed to start container.[/red]\n{result.stderr}")
            screen.finish(False)
            return

        screen.set_progress(100, "Server running")
        screen.write(f"\n[green]Docs running at:[/green] http://localhost:{port}")
        screen.write("  Stop with: [bold]cobot doc-setup down[/bold]")
        screen.finish(True)

    except Exception as exc:
        screen.write(f"[red]Error:[/red] {exc}")
        screen.finish(False)


# One app handles all three actions (up/down/rebuild) by branching in on_mount.
# Одно приложение обрабатывает все три действия (up/down/rebuild), разветвляясь в on_mount.
class _DocApp(App[None]):
    CSS = SCREEN_CSS

    def __init__(self, action: str):
        super().__init__()
        self._action = action

    def on_mount(self) -> None:
        if self._action == "down":
            self.push_screen(
                LogScreen("Documentation server", _task_down, show_progress=True),
                lambda _: self.exit(),
            )
        elif self._action == "rebuild":
            self.push_screen(
                InputScreen("Step 1 of 1", "Port to serve documentation on:", _DEFAULT_PORT),
                self._got_port_rebuild,
            )
        else:
            self.push_screen(
                InputScreen("Step 1 of 1", "Port to serve documentation on:", _DEFAULT_PORT),
                self._got_port_up,
            )

    def _got_port_up(self, port: Optional[str]) -> None:
        if port is None:
            self.exit()
            return
        # Use the default port if the user cleared the input or typed something that is not a number.
        # Используем порт по умолчанию если пользователь очистил ввод или написал не число.
        p = (port.strip() or _DEFAULT_PORT) if port.isdigit() or not port.strip() else _DEFAULT_PORT
        self.push_screen(
            LogScreen("Documentation server", lambda s: _task_up(s, p), show_progress=True),
            lambda _: self.exit(),
        )

    def _got_port_rebuild(self, port: Optional[str]) -> None:
        if port is None:
            self.exit()
            return
        p = (port.strip() or _DEFAULT_PORT) if port.isdigit() or not port.strip() else _DEFAULT_PORT
        self.push_screen(
            LogScreen("Documentation server — rebuild", lambda s: _task_rebuild(s, p), show_progress=True),
            lambda _: self.exit(),
        )


def register(subparsers: argparse._SubParsersAction) -> None:
    p = subparsers.add_parser("doc-setup", help="Deploy or stop the documentation server")
    p.add_argument(
        "action",
        nargs="?",
        choices=["up", "down", "rebuild"],
        default="up",
        help="up — start (default), down — stop, rebuild — rebuild image and restart",
    )
    p.set_defaults(func=run)


def run(args: argparse.Namespace) -> None:
    if not shutil.which("docker"):
        from rich.console import Console
        Console().print("[red]Error:[/red] Docker is not installed or not on PATH.")
        sys.exit(1)

    action = getattr(args, "action", "up")
    _DocApp(action).run()