#!/usr/bin/env python3
"""Read-only Codex metadata picker for exactly the three KILN workspaces.

Reads scoped titles/names, never messages, rollouts, credentials or configuration.
SQLite is an internal Codex format: fail closed if its schema changes.
"""
import argparse
import json
from dataclasses import dataclass
from datetime import datetime, timezone
import os
from pathlib import Path
import re
import sqlite3
import sys
import unicodedata
from uuid import UUID
from zoneinfo import ZoneInfo

SITE = Path("/var/www/html/kiln")
BOT = Path("/srv/kiln-bot")
WORKSPACE = Path("/var/www/html/kiln-system")
PROJECTS = {str(SITE): "Сайт", str(BOT): "Бот", str(WORKSPACE): "Совместный"}


class SessionIndexError(Exception):
    pass


@dataclass(frozen=True)
class Session:
    id: str
    cwd: str
    updated_at: int
    title: str = ""
    sandbox_policy: str | None = None
    approval_policy: str | None = None

    def option(self) -> str:
        stamp = datetime.fromtimestamp(self.updated_at, timezone.utc)
        local = stamp.astimezone(ZoneInfo("Europe/Moscow"))
        return f"{local:%d.%m.%Y %H:%M}  {PROJECTS[self.cwd]:<10}  {display_title(self.title)}|{self.id}"


def display_title(value: object) -> str:
    if not isinstance(value, str):
        return "Без заголовка"
    # Do not let stored metadata inject terminal commands or Gum option values.
    value = re.sub(r"\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)", "", value)
    value = re.sub(r"\x1b\[[0-?]*[ -/]*[@-~]", "", value)
    value = " ".join(value.split())
    value = "".join(char for char in value if not unicodedata.category(char).startswith("C"))
    value = value.replace("|", "¦").strip()
    return (value[:159] + "…" if len(value) > 160 else value) or "Без заголовка"


def metadata_database(session_home: Path | None = None) -> Path:
    if session_home is None:
        session_home = Path(os.environ.get("CODEX_HOME", str(Path.home() / ".codex")))
    candidates = []
    for path in session_home.glob("state_*.sqlite"):
        match = re.fullmatch(r"state_(\d+)\.sqlite", path.name)
        if match:
            candidates.append((int(match[1]), path))
    if not candidates:
        raise SessionIndexError("Не найден индекс сессий Codex. Глобальный список не открывается.")
    return max(candidates, key=lambda item: item[0])[1]


def allowed_cwd(value: object) -> str | None:
    if not isinstance(value, str) or not Path(value).is_absolute():
        return None
    try:
        normalized = str(Path(value).resolve())
    except (OSError, ValueError, RuntimeError):
        return None
    # Exact root equality. Neither parent, child nor prefix/name matching.
    return normalized if normalized in PROJECTS else None


def list_sessions(database: Path) -> list[Session]:
    try:
        connection = sqlite3.connect(database.absolute().as_uri() + "?mode=ro", uri=True, timeout=3)
        try:
            connection.execute("PRAGMA query_only=ON")
            # Name is optional in older Codex indexes. Scope in SQL before
            # retrieving titles. Never select messages, preview or rollout_path.
            columns = {row[1] for row in connection.execute("PRAGMA table_info(threads)")}
            title_column = "COALESCE(NULLIF(name,''),title)" if "name" in columns else "title"
            rows = connection.execute(
                f"SELECT id,cwd,updated_at,{title_column},sandbox_policy,approval_mode FROM threads WHERE archived=0 "
                "AND RTRIM(cwd,'/') IN (?,?,?) ORDER BY updated_at DESC,id",
                tuple(PROJECTS),
            ).fetchall()
        finally:
            connection.close()
    except sqlite3.Error as error:
        raise SessionIndexError("Не удалось прочитать метаданные Codex. Глобальный список не открывается.") from error
    result = []
    for ident, cwd, updated_at, title, sandbox_policy, approval_policy in rows:
        project = allowed_cwd(cwd)
        if not project:
            continue
        try:
            ident = str(UUID(ident))
            stamp = int(updated_at)
            datetime.fromtimestamp(stamp, timezone.utc)
        except (ValueError, TypeError, OverflowError, OSError):
            continue
        result.append(Session(ident, project, stamp, title, sandbox_policy, approval_policy))
    return result


def resume_command(ident: str, sessions: list[Session]) -> list[str]:
    session = next((session for session in sessions if session.id == ident), None)
    if session is None:
        raise SessionIndexError("Эта сессия не принадлежит рабочим каталогам KILN или уже недоступна.")
    try:
        policy = json.loads(session.sandbox_policy)
        mode = policy["type"]
        if mode == "disabled":
            mode = "danger-full-access"
        if mode not in ("read-only", "workspace-write", "danger-full-access"):
            raise ValueError("unsupported policy")
        if session.approval_policy not in ("never", "on-request"):
            raise ValueError("unsupported approval policy")
        supported = {"type"}
        if mode == "workspace-write":
            supported |= {"writable_roots", "network_access", "exclude_tmpdir_env_var", "exclude_slash_tmp"}
        if set(policy) - supported:
            raise ValueError("unsupported filesystem policy")
        extra = []
        if mode == "workspace-write":
            for key, value in policy.items():
                if key == "type":
                    continue
                if key == "writable_roots":
                    if not isinstance(value, list) or not all(isinstance(root, str) and Path(root).is_absolute() for root in value):
                        raise ValueError("invalid writable roots")
                elif not isinstance(value, bool):
                    raise ValueError("invalid sandbox option")
                extra += ["-c", f"sandbox_workspace_write.{key}={json.dumps(value, ensure_ascii=False)}"]
            extra += ["--add-dir", str(SITE), "--add-dir", str(BOT)]
    except (ValueError, TypeError, KeyError):
        raise SessionIndexError("Не удалось восстановить сохранённые права сессии. Режим доступа не изменён.") from None
    # Restore saved permissions before CLI validates additional writable roots.
    # Full-access already covers both repositories; read-only must stay read-only.
    return ["codex", "resume", ident, "--sandbox", mode,
            "--ask-for-approval", session.approval_policy, "--cd", str(WORKSPACE), *extra]


def local_proxy_bypass() -> None:
    # Preserve all existing exclusions, including separately configured domains.
    for key in ("NO_PROXY", "no_proxy"):
        entries = [part.strip() for part in os.environ.get(key, "").split(",") if part.strip()]
        for host in ("localhost", "127.0.0.1", "::1"):
            if host not in entries:
                entries.append(host)
        os.environ[key] = ",".join(entries)


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("action", choices=("list", "resume"))
    parser.add_argument("id", nargs="?")
    args = parser.parse_args()
    try:
        sessions = list_sessions(metadata_database())
        if args.action == "list":
            for session in sessions:
                print(session.option())
            return 0
        # Recheck against the current scoped index after choosing, so a value
        # injected through the selector cannot resume an unrelated project.
        command = resume_command(args.id or "", sessions)
        if not (WORKSPACE / "AGENTS.md").is_file():
            raise SessionIndexError("Не установлен совместный каталог KILN; проверьте deploy/admin-menu/README.md.")
        local_proxy_bypass()
        os.chdir(WORKSPACE)
        os.execvp(command[0], command)
    except (SessionIndexError, OSError) as error:
        if isinstance(error, SessionIndexError):
            print(str(error), file=sys.stderr)
        else:
            print("Не удалось запустить Codex для выбранной сессии KILN.", file=sys.stderr)
        return 2
    return 0


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