"""Coding-mode toggle: ON enforces code-task, OFF makes it unreachable."""

from __future__ import annotations

import shlex
import sys
from types import SimpleNamespace

import pytest

from opensquilla.engine.steps.coding_mode import enforce_coding_mode
from opensquilla.engine.steps.skills_filter import _eligibility_ctx
from opensquilla.gateway.config import GatewayConfig
from opensquilla.gateway.rpc_config import _SAFE_WRITE_PATCH_PATHS
from opensquilla.skills.eligibility import (
    CODING_MODE_SKILLS,
    effective_disabled,
    is_skill_available,
)
from opensquilla.tools.policy_config import (
    CODING_MODE_DENIED_TOOLS,
    coding_mode_denied_tools,
)


class TestAvailabilityHelper:
    def test_codetask_gated_when_coding_mode_off(self):
        assert is_skill_available("code-task", disabled=[], coding_mode=False) is False

    def test_codetask_available_when_coding_mode_on(self):
        assert is_skill_available("code-task", disabled=[], coding_mode=True) is True

    def test_other_skill_unaffected_by_coding_mode(self):
        assert is_skill_available("git-diff", disabled=[], coding_mode=False) is True

    def test_other_skill_still_respects_disabled(self):
        assert is_skill_available("git-diff", disabled=["git-diff"], coding_mode=True) is False

    def test_effective_disabled_adds_codetask_when_off(self):
        assert CODING_MODE_SKILLS <= effective_disabled([], coding_mode=False)
        assert "code-task" not in effective_disabled([], coding_mode=True)


class TestConfig:
    def test_coding_mode_defaults_off(self):
        assert GatewayConfig().skills.coding_mode is False

    def test_coding_mode_is_safe_write_path(self):
        assert "skills.coding_mode" in _SAFE_WRITE_PATCH_PATHS


class TestRuntimeToolContextCodingMode:
    @pytest.mark.asyncio
    async def test_build_tools_threads_config_coding_mode_into_tool_context(self):
        import json

        from opensquilla.engine.runtime import TurnRunner
        from opensquilla.tool_boundary import ToolCall
        from opensquilla.tools.registry import ToolRegistry
        from opensquilla.tools.types import ToolContext, ToolSpec, current_tool_context

        async def capture_coding_mode() -> str:
            ctx = current_tool_context.get()
            return json.dumps(
                {"coding_mode": ctx.coding_mode if ctx is not None else None}
            )

        registry = ToolRegistry()
        registry.register(
            ToolSpec(
                name="capture_coding_mode",
                description="capture coding mode",
                parameters={},
            ),
            capture_coding_mode,
        )
        config = GatewayConfig()
        config.skills.coding_mode = True
        runner = TurnRunner(provider_selector=None, tool_registry=registry, config=config)
        ctx = ToolContext(is_owner=True)

        tool_defs, handler = runner._build_tools(ctx)

        assert ctx.coding_mode is True
        assert {tool.name for tool in tool_defs} == {"capture_coding_mode"}
        assert handler is not None
        result = await handler(
            ToolCall(
                tool_use_id="tc-coding-mode",
                tool_name="capture_coding_mode",
                arguments={},
            )
        )
        assert result.is_error is False
        assert json.loads(result.content) == {"coding_mode": True}

    def test_build_tools_applies_coding_mode_denies_to_live_surface(self):
        import opensquilla.tools.builtin  # noqa: F401  (registers builtins)
        from opensquilla.engine.runtime import TurnRunner
        from opensquilla.tools.registry import get_default_registry
        from opensquilla.tools.types import CallerKind, ToolContext

        config = GatewayConfig()
        config.skills.coding_mode = True
        runner = TurnRunner(
            provider_selector=None,
            tool_registry=get_default_registry(),
            config=config,
        )
        ctx = ToolContext(is_owner=True, caller_kind=CallerKind.AGENT)

        tool_defs, _handler = runner._build_tools(ctx)
        names = {getattr(td, "name", "") for td in tool_defs}

        assert ctx.coding_mode is True
        assert coding_mode_denied_tools(True) <= ctx.denied_tools
        assert {
            "write_file",
            "edit_file",
            "apply_patch",
            "execute_code",
            "git_commit",
        }.isdisjoint(names)


class TestSkillsFilterGate:
    def test_off_gates_codetask(self):
        ctx = _eligibility_ctx(SimpleNamespace(disabled=[], coding_mode=False))
        assert "code-task" in ctx.disabled_set

    def test_on_does_not_gate_codetask(self):
        ctx = _eligibility_ctx(SimpleNamespace(disabled=[], coding_mode=True))
        assert "code-task" not in ctx.disabled_set


class TestDirectiveInjection:
    @pytest.fixture(autouse=True)
    def _stub_resolver(self, monkeypatch):
        # Deterministic, no subprocess: the directive's command line is the
        # resolved code-task invocation; pin it for these assertions.
        from opensquilla.engine.steps import coding_mode as _cm
        monkeypatch.setattr(
            _cm, "resolve_code_task_command", lambda: "/opt/x/opensquilla code-task"
        )

    def _ctx(self, coding_mode: bool):
        return SimpleNamespace(
            config=SimpleNamespace(skills=SimpleNamespace(coding_mode=coding_mode)),
            system_prompt="BASE",
            metadata={},
        )

    @pytest.mark.asyncio
    async def test_on_injects_directive_and_pins(self):
        ctx = await enforce_coding_mode(self._ctx(True))
        base, suffix = ctx.system_prompt
        assert base == "BASE"
        assert "CODING MODE" in suffix
        assert "opensquilla code-task solve" in suffix
        assert "DISABLED while coding mode is on" in suffix
        assert "code-task" in ctx.metadata["pinned_skills"]
        assert ctx.metadata["coding_mode"] is True

    @pytest.mark.asyncio
    async def test_directive_clarify_gate_asks_when_only_a_category(self):
        """Build-from-scratch clarify gate: a bare app category with no concrete
        features/scope/user gets 1-2 questions; a request that names concrete
        features/scope builds directly. Asserted as normalized concept groups so
        harmless rewording survives."""
        ctx = await enforce_coding_mode(self._ctx(True))
        _, suffix = ctx.system_prompt
        low = suffix.lower()
        # Trigger is "only a category / no concrete features".
        assert "only a" in low and "category" in low
        assert "concrete features" in low
        # Build (don't ask) once concrete features/scope/users are named.
        assert "do not ask" in low and "build it" in low
        # Bounded (<=2) and ask-then-stop (Lovable's "wait before calling tools").
        assert "1-2" in low and "at most 2" in low
        assert "stop this turn" in low
        assert "do not call code-task until" in low
        # Defaultable details are never asked about.
        assert "platform" in low and "styling" in low

    @pytest.mark.asyncio
    async def test_directive_warns_against_killing_running_code_task(self):
        """Isolation rule: the source repo stays empty until verified, so don't
        judge progress by it and don't kill/retry a running code-task."""
        ctx = await enforce_coding_mode(self._ctx(True))
        _, suffix = ctx.system_prompt
        low = suffix.lower()
        assert "isolated run directory" in low
        assert "stays empty until" in low  # source empty until verified
        assert "do not judge progress by the source" in low
        assert "do not kill" in low
        assert "status.json" in low

    @pytest.mark.asyncio
    async def test_directive_mandates_background_not_blocking_exec(self):
        ctx = await enforce_coding_mode(self._ctx(True))
        _, suffix = ctx.system_prompt
        low = suffix.lower()
        assert "always launch it with background_process" in low
        assert "do not run code-task with a" in low and "blocking exec_command" in low
        assert "600s" in suffix

    @pytest.mark.asyncio
    async def test_directive_mandates_task_file_staging(self):
        """Field report: a multi-line task passed inline as `--task "<text>"`
        gets truncated at the first \\n by cmd.exe on Windows, silently
        eating --yes and hanging code-task for 90 minutes at typer.confirm.
        The directive must teach the agent to stage task text via stdin
        into a temp file, then pass --task-file <path>."""
        ctx = await enforce_coding_mode(self._ctx(True))
        _, suffix = ctx.system_prompt

        # The command-line examples use --task-file, NOT inline --task.
        assert "--task-file <path>" in suffix
        # The scratch-mode template no longer emits the inline --task form.
        scratch_block = suffix.split("scratch --yes", 1)[0]
        assert '--task "<text>" --verification-mode' not in scratch_block

        # The "why + how" section is present and unambiguous.
        assert "TASK-FILE STAGING" in suffix
        # No exception language — inline --task is FORBIDDEN regardless of
        # length/complexity. This guards against re-introducing the "single-
        # line ASCII is fine" escape hatch a model could rationalize into.
        assert "FORBIDDEN" in suffix
        assert "is an optimization" not in suffix
        assert "newline" in suffix.lower()
        assert "cmd.exe" in suffix.lower()

        # The two-step recipe references both tools by name and the
        # exec_command(stdin=...) escape hatch that bypasses cmd.exe.
        assert "exec_command" in suffix
        assert "stdin=" in suffix
        assert "background_process" in suffix
        assert "code-task stage-task-file" in suffix
        # Packaged desktop gateways are not Python interpreters. The staging
        # recipe must therefore be a code-task subcommand, never
        # `opensquilla-gateway -c ...`.
        assert " -c " not in suffix
        assert "sys.stdin.buffer.read()" not in suffix
        # Both real-repo (case 1) and scratch (case 2) recipes are shown,
        # otherwise weaker models copy the scratch command for repo edits.
        assert "Case 1, real repo" in suffix
        assert "Case 2, scratch" in suffix
        assert "Case 3, app build from scratch" in suffix
        assert "--verification-mode build --yes" in suffix
        # Explicit framing of exec_command's exit_code=0 prefix so the
        # agent doesn't try to parse the wrong stdout line.
        assert "exit_code=0" in suffix
        # Cleanup instructions: temp prose can contain private issue text;
        # the directive must tell the agent to drop the file after wait.
        cleanup_block = suffix.lower()
        assert "cleanup" in cleanup_block
        assert "del " in suffix and "rm " in suffix  # Windows + POSIX

    @pytest.mark.asyncio
    async def test_directive_uses_codetask_stage_task_file_not_python_dash_c(
        self, monkeypatch
    ):
        """Packaged gateways are CLI binaries, not Python interpreters.

        A desktop build previously rendered the staging recipe as
        `opensquilla-gateway -c ...`, which Typer rejects with
        "No such option: -c".  The directive must route staging through the
        verified code-task command prefix instead.
        """
        from opensquilla.engine.steps import coding_mode as _cm
        packaged_code_task = (
            "/Applications/OpenSquilla.app/Contents/Resources/runtime/"
            "gateway/opensquilla-gateway code-task"
        )
        monkeypatch.setattr(
            _cm,
            "resolve_code_task_command",
            lambda: packaged_code_task,
        )

        ctx = await enforce_coding_mode(self._ctx(True))
        _, suffix = ctx.system_prompt
        assert "opensquilla-gateway code-task stage-task-file" in suffix
        assert "opensquilla-gateway -c" not in suffix

    @pytest.mark.asyncio
    async def test_off_injects_nothing(self):
        ctx = await enforce_coding_mode(self._ctx(False))
        # system_prompt unchanged (still a plain str), no pin.
        assert ctx.system_prompt == "BASE"
        assert "pinned_skills" not in ctx.metadata

    @pytest.mark.asyncio
    async def test_directive_appends_to_existing_suffix(self):
        ctx = self._ctx(True)
        ctx.system_prompt = ("BASE", "PRIOR")
        out = await enforce_coding_mode(ctx)
        base, suffix = out.system_prompt
        assert base == "BASE"
        assert suffix.startswith("PRIOR")
        assert "CODING MODE" in suffix


class TestWriteToolDeny:
    """coding ON denies the in-session write tools (forces code-task)."""

    def test_on_denies_write_tools(self):
        denied = coding_mode_denied_tools(True)
        for t in ("write_file", "edit_file", "apply_patch", "execute_code", "git_commit"):
            assert t in denied
        assert denied == CODING_MODE_DENIED_TOOLS

    def test_off_denies_nothing(self):
        assert coding_mode_denied_tools(False) == frozenset()

    def test_shell_and_read_tools_kept(self):
        # shell stays so the agent can still LAUNCH code-task; reads stay.
        denied = coding_mode_denied_tools(True)
        for t in ("exec_command", "background_process", "process",
                  "read_file", "list_dir", "grep_search", "git_diff"):
            assert t not in denied


class TestWriteToolDenyEnforcement:
    """Integration: the deny set actually drops write tools from the live
    tool surface built from the default registry (pins the enforcement seam,
    not just the pure helper)."""

    def _surface(self, denied):
        import opensquilla.tools.builtin  # noqa: F401  (registers builtins)
        from opensquilla.tools.registry import get_default_registry
        from opensquilla.tools.types import CallerKind, ToolContext

        registry = get_default_registry()
        ctx = ToolContext(
            is_owner=True,
            caller_kind=CallerKind.AGENT,
            denied_tools=set(denied),
        )
        return {t.name for t in registry.to_tool_definitions(ctx)}

    def test_on_drops_write_tools_from_surface(self):
        names = self._surface(coding_mode_denied_tools(True))
        assert {
            "write_file",
            "edit_file",
            "apply_patch",
            "execute_code",
            "git_commit",
        }.isdisjoint(names)

    def test_on_keeps_codetask_launch_and_read_tools(self):
        # shell stays so the agent can still LAUNCH `opensquilla code-task solve`;
        # read-only tools stay so it can understand the repo.
        names = self._surface(coding_mode_denied_tools(True))
        for keep in ("exec_command", "background_process", "process",
                     "read_file", "list_dir", "grep_search"):
            assert keep in names, keep

    def test_off_is_noop_keeps_write_tools(self):
        names = self._surface(coding_mode_denied_tools(False))
        assert "write_file" in names
        assert "edit_file" in names


class TestPackagedCodeTaskResolution:
    """Packaged desktop gateways are the CLI executable, not a Python binary."""

    def test_uses_current_executable_when_it_runs_codetask(self, monkeypatch, tmp_path):
        from opensquilla.engine.steps import coding_mode as cm

        cm._reset_resolution_cache()
        app_dir = tmp_path / "OpenSquilla App"
        app_dir.mkdir()
        exe = app_dir / "opensquilla-gateway"
        exe.write_text("")
        exe.chmod(0o755)
        monkeypatch.setattr(cm.sys, "executable", str(exe))
        monkeypatch.setattr(cm.shutil, "which", lambda name: None)
        monkeypatch.setattr(cm, "_runs_code_task", lambda argv: argv == [str(exe)])

        assert cm.resolve_code_task_command() == f"{cm._quote(str(exe))} code-task"

        cm._reset_resolution_cache()

    def test_uses_current_windows_gateway_executable_path(self, monkeypatch):
        from opensquilla.engine.steps import coding_mode as cm

        cm._reset_resolution_cache()
        exe = r"C:\Program Files\OpenSquilla\opensquilla-gateway.exe"
        monkeypatch.setattr(cm.sys, "executable", exe)
        monkeypatch.setattr(cm.shutil, "which", lambda name: None)
        monkeypatch.setattr(cm, "_runs_code_task", lambda argv: argv == [exe])

        assert cm.resolve_code_task_command() == f"{cm._quote(exe)} code-task"

        cm._reset_resolution_cache()

    def test_does_not_accept_direct_probe_for_plain_python(self, monkeypatch, tmp_path):
        from opensquilla.engine.steps import coding_mode as cm

        cm._reset_resolution_cache()
        py = str(tmp_path / "python")
        monkeypatch.setattr(cm.sys, "executable", py)
        monkeypatch.setattr(cm.shutil, "which", lambda name: None)
        calls: list[list[str]] = []

        def fake_runs(argv: list[str]) -> bool:
            calls.append(argv)
            return argv == [py]

        monkeypatch.setattr(cm, "_runs_code_task", fake_runs)

        assert cm.resolve_code_task_command() is None
        assert [py] not in calls

        cm._reset_resolution_cache()


@pytest.mark.skipif(sys.platform == "win32", reason="code-task Windows support is WIP")
class TestCodeTaskResolution:
    """resolve_code_task_command picks a PATH-independent, runnable invocation."""

    def test_prefers_adjacent_cli(self, monkeypatch, tmp_path):
        from opensquilla.engine.steps import coding_mode as cm
        cm._reset_resolution_cache()
        cli = tmp_path / "opensquilla"
        cli.write_text("")
        cli.chmod(0o755)
        monkeypatch.setattr(cm.sys, "executable", str(tmp_path / "python"))
        monkeypatch.setattr(cm, "_runs_code_task", lambda argv: argv[0] == str(cli))
        assert cm.resolve_code_task_command() == f"{shlex.quote(str(cli))} code-task"
        cm._reset_resolution_cache()

    def test_falls_back_to_module_invocation(self, monkeypatch, tmp_path):
        from opensquilla.engine.steps import coding_mode as cm
        cm._reset_resolution_cache()
        py = str(tmp_path / "python")  # no adjacent opensquilla file exists
        monkeypatch.setattr(cm.sys, "executable", py)
        monkeypatch.setattr(cm.shutil, "which", lambda name: None)
        monkeypatch.setattr(cm, "_runs_code_task", lambda argv: argv[:2] == [py, "-P"])
        assert (
            cm.resolve_code_task_command()
            == f"{shlex.quote(py)} -P -m opensquilla.cli.main code-task"
        )
        cm._reset_resolution_cache()

    def test_adjacent_exists_but_preflight_fails_falls_through(self, monkeypatch, tmp_path):
        from opensquilla.engine.steps import coding_mode as cm
        cm._reset_resolution_cache()
        cli = tmp_path / "opensquilla"
        cli.write_text("")
        cli.chmod(0o755)
        py = str(tmp_path / "python")
        monkeypatch.setattr(cm.sys, "executable", py)
        monkeypatch.setattr(cm.shutil, "which", lambda name: None)
        # adjacent CLI exists but its --help fails; module invocation works
        monkeypatch.setattr(cm, "_runs_code_task", lambda argv: argv[:2] == [py, "-P"])
        assert (
            cm.resolve_code_task_command()
            == f"{shlex.quote(py)} -P -m opensquilla.cli.main code-task"
        )
        cm._reset_resolution_cache()

    def test_failure_is_not_cached_retries(self, monkeypatch, tmp_path):
        from opensquilla.engine.steps import coding_mode as cm
        cm._reset_resolution_cache()
        py = str(tmp_path / "python")
        monkeypatch.setattr(cm.sys, "executable", py)
        monkeypatch.setattr(cm.shutil, "which", lambda name: None)
        available = {"ok": False}
        def flaky(argv):
            return available["ok"] and argv[:2] == [py, "-P"]
        monkeypatch.setattr(cm, "_runs_code_task", flaky)
        assert cm.resolve_code_task_command() is None      # transient failure, NOT cached
        available["ok"] = True
        assert cm.resolve_code_task_command() is not None  # retried, resolves
        cm._reset_resolution_cache()

    def test_falls_back_to_path_which(self, monkeypatch, tmp_path):
        from opensquilla.engine.steps import coding_mode as cm
        cm._reset_resolution_cache()
        monkeypatch.setattr(cm.sys, "executable", str(tmp_path / "python"))
        monkeypatch.setattr(cm.shutil, "which", lambda name: "/usr/bin/opensquilla")
        monkeypatch.setattr(cm, "_runs_code_task", lambda argv: argv[0] == "/usr/bin/opensquilla")
        assert cm.resolve_code_task_command() == "/usr/bin/opensquilla code-task"
        cm._reset_resolution_cache()

    def test_none_when_nothing_runs(self, monkeypatch, tmp_path):
        from opensquilla.engine.steps import coding_mode as cm
        cm._reset_resolution_cache()
        monkeypatch.setattr(cm.sys, "executable", str(tmp_path / "python"))
        monkeypatch.setattr(cm.shutil, "which", lambda name: None)
        monkeypatch.setattr(cm, "_runs_code_task", lambda argv: False)
        assert cm.resolve_code_task_command() is None
        cm._reset_resolution_cache()

    def test_directive_uses_resolved_command_not_bare(self, monkeypatch):
        from opensquilla.engine.steps import coding_mode as cm
        monkeypatch.setattr(
            cm, "resolve_code_task_command",
            lambda: "/opt/env/bin/python -P -m opensquilla.cli.main code-task",
        )
        d = cm._build_coding_mode_directive()
        assert "/opt/env/bin/python -P -m opensquilla.cli.main code-task solve --repo" in d
        low = d.lower()
        assert "pip install" in low and "do not" in low
        assert "stop and report" in low

    def test_directive_fail_loud_when_unavailable(self, monkeypatch):
        from opensquilla.engine.steps import coding_mode as cm
        monkeypatch.setattr(cm, "resolve_code_task_command", lambda: None)
        d = cm._build_coding_mode_directive()
        assert "UNAVAILABLE" in d
        low = d.lower()
        assert "hand-edit" in low and "pip install" in low
        assert "stop and tell the user" in low