from contextlib import nullcontext
from io import StringIO
from unittest.mock import AsyncMock, MagicMock, call, patch

import pytest
from prompt_toolkit.formatted_text import HTML

from nanobot.cli import commands
from nanobot.cli import stream as stream_mod


@pytest.fixture
def mock_prompt_session():
    """Mock the global prompt session."""
    mock_session = MagicMock()
    mock_session.prompt_async = AsyncMock()
    with patch("nanobot.cli.commands._PROMPT_SESSION", mock_session), \
         patch("nanobot.cli.commands.patch_stdout"):
        yield mock_session


@pytest.mark.asyncio
async def test_read_interactive_input_async_returns_input(mock_prompt_session):
    """Test that _read_interactive_input_async returns the user input from prompt_session."""
    mock_prompt_session.prompt_async.return_value = "hello world"

    result = await commands._read_interactive_input_async()

    assert result == "hello world"
    mock_prompt_session.prompt_async.assert_called_once()
    args, _ = mock_prompt_session.prompt_async.call_args
    assert isinstance(args[0], HTML)  # Verify HTML prompt is used


@pytest.mark.asyncio
async def test_read_interactive_input_async_handles_eof(mock_prompt_session):
    """Test that EOFError converts to KeyboardInterrupt."""
    mock_prompt_session.prompt_async.side_effect = EOFError()

    with pytest.raises(KeyboardInterrupt):
        await commands._read_interactive_input_async()


def test_init_prompt_session_creates_session():
    """Test that _init_prompt_session initializes the global session."""
    # Ensure global is None before test
    commands._PROMPT_SESSION = None

    with patch("nanobot.cli.commands.PromptSession") as mock_session_cls, \
         patch("nanobot.cli.commands.FileHistory"), \
         patch("pathlib.Path.home") as mock_home:

        mock_home.return_value = MagicMock()

        commands._init_prompt_session()

        assert commands._PROMPT_SESSION is not None
        mock_session_cls.assert_called_once()
        _, kwargs = mock_session_cls.call_args
        # Buffer is multiline-capable so Alt+Enter can insert newlines;
        # Enter-to-submit is restored via custom key bindings.
        assert kwargs["multiline"] is True
        assert kwargs["enable_open_in_editor"] is False
        assert kwargs.get("key_bindings") is not None


def test_cli_key_bindings_enter_submits_and_alt_enter_newlines():
    """Enter submits the buffer; Alt+Enter inserts a newline."""
    from prompt_toolkit.keys import Keys

    kb = commands._build_cli_key_bindings()

    def _keys(binding):
        return tuple(getattr(k, "value", k) for k in binding.keys)

    bound = {_keys(b): b for b in kb.bindings}

    # Enter -> submit
    enter = bound[(Keys.Enter.value,)]
    buf = MagicMock()
    enter.call(MagicMock(current_buffer=buf))
    buf.validate_and_handle.assert_called_once()
    buf.insert_text.assert_not_called()

    # Alt+Enter (escape, enter) -> newline
    alt_enter = bound[(Keys.Escape.value, Keys.Enter.value)]
    buf = MagicMock()
    alt_enter.call(MagicMock(current_buffer=buf))
    buf.insert_text.assert_called_once_with("\n")


@pytest.mark.asyncio
async def test_raw_lf_enter_still_submits_like_wsl_terminals():
    """A raw LF byte (\\x0a) is what some terminals -- e.g. WSL -- send for a
    plain Enter keypress. It must submit the buffer, not insert a newline;
    a mock buffer can't catch a key binding shadowing prompt_toolkit's own
    default \\n-as-\\r handling, so this drives a real PromptSession/parser.
    """
    from prompt_toolkit.application import create_app_session
    from prompt_toolkit.input import create_pipe_input
    from prompt_toolkit.output import DummyOutput

    with create_pipe_input() as pipe_input:
        with create_app_session(input=pipe_input, output=DummyOutput()):
            commands._init_prompt_session()
            session = commands._PROMPT_SESSION
            pipe_input.send_text("hello\x0aworld\r")
            result = await session.prompt_async("> ")

    assert result == "hello"


@pytest.mark.asyncio
async def test_alt_enter_inserts_newline_on_lf_terminals():
    """LF-as-Enter terminals send Alt+Enter as ESC + LF, which needs its own binding."""
    from prompt_toolkit.application import create_app_session
    from prompt_toolkit.input import create_pipe_input
    from prompt_toolkit.output import DummyOutput

    with create_pipe_input() as pipe_input:
        with create_app_session(input=pipe_input, output=DummyOutput()):
            commands._init_prompt_session()
            session = commands._PROMPT_SESSION
            pipe_input.send_text("foo\x1b\x0abar\r")
            result = await session.prompt_async("> ")

    assert result == "foo\nbar"


@pytest.mark.asyncio
async def test_csi_u_shift_enter_inserts_newline_not_raw_escape():
    """CSI-u Shift+Enter inserts a newline instead of raw escape bytes."""
    from prompt_toolkit.application import create_app_session
    from prompt_toolkit.input import create_pipe_input
    from prompt_toolkit.output import DummyOutput

    with create_pipe_input() as pipe_input:
        with create_app_session(input=pipe_input, output=DummyOutput()):
            commands._init_prompt_session()
            session = commands._PROMPT_SESSION
            pipe_input.send_text("foo\x1b[13;2ubar\r")
            result = await session.prompt_async("> ")

    # A newline is inserted and no raw escape bytes leak into the result.
    assert result == "foo\nbar"


def test_thinking_spinner_pause_stops_and_restarts():
    """Pause should stop the active spinner and restart it afterward."""
    spinner = MagicMock()
    mock_console = MagicMock()
    mock_console.status.return_value = spinner

    thinking = stream_mod.ThinkingSpinner(console=mock_console)
    with thinking:
        with thinking.pause():
            pass

    assert spinner.method_calls == [
        call.start(),
        call.stop(),
        call.start(),
        call.stop(),
    ]


def test_print_cli_progress_line_pauses_spinner_before_printing():
    """CLI progress output should pause spinner to avoid garbled lines."""
    order: list[str] = []
    spinner = MagicMock()
    spinner.start.side_effect = lambda: order.append("start")
    spinner.stop.side_effect = lambda: order.append("stop")
    mock_console = MagicMock()
    mock_console.status.return_value = spinner

    with patch.object(commands.console, "print", side_effect=lambda *_args, **_kwargs: order.append("print")):
        thinking = stream_mod.ThinkingSpinner(console=mock_console)
        with thinking:
            commands._print_cli_progress_line("tool running", thinking)

    assert order == ["start", "stop", "print", "start", "stop"]


def test_thinking_spinner_clears_status_line_when_paused():
    """Stopping the spinner should erase its transient line before output."""
    stream = StringIO()
    stream.isatty = lambda: True  # type: ignore[method-assign]
    mock_console = MagicMock()
    mock_console.file = stream
    spinner = MagicMock()
    mock_console.status.return_value = spinner

    thinking = stream_mod.ThinkingSpinner(console=mock_console)
    with thinking:
        with thinking.pause():
            pass

    assert "\r\x1b[2K" in stream.getvalue()


def test_stream_renderer_stops_spinner_even_after_header_printed():
    """A later answer delta must stop the spinner even when header already exists."""
    stream = StringIO()
    stream.isatty = lambda: True  # type: ignore[method-assign]
    mock_console = MagicMock()
    mock_console.file = stream
    spinner = MagicMock()
    mock_console.status.return_value = spinner

    with patch.object(stream_mod, "_make_console", return_value=mock_console):
        renderer = stream_mod.StreamRenderer(show_spinner=True)
        renderer._header_printed = True
        renderer.ensure_header()

    spinner.stop.assert_called_once()
    assert "\r\x1b[2K" in stream.getvalue()


def test_print_cli_progress_line_opens_renderer_header_before_trace():
    """Trace lines should appear under the assistant header, not under You."""
    order: list[str] = []
    renderer = MagicMock()
    renderer.console.print.side_effect = lambda *_args, **_kwargs: order.append("print")
    renderer.ensure_header.side_effect = lambda: order.append("header")
    renderer.pause_spinner.return_value = nullcontext()

    commands._print_cli_progress_line("tool running", None, renderer)

    assert order == ["header", "print"]


def test_print_cli_progress_line_stops_live_before_trace():
    """A trace line should not leak the current transient Live frame."""
    mock_live = MagicMock()
    renderer = stream_mod.StreamRenderer(show_spinner=False)
    renderer._live = mock_live

    commands._print_cli_progress_line("tool running", None, renderer)

    mock_live.stop.assert_called_once()
    assert renderer._live is None


@pytest.mark.asyncio
async def test_print_interactive_progress_line_pauses_spinner_before_printing():
    """Interactive progress output should also pause spinner cleanly."""
    order: list[str] = []
    spinner = MagicMock()
    spinner.start.side_effect = lambda: order.append("start")
    spinner.stop.side_effect = lambda: order.append("stop")
    mock_console = MagicMock()
    mock_console.status.return_value = spinner

    async def fake_print(_text: str) -> None:
        order.append("print")

    with patch("nanobot.cli.commands._print_interactive_line", side_effect=fake_print):
        thinking = stream_mod.ThinkingSpinner(console=mock_console)
        with thinking:
            await commands._print_interactive_progress_line("tool running", thinking)

    assert order == ["start", "stop", "print", "start", "stop"]


def test_response_renderable_uses_text_for_explicit_plain_rendering():
    status = (
        "🐈 nanobot v0.1.4.post5\n"
        "🧠 Model: MiniMax-M2.7\n"
        "📊 Tokens: 20639 in / 29 out"
    )

    renderable = commands._response_renderable(
        status,
        render_markdown=True,
        metadata={"render_as": "text"},
    )

    assert renderable.__class__.__name__ == "Text"


def test_response_renderable_preserves_normal_markdown_rendering():
    renderable = commands._response_renderable("**bold**", render_markdown=True)

    assert renderable.__class__.__name__ == "Markdown"


def test_response_renderable_without_metadata_keeps_markdown_path():
    help_text = "🐈 nanobot commands:\n/status — Show bot status\n/help — Show available commands"

    renderable = commands._response_renderable(help_text, render_markdown=True)

    assert renderable.__class__.__name__ == "Markdown"


def test_stream_renderer_stop_for_input_stops_spinner():
    """stop_for_input should stop the active spinner to avoid prompt_toolkit conflicts."""
    spinner = MagicMock()
    mock_console = MagicMock()
    mock_console.status.return_value = spinner

    # Create renderer with mocked console
    with patch.object(stream_mod, "_make_console", return_value=mock_console):
        renderer = stream_mod.StreamRenderer(show_spinner=True)

        # Verify spinner started
        spinner.start.assert_called_once()

        # Stop for input
        renderer.stop_for_input()

        # Verify spinner stopped
        spinner.stop.assert_called_once()


@pytest.mark.asyncio
async def test_on_end_writes_final_content_to_stdout_after_stopping_live():
    """on_end should stop Live (transient erases it) then print final content to stdout."""
    mock_live = MagicMock()
    mock_console = MagicMock()
    mock_console.capture.return_value.__enter__ = MagicMock(
        return_value=MagicMock(get=lambda: "final output\n")
    )
    mock_console.capture.return_value.__exit__ = MagicMock(return_value=False)

    with patch.object(stream_mod, "_make_console", return_value=mock_console):
        renderer = stream_mod.StreamRenderer(show_spinner=False)
        renderer._live = mock_live
        renderer._buf = "final output"

        written: list[str] = []
        with patch("sys.stdout") as mock_stdout:
            mock_stdout.write = lambda s: written.append(s)
            mock_stdout.flush = MagicMock()
            await renderer.on_end()

    mock_live.stop.assert_called_once()
    assert renderer._live is None
    assert written == ["final output\n"]


@pytest.mark.asyncio
async def test_on_end_resuming_clears_buffer_and_restarts_spinner():
    """on_end(resuming=True) should reset state for the next iteration."""
    spinner = MagicMock()
    mock_console = MagicMock()
    mock_console.status.return_value = spinner
    mock_console.capture.return_value.__enter__ = MagicMock(
        return_value=MagicMock(get=lambda: "")
    )
    mock_console.capture.return_value.__exit__ = MagicMock(return_value=False)

    with patch.object(stream_mod, "_make_console", return_value=mock_console):
        renderer = stream_mod.StreamRenderer(show_spinner=True)
        renderer._buf = "some content"

        await renderer.on_end(resuming=True)

    assert renderer._buf == ""
    # Spinner should have been restarted (start called twice: __init__ + resuming)
    assert spinner.start.call_count == 2


def test_make_console_force_terminal_when_stdout_is_tty():
    """Console should set force_terminal=True when stdout is a TTY (rich output)."""
    import sys
    with patch.object(sys.stdout, "isatty", return_value=True):
        console = stream_mod._make_console()
        assert console._force_terminal is True


def test_make_console_force_terminal_false_when_stdout_is_not_tty():
    """Console should set force_terminal=False when stdout is not a TTY so that
    ANSI escape codes (cursor visibility, braille spinner frames) don't pollute
    piped output such as `docker exec -i` (#3265)."""
    import sys
    with patch.object(sys.stdout, "isatty", return_value=False):
        console = stream_mod._make_console()
        assert console._force_terminal is False


def test_render_interactive_ansi_force_terminal_follows_isatty():
    """Mirror of _make_console: the capture console used to produce ANSI for
    prompt_toolkit must also defer to sys.stdout.isatty(), otherwise cursor
    escapes and spinner frames leak into piped output (#3265, #3370)."""
    import sys
    captured: dict = {}

    def render_fn(c):
        captured["console"] = c

    with patch.object(sys.stdout, "isatty", return_value=True):
        commands._render_interactive_ansi(render_fn)
        assert captured["console"]._force_terminal is True

    with patch.object(sys.stdout, "isatty", return_value=False):
        commands._render_interactive_ansi(render_fn)
        assert captured["console"]._force_terminal is False