import contextlib
from datetime import datetime, timezone
import importlib.util
import io
import json
import os
from pathlib import Path
import sqlite3
import sys
import tempfile
import unittest
from unittest.mock import patch
from uuid import UUID

spec = importlib.util.spec_from_file_location("kiln_session_picker", Path(__file__).with_name("codex-kiln-sessions.py"))
picker = importlib.util.module_from_spec(spec)
sys.modules[spec.name] = picker
spec.loader.exec_module(picker)


class SessionPickerTests(unittest.TestCase):
    def setUp(self):
        self.temp = tempfile.TemporaryDirectory(prefix="kiln-session-picker-test-")
        self.addCleanup(self.temp.cleanup)
        self.database = Path(self.temp.name) / "state_5.sqlite"
        with sqlite3.connect(self.database) as connection:
            connection.execute("CREATE TABLE threads(id TEXT PRIMARY KEY,cwd TEXT,updated_at INTEGER,archived INTEGER,title TEXT,first_user_message TEXT,sandbox_policy TEXT,approval_mode TEXT)")

    def insert(self, number, cwd, stamp=1, archived=0, title="Тестовая сессия", policy=None, approval="never"):
        ident = str(UUID(int=number))
        with sqlite3.connect(self.database) as connection:
            connection.execute("INSERT INTO threads VALUES(?,?,?,?,?,?,?,?)", (ident, cwd, stamp, archived, title, "DO NOT READ TRANSCRIPT", json.dumps(policy or {"type": "disabled"}), approval))
        return ident

    def test_only_three_exact_roots_and_no_archive(self):
        expected = [self.insert(n, path, stamp=n) for n, path in enumerate(picker.PROJECTS, 1)]
        for n, path in enumerate(("/var/www/html/hotelerp", "/var/www/html/kiln-hotelerp", "/srv/kiln-bot-backup", "/var/www/html/kiln/tmp/hotelerp", "/var/www/html/kiln-system-other", "/root", "/"), 10):
            self.insert(n, path, stamp=1000)
        self.insert(30, str(picker.SITE), stamp=2000, archived=1)
        sessions = picker.list_sessions(self.database)
        self.assertEqual([row.id for row in sessions], list(reversed(expected)))
        self.assertEqual({row.cwd for row in sessions}, set(picker.PROJECTS))

    def test_all_project_sessions_not_just_a_recent_page(self):
        for n in range(1, 251):
            self.insert(n, str(picker.BOT), stamp=n)
        self.insert(1000, "/var/www/html/hotelerp", stamp=100000)
        self.assertEqual(len(picker.list_sessions(self.database)), 250)

    def test_legacy_index_does_not_require_has_user_event(self):
        # The real current Codex index has has_user_event=0 even for saved CLI chats.
        self.insert(1, str(picker.SITE))
        self.assertEqual(len(picker.list_sessions(self.database)), 1)

    def test_read_only_and_no_transcript_access(self):
        self.insert(1, str(picker.SITE))
        connection = sqlite3.connect(self.database)
        permitted = {"id", "cwd", "updated_at", "archived", "title", "sandbox_policy", "approval_mode"}
        seen = []
        def authorize(action, table, column, _db, _source):
            if action == sqlite3.SQLITE_READ and table == "threads":
                seen.append(column)
                return sqlite3.SQLITE_OK if column in permitted else sqlite3.SQLITE_DENY
            return sqlite3.SQLITE_OK
        connection.set_authorizer(authorize)
        original_connect = sqlite3.connect
        def read_only_connect(filename_uri, **kwargs):
            self.assertTrue(filename_uri.endswith("?mode=ro"))
            self.assertTrue(kwargs["uri"])
            return connection
        with patch.object(picker.sqlite3, "connect", side_effect=read_only_connect):
            self.assertEqual(len(picker.list_sessions(self.database)), 1)
        self.assertEqual(set(seen), permitted)
        with original_connect(self.database) as verify:
            self.assertEqual(verify.execute("SELECT COUNT(*) FROM threads").fetchone()[0], 1)

    def test_missing_or_changed_index_fails_closed(self):
        missing = Path(self.temp.name) / "missing.sqlite"
        with self.assertRaises(picker.SessionIndexError):
            picker.list_sessions(missing)
        self.assertFalse(missing.exists())
        wrong = Path(self.temp.name) / "changed.sqlite"
        with sqlite3.connect(wrong) as connection:
            connection.execute("CREATE TABLE something_else(id TEXT)")
        with self.assertRaises(picker.SessionIndexError):
            picker.list_sessions(wrong)

    def test_latest_metadata_version_and_missing_index(self):
        self.assertEqual(picker.metadata_database(Path(self.temp.name)), self.database)
        newer = Path(self.temp.name) / "state_10.sqlite"
        newer.touch()
        self.assertEqual(picker.metadata_database(Path(self.temp.name)), newer)
        with tempfile.TemporaryDirectory() as empty:
            with self.assertRaises(picker.SessionIndexError):
                picker.metadata_database(Path(empty))

    def test_bad_identifiers_are_never_passed_to_codex(self):
        with sqlite3.connect(self.database) as connection:
            connection.execute("INSERT INTO threads VALUES(?,?,?,?,?,?,?,?)", ("$(bad);not-a-uuid", str(picker.SITE), 1, 0, "", "", '{"type":"disabled"}', 'never'))
        self.assertEqual(picker.list_sessions(self.database), [])

    def test_paths_do_not_match_parent_child_or_escaping_symlink(self):
        self.assertIsNone(picker.allowed_cwd("/var/www/html"))
        self.assertIsNone(picker.allowed_cwd(str(picker.SITE / "src")))
        self.assertIsNone(picker.allowed_cwd("/var/www/html/kiln/../hotelerp"))
        self.assertIsNone(picker.allowed_cwd("relative/path"))
        with patch.object(picker.Path, "resolve", return_value=Path("/var/www/html/hotelerp")):
            self.assertIsNone(picker.allowed_cwd(str(picker.SITE)))

    def test_resume_uses_selected_id_and_joint_context_without_global_picker(self):
        ident = self.insert(1, str(picker.BOT))
        sessions = picker.list_sessions(self.database)
        self.assertEqual(picker.resume_command(ident, sessions), ["codex", "resume", ident, "--sandbox", "danger-full-access", "--ask-for-approval", "never", "--cd", str(picker.WORKSPACE)])
        for bad in (str(UUID(int=999)), "--all", "", "$(bad)"):
            with self.assertRaises(picker.SessionIndexError):
                picker.resume_command(bad, sessions)

    def test_injected_other_project_choice_cannot_launch_codex(self):
        self.insert(1, str(picker.SITE))
        other = self.insert(2, "/var/www/html/hotelerp")
        with patch.object(picker, "metadata_database", return_value=self.database), \
             patch.object(sys, "argv", ["picker", "resume", other]), \
             patch.object(picker.os, "execvp") as launch, \
             patch.object(picker.os, "chdir") as change_dir, contextlib.redirect_stderr(io.StringIO()):
            self.assertEqual(picker.main(), 2)
        launch.assert_not_called()
        change_dir.assert_not_called()

    def test_display_is_moscow_and_metadata_only(self):
        stamp = int(datetime(2026, 11, 5, 12, tzinfo=timezone.utc).timestamp())
        ident = self.insert(1, str(picker.SITE), stamp=stamp)
        option = picker.list_sessions(self.database)[0].option()
        self.assertIn("05.11.2026 15:00", option)
        self.assertIn("Сайт", option)
        self.assertTrue(option.endswith("|" + ident))
        self.assertIn("Тестовая сессия", option)
        self.assertNotIn(ident, option.split("|", 1)[0])
        self.assertNotIn("DO NOT READ", option)

    def test_explicit_name_takes_precedence_over_title(self):
        self.insert(1, str(picker.SITE), title="Исходный заголовок")
        with sqlite3.connect(self.database) as connection:
            connection.execute("ALTER TABLE threads ADD COLUMN name TEXT")
            connection.execute("UPDATE threads SET name='Новое название'")
        self.assertIn("Новое название", picker.list_sessions(self.database)[0].option())

    def test_title_sanitizes_terminal_controls_delimiters_and_length(self):
        ident = self.insert(1, str(picker.SITE), title="\x1b]0;unsafe\x07\x1b[31mНазвание\x1b[0m\nстрока|подмена\u202e")
        option = picker.list_sessions(self.database)[0].option()
        self.assertIn("Название строка¦подмена", option)
        self.assertEqual(option.count("|"), 1)
        self.assertTrue(option.endswith("|" + ident))
        for control in ("\x1b", "\x07", "\n", "\u202e", "unsafe"):
            self.assertNotIn(control, option)
        self.assertEqual(picker.display_title(None), "Без заголовка")
        self.assertEqual(picker.display_title("  \n"), "Без заголовка")
        self.assertEqual(len(picker.display_title("я" * 1000)), 160)

    def test_titles_are_retrieved_only_for_allowed_roots(self):
        self.insert(1, str(picker.SITE), title="Разговор KILN про HotelERP")
        self.insert(2, "/var/www/html/hotelerp", title="Чужое название")
        connection = sqlite3.connect(self.database)
        connection.execute("ALTER TABLE threads RENAME TO original_threads")
        accessed = []
        connection.create_function("track_title", 1, lambda title: accessed.append(title) or title)
        connection.execute("CREATE VIEW threads AS SELECT id,cwd,updated_at,archived,track_title(title) AS title,first_user_message,sandbox_policy,approval_mode FROM original_threads")
        with patch.object(picker.sqlite3, "connect", return_value=connection):
            sessions = picker.list_sessions(self.database)
        self.assertEqual(accessed, ["Разговор KILN про HotelERP"])
        self.assertIn("Разговор KILN про HotelERP", sessions[0].option())

    def test_read_only_session_is_not_elevated_and_has_no_add_dir(self):
        ident = self.insert(1, str(picker.SITE), policy={"type": "read-only"}, approval="on-request")
        command = picker.resume_command(ident, picker.list_sessions(self.database))
        self.assertEqual(command[command.index("--sandbox") + 1], "read-only")
        self.assertEqual(command[command.index("--ask-for-approval") + 1], "on-request")
        self.assertNotIn("--add-dir", command)

    def test_workspace_write_session_keeps_options_and_both_repositories(self):
        policy = {"type": "workspace-write", "writable_roots": ["/tmp/a b"], "network_access": True, "exclude_slash_tmp": True}
        ident = self.insert(1, str(picker.SITE), policy=policy, approval="on-request")
        command = picker.resume_command(ident, picker.list_sessions(self.database))
        self.assertEqual(command[command.index("--sandbox") + 1], "workspace-write")
        self.assertEqual(command.count("--add-dir"), 2)
        self.assertIn('sandbox_workspace_write.writable_roots=["/tmp/a b"]', command)
        self.assertIn('sandbox_workspace_write.network_access=true', command)
        self.assertIn('sandbox_workspace_write.exclude_slash_tmp=true', command)

    def test_unknown_permissions_are_never_silently_replaced(self):
        for n, policy in enumerate(({"type": "custom"}, {"type": "disabled", "unknown": True}, {"type": "workspace-write", "network_access": "yes"}), 1):
            ident = self.insert(n, str(picker.SITE), policy=policy)
            with self.assertRaises(picker.SessionIndexError):
                picker.resume_command(ident, picker.list_sessions(self.database))

    def test_mcp_localhost_bypass_preserves_other_proxy_settings_and_domains(self):
        env = {"NO_PROXY": "existing.example,localhost", "no_proxy": "another.example", "HTTPS_PROXY": "http://127.0.0.1:1081"}
        with patch.dict(os.environ, env, clear=True):
            picker.local_proxy_bypass()
            picker.local_proxy_bypass()
            self.assertEqual(os.environ["NO_PROXY"], "existing.example,localhost,127.0.0.1,::1")
            self.assertEqual(os.environ["no_proxy"], "another.example,localhost,127.0.0.1,::1")
            self.assertEqual(os.environ["HTTPS_PROXY"], env["HTTPS_PROXY"])


if __name__ == "__main__":
    unittest.main()
