"""The glyph CLI layout (``display.cli_layout: modern``): scrollback rows never depend on the
terminal width, and the status line renders under the composer instead of above it."""
import re

import pytest


def _plain(s: str) -> str:
    return re.sub(r"\x1b\[[0-9;]*m", "", s)


def _run_turn(monkeypatch, width: int, *, modern: bool) -> list[str]:
    from cli import HermesCLI
    import cli as climod

    cli = HermesCLI.__new__(HermesCLI)
    cli._modern_layout = modern
    cli.show_reasoning, cli.reasoning_full = True, False
    cli.final_response_markdown, cli.show_timestamps = "raw", False
    cli._reset_stream_state()
    emitted: list[str] = []
    monkeypatch.setattr(climod, "_cprint", lambda s: emitted.append(_plain(s)))
    monkeypatch.setattr(climod, "_terminal_width_for_streaming", lambda: width)
    monkeypatch.setattr(HermesCLI, "_scrollback_box_width", lambda self: width)
    cli._stream_reasoning_delta("**Planning the change**\nI will read calc.py first.\n")
    cli._stream_delta("Added multiply to calc.py.\n")
    cli._flush_stream()
    return emitted


@pytest.mark.parametrize("modern", [True, False])
def test_glyph_layout_scrollback_is_width_independent(monkeypatch, modern):
    narrow, wide = _run_turn(monkeypatch, 60, modern=modern), _run_turn(monkeypatch, 120, modern=modern)
    boxed = any(ch in line for line in wide for ch in "╭╮╰╯┌┐└┘")
    if not modern:  # control: the classic layout's frames are sized to the terminal
        assert boxed and narrow != wide
        return
    assert narrow == wide and not boxed, wide
    rows = "\n".join(wide).split("\n")
    thought = [line for line in rows if line.startswith("∴")]
    assert len(thought) == 1 and "Planning the change" in thought[0], rows
    # Reasoning streams in full like classic, under a fixed-width dim bar (never re-wraps on resize)
    # and closed by the ∴ summary; the answer opens under its own bar.
    start = rows.index("**Planning the change**")
    assert rows[start - 1] == "─" * 40 and rows[start + 1] == "I will read calc.py first.", rows
    assert rows[start + 2] == thought[0], rows
    assert rows[next(i for i, r in enumerate(rows) if r.startswith("☤ Hermes")) - 1] == "─" * 40, rows
    assert any("Added multiply to calc.py." in line for line in rows)


@pytest.mark.parametrize("reasoning", [
    "scripted reasoning about gamma zeta-reason",
    # Longer than the 72-char title cap: a shortened title would still repeat it.
    "scripted reasoning about gamma zeta-reason that keeps going well past the title length cap here",
])
def test_one_line_reasoning_is_shown_once(monkeypatch, reasoning):
    """Reasoning streams above its ∴ summary, so a one-sentence block must not reappear as the title."""
    from cli import HermesCLI
    import cli as climod

    cli = HermesCLI.__new__(HermesCLI)
    cli._modern_layout, cli.show_reasoning, cli.reasoning_full = True, True, False
    cli.final_response_markdown, cli.show_timestamps = "raw", False
    cli._reset_stream_state()
    emitted: list[str] = []
    monkeypatch.setattr(climod, "_cprint", lambda s: emitted.append(_plain(s)))
    monkeypatch.setattr(climod, "_terminal_width_for_streaming", lambda: 100)
    monkeypatch.setattr(HermesCLI, "_scrollback_box_width", lambda self: 100)
    cli._stream_reasoning_delta(reasoning)
    cli._stream_delta("GAMMA answered.\n")
    cli._flush_stream()

    rows = "\n".join(emitted).split("\n")
    assert sum(row.count(reasoning) for row in rows) == 1, emitted
    thought = [row for row in rows if row.startswith("∴")]
    assert len(thought) == 1 and "·" not in thought[0], thought


@pytest.mark.parametrize("modern", [True, False])
def test_status_line_sits_under_the_composer_only_in_the_glyph_layout(modern):
    from cli import HermesCLI

    cli = HermesCLI.__new__(HermesCLI)
    cli._modern_layout = modern
    names = ("sudo_widget", "secret_widget", "approval_widget", "clarify_widget", "spacer", "status_bar",
             "input_rule_top", "image_bar", "input_area", "input_rule_bot", "voice_status_bar", "completions_menu")
    order = cli._build_tui_layout_children(**{name: name for name in names})
    if modern:
        assert order.index("status_bar") > order.index("input_rule_bot")
        assert order[-1] == "status_bar"
    else:
        assert order.index("status_bar") < order.index("input_rule_top")


def test_panel_rows_never_carry_a_newline():
    """A multi-line command (heredoc) in the approval panel wraps line by line, so no row breaks
    the panel's right border."""
    from cli import _wrap_panel_text_keep_ws

    rows = _wrap_panel_text_keep_ws("python3 - <<'PY'\nprint(sum(range(10)))\nPY", 30)
    assert rows == ["python3 - <<'PY'", "print(sum(range(10)))", "PY"]


@pytest.mark.parametrize("display, modern, busy", [
    ({}, True, "interrupt"),
    ({"cli_layout": "classic"}, False, "interrupt"),
    ({"busy_input_mode": "queue"}, True, "queue"),
    ({"cli_layout": "classic", "busy_input_mode": "steer"}, False, "steer"),
])
def test_layout_and_busy_default_through_the_config_loader(tmp_path, monkeypatch, display, modern, busy):
    import hermes_yaml as yaml
    import cli
    from hermes_cli.cli_modern_layout import busy_input_mode_from_config, layout_from_config

    home = tmp_path / ".hermes"
    home.mkdir()
    monkeypatch.setenv("HERMES_HOME", str(home))
    monkeypatch.setattr(cli, "_hermes_home", home)
    (home / "config.yaml").write_text(yaml.safe_dump({"display": display} if display else {"model": {}}))
    loaded = cli.load_cli_config()["display"]
    assert layout_from_config(loaded) is modern
    assert busy_input_mode_from_config(loaded) == busy


def test_status_line_keeps_every_classic_status_bar_field(monkeypatch):
    """The glyph footer renders the classic bar's segments: nothing (tps, cache, latency, context
    detail, duration...) is dropped by a layout-private default subset."""
    from cli import HermesCLI

    cli = HermesCLI.__new__(HermesCLI)
    cli._modern_layout, cli._status_bar_visible = True, True
    snapshot = {"model_short": "m", "duration": "6h 43m", "context_percent": 7, "context_length": 1_000_000,
                "context_tokens": 73_200, "context_estimated": True, "avg_latency_label": "9.0s",
                "avg_velocity_label": "61 t/s", "cache_hit_rate": 28.9, "cache_read_tokens": 1, "prompt_tokens": 1,
                "active_background_subagents": 3, "prompt_elapsed": "⏱ 10s"}
    monkeypatch.setattr(HermesCLI, "_get_status_bar_snapshot", lambda self: snapshot)
    monkeypatch.setattr(HermesCLI, "_get_tui_terminal_width", lambda self: 400)
    monkeypatch.setattr(HermesCLI, "_get_status_bar_field_set", lambda self: None)
    monkeypatch.setattr(HermesCLI, "_is_session_yolo_active", lambda self: False)
    monkeypatch.setattr(HermesCLI, "_vim_mode_label", lambda self: "")
    monkeypatch.setattr(HermesCLI, "_cache_hit_rate", lambda self, snap, precision=1: (28.9, "◎ 28.9%"))
    monkeypatch.setattr("hermes_cli.cli_modern_layout.hint_pairs", lambda cli: [])
    monkeypatch.setattr("hermes_cli.cli_modern_layout._cwd_label", lambda: "~")
    line = "".join(text for _, text in cli._get_status_bar_fragments())
    for piece in ("73.2K/1M", "7%", "◎ 28.9%", "◷ 9.0s", "↑ 61 t/s", "⛓ 3", "6h 43m", "⏱ 10s"):
        assert piece in line, (piece, line)


@pytest.mark.parametrize("prompt", ["_connection_state", "_secret_state", "_sudo_state", "_clarify_state"])
def test_tab_never_queues_what_a_prompt_owns(prompt):
    """A connection form's masked field (or any prompt) owns the composer while a turn runs: Tab must
    not queue its text as a chat message, which would print and save a secret in plain text."""
    from types import SimpleNamespace
    from prompt_toolkit.application import Application
    from prompt_toolkit.application.current import set_app
    from prompt_toolkit.buffer import Buffer
    from prompt_toolkit.key_binding import KeyBindings
    from prompt_toolkit.keys import Keys
    from prompt_toolkit.layout import BufferControl, Layout, Window
    from hermes_cli.cli_modern_layout import modern_input_rules

    cli = SimpleNamespace(_agent_running=True, _tui_input_rule_height=lambda pos: 1)
    kb = KeyBindings()
    modern_input_rules(cli, kb)
    tab = next(b for b in kb.bindings if b.keys == (Keys.ControlI,))
    buf = Buffer(document=None)
    buf.text = "REVIEW_CANARY_NOT_A_CREDENTIAL"
    app = Application(layout=Layout(Window(BufferControl(buffer=buf))))
    with set_app(app):
        assert tab.filter()  # control: a plain busy composer does queue on Tab
        setattr(cli, prompt, {"phase": "form"})
        assert not tab.filter(), prompt


def test_long_user_message_soft_wraps_so_a_resize_reflows_it(monkeypatch):
    """The glyph layout's echo of a long prompt is one logical line per source line: the terminal
    wraps it, so widening the window re-flows it instead of keeping old-width breaks."""
    from cli import HermesCLI
    import cli as climod
    import shutil

    cli = HermesCLI.__new__(HermesCLI)
    cli._modern_layout, cli.show_timestamps = True, False
    long_line = "word " * 60
    for text in (long_line.strip(), f"{long_line.strip()}\nsecond line"):
        out = {}
        for width in (60, 140):
            emitted: list[str] = []
            monkeypatch.setattr(climod, "_cprint", lambda s: emitted.append(_plain(s)))
            monkeypatch.setattr(shutil, "get_terminal_size", lambda *_a, w=width: __import__("os").terminal_size((w, 40)))
            cli._print_user_message_preview(text)
            out[width] = [line for line in "\n".join(emitted).split("\n") if line.strip()]
        assert out[60] == out[140], out
        assert any(line.rstrip().endswith("word") and line.count("word") == 60 for line in out[60]), out[60]


def test_tool_rows_keep_the_classic_tool_emoji():
    """Each finished tool row leads with the same emoji the classic ``┊`` row shows (📖 read, 💻
    terminal…); a failed entry swaps it for the red ✗ so failures stay obvious."""
    from agent.display import get_cute_tool_message
    from hermes_cli.cli_modern_layout import tool_row

    # clarify has no dedicated renderer: both layouts take its registered emoji from one source.
    for name, args in (("read_file", {"path": "/etc/hostname"}), ("terminal", {"command": "echo ok"}),
                       ("execute_code", {"code": "import math"}), ("clarify", {"question": "Which?"})):
        classic_emoji = get_cute_tool_message(name, args, 0.2).split()[1]
        assert _plain(tool_row(name, args, 0.2)).startswith(classic_emoji + " "), (name, classic_emoji)
    failed = _plain(tool_row("terminal", {"command": "false"}, 0.2, result='{"exit_code": 1, "output": ""}'))
    assert failed.startswith("✗ ") and "[exit 1]" in failed, failed


def test_refused_skill_write_reads_neutral_not_failed():
    """A skill_manage write the agent will re-plan (size cap, stale old_string) keeps the tool's own
    emoji and a dim reason: no red ✗ for the agent's routine retry loop."""
    from agent.display import get_tool_emoji
    from hermes_cli.cli_modern_layout import _RED, tool_row

    refused = ('{"success": false, "error": "operations[0] (patch on \'hermes-agent-dev\') failed: '
               'SKILL.md content is 100,193 characters (limit: 100,000).", '
               '"file_preview": "Never ignore a ROLLBACK FAILED note."}')
    row = tool_row("skill_manage", {"operations": [{"action": "patch", "name": "hermes-agent-dev"}]}, 1.1, refused)
    assert _plain(row).startswith(get_tool_emoji("skill_manage") + " "), row
    assert "[operations[0]" in _plain(row) and _RED not in row, row
    # A failed rollback left partial changes on disk: that one stays a red failure.
    broken = refused.replace('(limit: 100,000)."', '(limit: 100,000). — batch aborted, ROLLBACK FAILED for demo."')
    assert _plain(tool_row("skill_manage", {"operations": []}, 1.1, broken)).startswith("✗ ")


def test_every_block_is_framed_by_bars_and_blank_lines(monkeypatch):
    """User message, reasoning and answer each read as: blank line, bar, content, bar, blank line.
    The blank line after a closing bar is paid by whatever prints next (a tool row, the footer)
    and never doubled when the next block opens with its own blank line + bar. Tool rows inside a
    run stay tight."""
    from cli import HermesCLI
    import cli as climod
    from hermes_cli import cli_modern_layout as layout

    out: list[str] = []
    monkeypatch.setattr(climod, "_cprint", lambda s: out.extend(_plain(s).split("\n")))
    cli = HermesCLI.__new__(HermesCLI)
    cli._modern_layout, cli.show_timestamps = True, False
    bar = "─" * 40

    cli._print_user_message_preview("read the hostname")
    for row in layout.thought_rows(2.0, "Plan the read.", full=True):
        climod._cprint(row)
    climod._cprint(layout.completed_tool_line(cli, "read_file", {"path": "/etc/hostname"}, 0.2))
    climod._cprint(layout.completed_tool_line(cli, "terminal", {"command": "echo hi"}, 0.1))
    climod._cprint(layout.answer_label())
    climod._cprint("It is LINUX.")
    climod._cprint(layout.closing_separator(True))
    climod._cprint(layout.turn_footer("1.0s"))

    rows = [r.rstrip() for r in out]
    start = rows.index("❯ read the hostname") - 1
    got = ["BAR" if r == bar else ("" if not r else r.split()[0]) for r in rows[start - 1:]]
    assert got == ["", "BAR", "❯", "BAR",          # user message
                   "", "BAR", "Plan", "∴", "BAR",  # reasoning
                   "", "📖", "💻",                  # tool rows, tight
                   "", "BAR", "☤", "It", "BAR",    # answer
                   "", "─"], got                   # footer