"""Unit tests for the BrowserCLI Python SDK (BrowserCLI, namespaces, Tab, Group).

These tests mock `send_command` so no live browser connection is required.
Commands live on namespace accessors: b.tabs.list(), b.dom.click(), b.groups.create(), ...
"""
import asyncio
import pytest
from unittest.mock import MagicMock, patch, call

import browser_cli
from browser_cli import AsyncBrowserCLI, BrowserCLI, BrowserCounts, Tab, Group
from browser_cli.client import BrowserNotConnected, BrowserTarget


# ── Helpers ───────────────────────────────────────────────────────────────────

TAB_DATA = {
  "id": 10,
  "windowId": 1,
  "active": True,
  "index": 3,
  "title": "Example",
  "url": "https://example.com",
  "groupId": None,
}

GROUP_DATA = {
  "id": 42,
  "title": "Work",
  "color": "blue",
  "collapsed": False,
  "tabCount": 3,
}

def tab_close_args(tab_id: int):
  return {"tabId": tab_id, "tabIds": None, "inactive": False, "duplicates": False, "gentleMode": "auto"}

def group_close_args(group_id: int):
  return {"groupId": group_id, "gentleMode": "auto"}

@pytest.fixture()
def mock_send():
  """Patch send_command for the duration of one test.

  BrowserCLI._cmd calls the `send_command` name that was imported into
  browser_cli/__init__.py, so we must patch it there, not in the client module.
  """
  with patch("browser_cli.send_command") as m, patch("browser_cli.active_browser_targets", return_value=[]):
    yield m

@pytest.fixture()
def b(mock_send):
  """A BrowserCLI instance with send_command mocked."""
  return BrowserCLI()

@pytest.fixture()
def b_profile(mock_send):
  """A BrowserCLI instance targeting a specific profile."""
  return BrowserCLI(browser="brave")

# ── BrowserCLI construction ───────────────────────────────────────────────────

class TestBrowserCLIInit:
  def test_default_browser_is_none(self):
    b = BrowserCLI()
    assert b._browser is None

  def test_named_browser_stored(self):
    b = BrowserCLI(browser="chrome")
    assert b._browser == "chrome"

  def test_remote_options_stored(self):
    b = BrowserCLI(browser="work", remote="host:8765", key=None)
    assert b._browser == "work"
    assert b._remote == "host:8765"

  def test_public_target_properties(self):
    b = BrowserCLI(browser="work", remote="browser-host.example:443", key="agent")
    assert b.browser == "work"
    assert b.remote == "browser-host.example:443"
    assert b.key == "agent"

  def test_tab_factory_preserves_index(self):
    tab = BrowserCLI().tab_from(TAB_DATA)
    assert tab.index == 3

  def test_tab_factory_defaults_missing_index_to_zero(self):
    data = {key: value for key, value in TAB_DATA.items() if key != "index"}
    tab = BrowserCLI().tab_from(data)
    assert tab.index == 0

  def test_namespaces_present_and_bound(self):
    b = BrowserCLI()
    for name in ("nav", "tabs", "groups", "windows", "dom", "extract",
           "page", "storage", "session", "perf", "extension", "decorators"):
      ns = getattr(b, name)
      assert ns is not None
      assert ns._c is b

  def test_raw_command_escape_hatch(self, mock_send):
    mock_send.return_value = {"ok": True}
    b = BrowserCLI(browser="work", remote="browser-host.example:443", key="agent")

    result = b.command("custom.command", {"value": 1})

    assert result == {"ok": True}
    mock_send.assert_called_once_with(
      "custom.command",
      {"value": 1},
      profile="work",
      remote="browser-host.example:443",
      key="agent",
    )

  def test_raw_command_defaults_args_to_empty_dict(self, b, mock_send):
    b.command("custom.command")
    mock_send.assert_called_once_with("custom.command", {}, profile=None, remote=None, key=None)

  def test_internal_sdk_command_decorator_keeps_method_metadata(self, b):
    assert b.nav.reload.__name__ == "reload"
    assert b.nav.reload.__doc__
    assert getattr(b.nav.reload, "_browser_cli_command") == "navigate.reload"

# ── Internal factories ────────────────────────────────────────────────────────

class TestMakeTab:
  def test_all_fields(self, b):
    tab = b.tab_from(TAB_DATA)
    assert tab.id == 10
    assert tab.window_id == 1
    assert tab.active is True
    assert tab.title == "Example"
    assert tab.url == "https://example.com"
    assert tab.group_id is None

  def test_bound_to_browser(self, b):
    tab = b.tab_from(TAB_DATA)
    assert tab._browser is b

  def test_missing_optional_fields_use_defaults(self, b):
    tab = b.tab_from({"id": 1})
    assert tab.window_id == 0
    assert tab.active is False
    assert tab.title == ""
    assert tab.url == ""
    assert tab.group_id is None

  def test_group_id_set(self, b):
    tab = b.tab_from({**TAB_DATA, "groupId": 99})
    assert tab.group_id == 99

class TestMakeGroup:
  def test_all_fields(self, b):
    group = b.group_from(GROUP_DATA)
    assert group.id == 42
    assert group.title == "Work"
    assert group.color == "blue"
    assert group.collapsed is False
    assert group.tab_count == 3

  def test_bound_to_browser(self, b):
    group = b.group_from(GROUP_DATA)
    assert group._browser is b

  def test_missing_optional_fields_use_defaults(self, b):
    group = b.group_from({"id": 5})
    assert group.title == ""
    assert group.color == ""
    assert group.collapsed is False
    assert group.tab_count == 0

# ── Navigation ────────────────────────────────────────────────────────────────

class TestNavigation:
  def test_open(self, b, mock_send):
    b.nav.open("https://example.com")
    mock_send.assert_called_once_with(
      "navigate.open",
      {"url": "https://example.com", "background": True, "focus": False, "window": None, "group": None},
      profile=None, remote=None, key=None,
    )

  def test_open_background(self, b, mock_send):
    b.nav.open("https://example.com", background=True)
    args = mock_send.call_args[0]
    assert args[1]["background"] is True

  def test_open_with_group(self, b, mock_send):
    b.nav.open("https://x.com", group="Work")
    assert mock_send.call_args[0][1]["group"] == "Work"

  def test_open_focus_is_explicit(self, b, mock_send):
    b.nav.open("https://example.com", focus=True)
    assert mock_send.call_args[0][1]["focus"] is True

  def test_tabs_open_returns_bound_tab(self, b, mock_send):
    mock_send.return_value = {"id": 123, "url": "https://example.com"}

    tab = b.tabs.open("https://example.com", background=True)

    assert tab.id == 123
    assert tab.url == "https://example.com"
    assert tab._browser is b
    mock_send.assert_called_once_with(
      "navigate.open",
      {"url": "https://example.com", "background": True, "focus": False, "window": None, "group": None},
      profile=None,
      remote=None,
      key=None,
    )

  def test_tabs_open_wait_uses_open_wait(self, b, mock_send):
    mock_send.return_value = TAB_DATA

    tab = b.tabs.open("https://example.com", wait=True, timeout=1.5)

    assert tab.id == 10
    mock_send.assert_called_once_with(
      "navigate.open_wait",
      {"url": "https://example.com", "timeout": 1500, "background": True, "focus": False, "window": None, "group": None},
      profile=None,
      remote=None,
      key=None,
    )

  def test_tabs_open_unexpected_response_raises(self, b, mock_send):
    mock_send.return_value = None
    with pytest.raises(RuntimeError, match="navigate.open returned unexpected data"):
      b.tabs.open("https://example.com")

  def test_nav_open_wait_unexpected_response_raises(self, b, mock_send):
    mock_send.return_value = None
    with pytest.raises(RuntimeError, match="navigate.open_wait returned unexpected data"):
      b.nav.open_wait("https://example.com")

  def test_reload(self, b, mock_send):
    b.nav.reload(tab_id=5)
    mock_send.assert_called_once_with("navigate.reload", {"tabId": 5}, profile=None, remote=None, key=None)

  def test_hard_reload(self, b, mock_send):
    b.nav.hard_reload(tab_id=7)
    mock_send.assert_called_once_with("navigate.hard_reload", {"tabId": 7}, profile=None, remote=None, key=None)

  def test_back(self, b, mock_send):
    b.nav.back(tab_id=3)
    mock_send.assert_called_once_with("navigate.back", {"tabId": 3}, profile=None, remote=None, key=None)

  def test_forward(self, b, mock_send):
    b.nav.forward(tab_id=3)
    mock_send.assert_called_once_with("navigate.forward", {"tabId": 3}, profile=None, remote=None, key=None)

  def test_focus(self, b, mock_send):
    b.nav.focus("github.com")
    mock_send.assert_called_once_with("navigate.focus", {"pattern": "github.com"}, profile=None, remote=None, key=None)

  def test_nav_to(self, b, mock_send):
    b.nav.to(5, "https://example.com")
    mock_send.assert_called_once_with(
      "navigate.to", {"tabId": 5, "url": "https://example.com"}, profile=None, remote=None, key=None
    )

  def test_profile_forwarded(self, b_profile, mock_send):
    b_profile.nav.reload()
    mock_send.assert_called_once_with("navigate.reload", {"tabId": None}, profile="brave", remote=None, key=None)

  def test_remote_forwarded(self, mock_send):
    b = BrowserCLI(browser="work", remote="host:8765", key=None)
    b.nav.reload()
    mock_send.assert_called_once_with("navigate.reload", {"tabId": None}, profile="work", remote="host:8765", key=None)

# ── Search ────────────────────────────────────────────────────────────────────

class TestSearch:
  def test_known_engine_builds_url(self, b, mock_send):
    b.nav.search("google", "python asyncio")
    call_args = mock_send.call_args[0]
    assert call_args[0] == "navigate.open"
    assert "python+asyncio" in call_args[1]["url"] or "python%20asyncio" in call_args[1]["url"]

  def test_unknown_engine_raises(self, b):
    with pytest.raises(ValueError, match="Unknown search engine"):
      b.nav.search("nonexistent", "query")

  def test_search_alias_ddg(self, b, mock_send):
    b.nav.search("ddg", "hello")
    url = mock_send.call_args[0][1]["url"]
    assert "duckduckgo.com" in url

  def test_search_background(self, b, mock_send):
    b.nav.search("bing", "test", background=True)
    assert mock_send.call_args[0][1]["background"] is True

# ── Extract ───────────────────────────────────────────────────────────────────

class TestExtract:
  def test_extract_markdown_default(self, b, mock_send):
    mock_send.return_value = "# Title"

    result = b.extract.markdown()

    assert result == "# Title"
    mock_send.assert_called_once_with("extract.markdown", {"selector": None}, profile=None, remote=None, key=None)

  def test_extract_markdown_selector(self, b, mock_send):
    mock_send.return_value = "## Post"

    assert b.extract.markdown("article") == "## Post"
    mock_send.assert_called_once_with("extract.markdown", {"selector": "article"}, profile=None, remote=None, key=None)

  def test_extract_links(self, b, mock_send):
    mock_send.return_value = [{"href": "https://x"}]
    assert b.extract.links() == [{"href": "https://x"}]
    mock_send.assert_called_once_with("extract.links", {}, profile=None, remote=None, key=None)

  def test_extract_text_none(self, b, mock_send):
    mock_send.return_value = None
    assert b.extract.text() == ""

# ── Tabs ──────────────────────────────────────────────────────────────────────

class TestTabs:
  def test_tabs_list_returns_tab_objects(self, b, mock_send):
    mock_send.return_value = [TAB_DATA]
    tabs = b.tabs.list()
    assert len(tabs) == 1
    assert isinstance(tabs[0], Tab)
    assert tabs[0].id == 10

  def test_tabs_list_empty(self, b, mock_send):
    mock_send.return_value = []
    assert b.tabs.list() == []

  def test_tabs_list_none_response(self, b, mock_send):
    mock_send.return_value = None
    assert b.tabs.list() == []

  def test_tabs_close_returns_count(self, b, mock_send):
    mock_send.return_value = {"closed": 3}
    assert b.tabs.close() == 3

  def test_tabs_close_non_dict_response(self, b, mock_send):
    mock_send.return_value = None
    assert b.tabs.close() == 1

  def test_tabs_close_by_id(self, b, mock_send):
    mock_send.return_value = {"closed": 1}
    b.tabs.close(tab_id=10)
    mock_send.assert_called_once_with(
      "tabs.close",
      {"tabId": 10, "tabIds": None, "inactive": False, "duplicates": False, "gentleMode": "auto"},
      profile=None, remote=None, key=None,
    )

  def test_tabs_close_by_ids(self, b, mock_send):
    mock_send.return_value = {"closed": 3}
    assert b.tabs.close(tab_ids=[10, 20, 30]) == 3
    mock_send.assert_called_once_with(
      "tabs.close",
      {"tabId": None, "tabIds": [10, 20, 30], "inactive": False, "duplicates": False, "gentleMode": "auto"},
      profile=None, remote=None, key=None,
    )

  def test_tabs_close_by_ids_accepts_tab_objects(self, b, mock_send):
    tabs = [b.tab_from({**TAB_DATA, "id": 10}), b.tab_from({**TAB_DATA, "id": 20})]
    mock_send.return_value = {"closed": 2}
    assert b.tabs.close(tab_ids=tabs) == 2
    mock_send.assert_called_once_with(
      "tabs.close",
      {"tabId": None, "tabIds": [10, 20], "inactive": False, "duplicates": False, "gentleMode": "auto"},
      profile=None, remote=None, key=None,
    )

  def test_tabs_close_by_ids_chunks_large_batches(self, b, mock_send):
    mock_send.side_effect = [{"closed": 50}, {"closed": 50}, {"closed": 20}]
    assert b.tabs.close(tab_ids=range(120), gentle_mode="normal") == 120
    assert mock_send.call_args_list == [
      call(
        "tabs.close",
        {"tabId": None, "tabIds": list(range(0, 50)), "inactive": False, "duplicates": False, "gentleMode": "normal"},
        profile=None, remote=None, key=None,
      ),
      call(
        "tabs.close",
        {"tabId": None, "tabIds": list(range(50, 100)), "inactive": False, "duplicates": False, "gentleMode": "normal"},
        profile=None, remote=None, key=None,
      ),
      call(
        "tabs.close",
        {"tabId": None, "tabIds": list(range(100, 120)), "inactive": False, "duplicates": False, "gentleMode": "normal"},
        profile=None, remote=None, key=None,
      ),
    ]

  def test_tabs_move(self, b, mock_send):
    b.tabs.move(10, forward=True)
    mock_send.assert_called_once_with(
      "tabs.move",
      {"tabId": 10, "forward": True, "backward": False, "groupId": None, "windowId": None, "index": None},
      profile=None, remote=None, key=None,
    )

  def test_tabs_activate(self, b, mock_send):
    b.tabs.activate(10)
    mock_send.assert_called_once_with("tabs.active", {"tabId": 10}, profile=None, remote=None, key=None)

  def test_tabs_active_in_window(self, b, mock_send):
    mock_send.return_value = TAB_DATA
    tab = b.tabs.active_in_window(1)
    assert isinstance(tab, Tab)
    assert tab.id == 10
    mock_send.assert_called_once_with("tabs.active_in_window", {"windowId": 1}, profile=None, remote=None, key=None)

  def test_tabs_active_in_window_missing_raises(self, b, mock_send):
    mock_send.return_value = None
    with pytest.raises(RuntimeError, match="No active tab found for window 1"):
      b.tabs.active_in_window(1)

  def test_tabs_filter(self, b, mock_send):
    mock_send.return_value = [TAB_DATA]
    tabs = b.tabs.filter("example")
    assert isinstance(tabs[0], Tab)

  def test_tabs_filter_none(self, b, mock_send):
    mock_send.return_value = None
    assert b.tabs.filter("x") == []

  def test_tabs_filter_predicate(self, b, mock_send):
    mock_send.return_value = [TAB_DATA, {**TAB_DATA, "id": 11, "url": "https://youtube.com"}]
    tabs = b.tabs.filter(lambda tab: "youtube" in tab.url)
    assert [tab.id for tab in tabs] == [11]

  def test_tabs_filter_list_transformer(self, b, mock_send):
    mock_send.return_value = [TAB_DATA, {**TAB_DATA, "id": 11, "url": "https://example.com"}]
    tabs = b.tabs.filter(lambda tabs: tabs[:1])
    assert [tab.id for tab in tabs] == [10]

  def test_tabs_count(self, b, mock_send):
    mock_send.return_value = 5
    assert b.tabs.count() == 5

  def test_tabs_list_multi_browser_annotates_browser_and_binds_actions(self, b, mock_send):
    with patch(
      "browser_cli.active_browser_targets",
      return_value=[
        BrowserTarget("default", "uuid-1", "/tmp/uuid-1.sock"),
        BrowserTarget("work", "work", "/tmp/work.sock"),
      ],
    ):
      mock_send.side_effect = [
        [TAB_DATA],
        [{**TAB_DATA, "id": 11}],
        None,
      ]

      tabs = b.tabs.list()
      tabs[1].close()

    assert [tab.browser for tab in tabs] == ["uuid-1", "work"]
    assert [tab.id for tab in tabs] == [10, 11]
    assert mock_send.call_args_list == [
      call("tabs.list", {}, profile="default"),
      call("tabs.list", {}, profile="work"),
      call("tabs.close", tab_close_args(11), profile="work", remote=None, key=None),
    ]

  def test_tabs_list_remote_uses_only_requested_remote_and_binds_actions(self, mock_send):
    b = BrowserCLI(remote="host:8765", key=None)
    with patch(
      "browser_cli.active_browser_targets",
      side_effect=AssertionError("local targets should not be used for explicit remote"),
    ), patch(
      "browser_cli.remote_browser_targets",
      return_value=[BrowserTarget("work", "host:work", "", remote="host:8765")],
    ):
      mock_send.side_effect = [[TAB_DATA], None]
      tabs = b.tabs.list()
      tabs[0].close()

    assert [tab.browser for tab in tabs] == ["work"]
    assert mock_send.call_args_list == [
      call("tabs.list", {}, profile="work", remote="host:8765", key=None),
      call("tabs.close", tab_close_args(10), profile="work", remote="host:8765", key=None),
    ]

  def test_tabs_list_remote_bound_actions_preserve_key(self, mock_send):
    b = BrowserCLI(remote="browser-host.example", key="agent")
    with patch(
      "browser_cli.remote_browser_targets",
      return_value=[BrowserTarget("work", "browser-host.example:work", "", remote="browser-host.example")],
    ):
      mock_send.side_effect = [[TAB_DATA], None]
      tabs = b.tabs.list()
      tabs[0].close()

    assert mock_send.call_args_list == [
      call("tabs.list", {}, profile="work", remote="browser-host.example", key="agent"),
      call("tabs.close", tab_close_args(10), profile="work", remote="browser-host.example", key="agent"),
    ]

  def test_tabs_list_browser_host_alias_fans_out_to_remote_targets(self, mock_send):
    b = BrowserCLI(browser="browser-host.example", key="agent")
    with patch(
      "browser_cli.remote_targets_for_alias",
      return_value=[
        BrowserTarget("main", "browser-host.example:main", "", remote="browser-host.example:8765", browser_name="Chrome"),
        BrowserTarget("work", "browser-host.example:work", "", remote="browser-host.example:8765", browser_name="Firefox"),
      ],
    ):
      mock_send.side_effect = [[TAB_DATA], [{**TAB_DATA, "id": 11}], None]
      tabs = b.tabs.list()
      tabs[1].close()

    assert [tab.browser for tab in tabs] == ["main", "work"]
    assert [tab.browser_name for tab in tabs] == ["Chrome", "Firefox"]
    assert [tab.browser_group for tab in tabs] == [None, None]
    assert mock_send.call_args_list == [
      call("tabs.list", {}, profile="main", remote="browser-host.example:8765", key="agent"),
      call("tabs.list", {}, profile="work", remote="browser-host.example:8765", key="agent"),
      call("tabs.close", tab_close_args(11), profile="work", remote="browser-host.example:8765", key="agent"),
    ]

  def test_tabs_active_returns_active_tab(self, b, mock_send):
    mock_send.side_effect = [[TAB_DATA], TAB_DATA]

    tabs = b.tabs.list()
    active = b.tabs.active()

    assert tabs[0].id == 10
    assert active.id == 10
    assert mock_send.call_args_list == [
      call("tabs.list", {}, profile=None, remote=None, key=None),
      call("tabs.status", {"tabId": None}, profile=None, remote=None, key=None),
    ]

  def test_tabs_get_first_and_close_helpers(self, b, mock_send):
    mock_send.side_effect = [TAB_DATA, [TAB_DATA], [], {"closed": 1}, {"closed": 1}]

    tab = b.tabs.get(10)
    found = b.tabs.first("Example")
    missing = b.tabs.first("Missing")
    closed_by_object = b.tabs.close(tab.id)
    closed_by_id = b.tabs.close(10)

    assert tab.id == 10
    assert found and found.id == 10
    assert missing is None
    assert closed_by_object == 1
    assert closed_by_id == 1
    assert mock_send.call_args_list == [
      call("tabs.status", {"tabId": 10}, profile=None, remote=None, key=None),
      call("tabs.query", {"search": "Example"}, profile=None, remote=None, key=None),
      call("tabs.query", {"search": "Missing"}, profile=None, remote=None, key=None),
      call("tabs.close", {"tabId": 10, "tabIds": None, "inactive": False, "duplicates": False, "gentleMode": "auto"}, profile=None, remote=None, key=None),
      call("tabs.close", {"tabId": 10, "tabIds": None, "inactive": False, "duplicates": False, "gentleMode": "auto"}, profile=None, remote=None, key=None),
    ]

  def test_tabs_count_multi_browser_returns_browser_counts(self, b, mock_send):
    with patch(
      "browser_cli.active_browser_targets",
      return_value=[
        BrowserTarget("default", "uuid-1", "/tmp/uuid-1.sock"),
        BrowserTarget("work", "work", "/tmp/work.sock"),
      ],
    ):
      mock_send.side_effect = [3, 4]
      result = b.tabs.count("github")

    assert result == BrowserCounts(
      total=7,
      by_browser={"uuid-1": 3, "work": 4},
      browser_groups={"uuid-1": "local", "work": "local"},
    )
    assert mock_send.call_args_list == [
      call("tabs.count", {"pattern": "github"}, profile="default"),
      call("tabs.count", {"pattern": "github"}, profile="work"),
    ]

  def test_tabs_count_multi_browser_keeps_remote_display_groups(self, b, mock_send):
    with patch(
      "browser_cli.active_browser_targets",
      return_value=[
        BrowserTarget("main", "browser-host.example:main", "", remote="browser-host.example:8765", display_group="browser-host.example"),
        BrowserTarget("work", "browser-host.example:work", "", remote="browser-host.example:8765", display_group="browser-host.example"),
      ],
    ):
      mock_send.side_effect = [1, 2]
      result = b.tabs.count()

    assert result == BrowserCounts(
      total=3,
      by_browser={"browser-host.example:main": 1, "browser-host.example:work": 2},
      browser_groups={"browser-host.example:main": "browser-host.example", "browser-host.example:work": "browser-host.example"},
    )
    assert mock_send.call_args_list == [
      call("tabs.count", {"pattern": None}, profile="main", remote="browser-host.example:8765", key=None),
      call("tabs.count", {"pattern": None}, profile="work", remote="browser-host.example:8765", key=None),
    ]

  def test_tabs_query(self, b, mock_send):
    mock_send.return_value = [TAB_DATA]
    result = b.tabs.query("example")
    assert isinstance(result[0], Tab)
    mock_send.assert_called_once_with("tabs.query", {"search": "example"}, profile=None, remote=None, key=None)

  def test_tabs_html(self, b, mock_send):
    mock_send.return_value = "<html></html>"
    assert b.tabs.html(10) == "<html></html>"

  def test_tabs_html_none(self, b, mock_send):
    mock_send.return_value = None
    assert b.tabs.html() == ""

  def test_tabs_dedupe(self, b, mock_send):
    mock_send.return_value = {"closed": 2}
    assert b.tabs.dedupe() == 2

  def test_tabs_dedupe_non_dict(self, b, mock_send):
    mock_send.return_value = None
    assert b.tabs.dedupe() == 0

  def test_tabs_sort(self, b, mock_send):
    b.tabs.sort(by="title")
    mock_send.assert_called_once_with("tabs.sort", {"by": "title", "gentleMode": "auto"}, profile=None, remote=None, key=None)

  def test_tabs_merge_windows(self, b, mock_send):
    mock_send.return_value = {"moved": 4}
    assert b.tabs.merge_windows() == 4

  def test_tabs_close_inactive(self, b, mock_send):
    mock_send.return_value = {"closed": 2}
    assert b.tabs.close_inactive() == 2

  def test_tabs_close_duplicates(self, b, mock_send):
    mock_send.return_value = {"closed": 1}
    assert b.tabs.close_duplicates() == 1

  def test_tabs_mute_pin_return_tab_id(self, b, mock_send):
    mock_send.side_effect = [{"tabId": 10}, None]
    assert b.tabs.mute(10) == 10
    assert b.tabs.pin() == 0
    assert mock_send.call_args_list == [
      call("tabs.mute", {"tabId": 10}, profile=None, remote=None, key=None),
      call("tabs.pin", {"tabId": None}, profile=None, remote=None, key=None),
    ]

  def test_tabs_screenshot(self, b, mock_send):
    mock_send.return_value = {"dataUrl": "data:image/png;base64,abc"}
    assert b.tabs.screenshot(10) == "data:image/png;base64,abc"
    mock_send.assert_called_once_with(
      "tabs.screenshot", {"tabId": 10, "format": "png", "quality": None}, profile=None, remote=None, key=None
    )

# ── Groups ────────────────────────────────────────────────────────────────────

class TestGroups:
  def test_group_list_returns_group_objects(self, b, mock_send):
    mock_send.return_value = [GROUP_DATA]
    groups = b.groups.list()
    assert len(groups) == 1
    assert isinstance(groups[0], Group)
    assert groups[0].id == 42

  def test_group_list_empty(self, b, mock_send):
    mock_send.return_value = None
    assert b.groups.list() == []

  def test_group_tabs(self, b, mock_send):
    mock_send.return_value = [TAB_DATA]
    tabs = b.groups.tabs(42)
    assert isinstance(tabs[0], Tab)
    mock_send.assert_called_once_with("group.tabs", {"groupId": 42}, profile=None, remote=None, key=None)

  def test_group_count(self, b, mock_send):
    mock_send.return_value = 7
    assert b.groups.count() == 7

  def test_group_list_multi_browser_annotates_browser_and_binds_actions(self, b, mock_send):
    with patch(
      "browser_cli.active_browser_targets",
      return_value=[
        BrowserTarget("default", "uuid-1", "/tmp/uuid-1.sock"),
        BrowserTarget("work", "work", "/tmp/work.sock"),
      ],
    ):
      mock_send.side_effect = [
        [GROUP_DATA],
        [{**GROUP_DATA, "id": 99, "title": "Later"}],
        None,
      ]

      groups = b.groups.list()
      groups[1].close()

    assert [group.browser for group in groups] == ["uuid-1", "work"]
    assert [group.id for group in groups] == [42, 99]
    assert mock_send.call_args_list == [
      call("group.list", {}, profile="default"),
      call("group.list", {}, profile="work"),
      call("group.close", group_close_args(99), profile="work", remote=None, key=None),
    ]

  def test_group_list_remote_uses_only_requested_remote_and_binds_actions(self, mock_send):
    b = BrowserCLI(remote="host:8765", key=None)
    with patch(
      "browser_cli.active_browser_targets",
      side_effect=AssertionError("local targets should not be used for explicit remote"),
    ), patch(
      "browser_cli.remote_browser_targets",
      return_value=[BrowserTarget("work", "host:work", "", remote="host:8765")],
    ):
      mock_send.side_effect = [[GROUP_DATA], None]
      groups = b.groups.list()
      groups[0].close()

    assert [group.browser for group in groups] == ["work"]
    assert mock_send.call_args_list == [
      call("group.list", {}, profile="work", remote="host:8765", key=None),
      call("group.close", group_close_args(42), profile="work", remote="host:8765", key=None),
    ]

  def test_group_list_remote_bound_actions_preserve_key(self, mock_send):
    b = BrowserCLI(remote="browser-host.example", key="agent")
    with patch(
      "browser_cli.remote_browser_targets",
      return_value=[BrowserTarget("work", "browser-host.example:work", "", remote="browser-host.example")],
    ):
      mock_send.side_effect = [[GROUP_DATA], None]
      groups = b.groups.list()
      groups[0].close()

    assert mock_send.call_args_list == [
      call("group.list", {}, profile="work", remote="browser-host.example", key="agent"),
      call("group.close", group_close_args(42), profile="work", remote="browser-host.example", key="agent"),
    ]

  def test_group_count_multi_browser_returns_browser_counts(self, b, mock_send):
    with patch(
      "browser_cli.active_browser_targets",
      return_value=[
        BrowserTarget("default", "uuid-1", "/tmp/uuid-1.sock"),
        BrowserTarget("work", "work", "/tmp/work.sock"),
      ],
    ):
      mock_send.side_effect = [2, 5]
      result = b.groups.count()

    assert result == BrowserCounts(
      total=7,
      by_browser={"uuid-1": 2, "work": 5},
      browser_groups={"uuid-1": "local", "work": "local"},
    )

  def test_group_query(self, b, mock_send):
    mock_send.return_value = [GROUP_DATA]
    groups = b.groups.query("Work")
    assert isinstance(groups[0], Group)
    mock_send.assert_called_once_with("group.query", {"search": "Work"}, profile=None, remote=None, key=None)

  def test_group_close(self, b, mock_send):
    b.groups.close(42)
    mock_send.assert_called_once_with("group.close", {"groupId": 42, "gentleMode": "auto"}, profile=None, remote=None, key=None)

  def test_group_create_dict_response(self, b, mock_send):
    mock_send.return_value = GROUP_DATA
    group = b.groups.create("Work")
    assert isinstance(group, Group)
    assert group.id == 42
    assert group.title == "Work"

  def test_group_create_int_response(self, b, mock_send):
    mock_send.return_value = 99
    group = b.groups.create("Misc")
    assert group.id == 99
    assert group.title == "Misc"

  def test_group_add_tab(self, b, mock_send):
    mock_send.return_value = {"tabId": 55}
    tab_id = b.groups.add_tab(42, "https://example.com")
    assert tab_id == 55
    mock_send.assert_called_once_with(
      "group.add_tab", {"group": "42", "url": "https://example.com"}, profile=None, remote=None, key=None
    )

  def test_group_add_tab_non_dict_response(self, b, mock_send):
    mock_send.return_value = 55
    assert b.groups.add_tab(42) == 55

  def test_group_move_forward(self, b, mock_send):
    b.groups.move(42, forward=True)
    mock_send.assert_called_once_with(
      "group.move", {"group": "42", "forward": True, "backward": False}, profile=None, remote=None, key=None
    )

class TestWindows:
  def test_windows_list_multi_browser_adds_browser(self, b, mock_send):
    with patch(
      "browser_cli.active_browser_targets",
      return_value=[
        BrowserTarget("default", "uuid-1", "/tmp/uuid-1.sock"),
        BrowserTarget("work", "work", "/tmp/work.sock"),
      ],
    ):
      mock_send.side_effect = [
        [{"id": 1, "tabCount": 2, "state": "normal"}],
        [{"id": 2, "tabCount": 3, "state": "maximized"}],
      ]
      result = b.windows.list()

    assert result == [
      {"id": 1, "tabCount": 2, "state": "normal", "browser": "uuid-1", "browserGroup": "local"},
      {"id": 2, "tabCount": 3, "state": "maximized", "browser": "work", "browserGroup": "local"},
    ]

  def test_windows_open_without_url(self, b, mock_send):
    mock_send.return_value = {"id": 5}

    result = b.windows.open()

    assert result == {"id": 5}
    mock_send.assert_called_once_with("windows.open", {"url": None}, profile=None, remote=None, key=None)

  def test_windows_open_with_url(self, b, mock_send):
    mock_send.return_value = {"id": 9}

    result = b.windows.open("https://example.com")

    assert result == {"id": 9}
    mock_send.assert_called_once_with("windows.open", {"url": "https://example.com"}, profile=None, remote=None, key=None)

class TestDom:
  def test_dom_click(self, b, mock_send):
    b.dom.click("#go")
    mock_send.assert_called_once_with("dom.click", {"selector": "#go"}, profile=None, remote=None, key=None)

  def test_dom_type(self, b, mock_send):
    b.dom.type("#in", "hello")
    mock_send.assert_called_once_with("dom.type", {"selector": "#in", "text": "hello"}, profile=None, remote=None, key=None)

  def test_dom_query_none(self, b, mock_send):
    mock_send.return_value = None
    assert b.dom.query("a") == []

  def test_dom_exists_falsy(self, b, mock_send):
    mock_send.return_value = None
    assert b.dom.exists("a") is False

  def test_dom_wait_for(self, b, mock_send):
    mock_send.return_value = {"selector": "#done", "found": True}

    result = b.dom.wait_for("#done", timeout=2.5, visible=True, tab_id=10)

    assert result == {"selector": "#done", "found": True}
    mock_send.assert_called_once_with(
      "dom.wait_for",
      {"selector": "#done", "timeout": 2500, "visible": True, "hidden": False, "tabId": 10},
      profile=None,
      remote=None,
      key=None,
    )

  def test_dom_eval(self, b, mock_send):
    mock_send.return_value = 42
    assert b.dom.eval("1+41", tab_id=3) == 42
    mock_send.assert_called_once_with("dom.eval", {"code": "1+41", "tabId": 3}, profile=None, remote=None, key=None)

class TestPageStorageCookies:
  def test_page_info(self, b, mock_send):
    mock_send.return_value = {"title": "X"}
    assert b.page.info() == {"title": "X"}
    mock_send.assert_called_once_with("page.info", {}, profile=None, remote=None, key=None)

  def test_storage_get(self, b, mock_send):
    mock_send.return_value = "v"
    assert b.storage.get("k") == "v"
    mock_send.assert_called_once_with("storage.get", {"key": "k", "type": "local", "tabId": None}, profile=None, remote=None, key=None)

  def test_storage_set(self, b, mock_send):
    b.storage.set("k", "v", type="session")
    mock_send.assert_called_once_with(
      "storage.set", {"key": "k", "value": "v", "type": "session", "tabId": None}, profile=None, remote=None, key=None
    )

class TestPerf:
  def test_perf_status(self, b, mock_send):
    mock_send.return_value = {"profile": "auto"}
    assert b.perf.status() == {"profile": "auto"}
    mock_send.assert_called_once_with("perf.status", {}, profile=None, remote=None, key=None)

  def test_perf_set_profile(self, b, mock_send):
    mock_send.return_value = {"profile": "gentle"}
    assert b.perf.set_profile("gentle") == {"profile": "gentle"}
    mock_send.assert_called_once_with("perf.set_profile", {"profile": "gentle"}, profile=None, remote=None, key=None)

  def test_perf_job_status(self, b, mock_send):
    mock_send.return_value = {"phase": "done"}
    assert b.perf.job_status("j1") == {"phase": "done"}
    mock_send.assert_called_once_with("jobs.status", {"jobId": "j1"}, profile=None, remote=None, key=None)

class TestExtension:
  def test_extension_reload(self, b, mock_send):
    b.extension.reload()
    mock_send.assert_called_once_with("extension.reload", {}, profile=None, remote=None, key=None)

class TestSession:
  def test_session_save(self, b, mock_send):
    b.session.save("work")
    mock_send.assert_called_once_with("session.save", {"name": "work"}, profile=None, remote=None, key=None)

  def test_session_load(self, b, mock_send):
    b.session.load("work")
    mock_send.assert_called_once_with(
      "session.load",
      {"name": "work", "gentleMode": "auto", "discardBackgroundTabs": False, "lazy": False, "eagerTabs": 10},
      profile=None, remote=None, key=None,
    )

  def test_session_load_background(self, b, mock_send):
    mock_send.return_value = {"jobId": "j1"}
    assert b.session.load_background("work") == {"jobId": "j1"}
    assert mock_send.call_args[0][1]["__background"] is True

  def test_session_list(self, b, mock_send):
    mock_send.return_value = [{"name": "saved", "tabs": 3, "savedAt": 1712707200000}]

    result = b.session.list()

    assert result == [{"name": "saved", "tabs": 3, "savedAt": 1712707200000}]
    mock_send.assert_called_once_with("session.list", {}, profile=None, remote=None, key=None)

  def test_session_list_multi_browser_adds_browser(self, b, mock_send):
    with patch(
      "browser_cli.active_browser_targets",
      return_value=[
        BrowserTarget("default", "uuid-1", "/tmp/uuid-1.sock"),
        BrowserTarget("work", "work", "/tmp/work.sock"),
      ],
    ):
      mock_send.side_effect = [
        [{"name": "first", "tabs": 2, "savedAt": 1712707200000}],
        [{"name": "second", "tabs": 5, "savedAt": 1712707300000}],
      ]
      result = b.session.list()

    assert result == [
      {"name": "first", "tabs": 2, "savedAt": 1712707200000, "browser": "uuid-1", "browserGroup": "local"},
      {"name": "second", "tabs": 5, "savedAt": 1712707300000, "browser": "work", "browserGroup": "local"},
    ]
    assert mock_send.call_args_list == [
      call("session.list", {}, profile="default"),
      call("session.list", {}, profile="work"),
    ]


# ── Tab model ─────────────────────────────────────────────────────────────────

class TestTabModel:
  @pytest.fixture()
  def tab(self, b, mock_send):
    return b.tab_from(TAB_DATA)

  def test_close(self, tab, mock_send):
    tab.close()
    mock_send.assert_called_once_with("tabs.close", tab_close_args(10), profile=None, remote=None, key=None)

  def test_activate(self, tab, mock_send):
    tab.activate()
    mock_send.assert_called_once_with("tabs.active", {"tabId": 10}, profile=None, remote=None, key=None)

  def test_reload(self, tab, mock_send):
    tab.reload()
    mock_send.assert_called_once_with("navigate.reload", {"tabId": 10}, profile=None, remote=None, key=None)

  def test_hard_reload(self, tab, mock_send):
    tab.hard_reload()
    mock_send.assert_called_once_with("navigate.hard_reload", {"tabId": 10}, profile=None, remote=None, key=None)

  def test_move_forward(self, tab, mock_send):
    tab.move(forward=True)
    mock_send.assert_called_once_with(
      "tabs.move",
      {"tabId": 10, "forward": True, "backward": False, "groupId": None, "windowId": None, "index": None},
      profile=None, remote=None, key=None,
    )

  def test_move_to_group(self, tab, mock_send):
    tab.move(group_id=5)
    assert mock_send.call_args[0][1]["groupId"] == 5

  def test_html(self, tab, mock_send):
    mock_send.return_value = "<html/>"
    assert tab.html() == "<html/>"
    mock_send.assert_called_once_with("tabs.html", {"tabId": 10}, profile=None, remote=None, key=None)

  def test_open(self, tab, mock_send):
    tab.open("https://new.example.com")
    mock_send.assert_called_once_with(
      "navigate.to", {"tabId": 10, "url": "https://new.example.com"}, profile=None, remote=None, key=None
    )

  def test_screenshot(self, tab, mock_send):
    mock_send.return_value = {"dataUrl": "data:image/png;base64,abc"}
    assert tab.screenshot() == "data:image/png;base64,abc"
    mock_send.assert_called_once_with(
      "tabs.screenshot", {"tabId": 10, "format": "png", "quality": None}, profile=None, remote=None, key=None
    )

  def test_pin_unpin(self, tab, mock_send):
    tab.pin()
    tab.unpin()
    assert mock_send.call_args_list == [
      call("tabs.pin", {"tabId": 10}, profile=None, remote=None, key=None),
      call("tabs.unpin", {"tabId": 10}, profile=None, remote=None, key=None),
    ]

  def test_refresh(self, tab, mock_send):
    mock_send.return_value = {**TAB_DATA, "title": "Fresh"}
    fresh = tab.refresh()
    assert fresh.title == "Fresh"
    mock_send.assert_called_once_with("tabs.status", {"tabId": 10}, profile=None, remote=None, key=None)

  def test_wait_for_load_and_watch_url(self, tab, mock_send):
    mock_send.side_effect = [TAB_DATA, TAB_DATA]
    tab.wait_for_load(timeout=1.5, ready_state="interactive")
    tab.watch_url("example", timeout=2)
    assert mock_send.call_args_list == [
      call("navigate.wait", {"tabId": 10, "timeout": 1500, "readyState": "interactive"}, profile=None, remote=None, key=None),
      call("tabs.watch_url", {"pattern": "example", "tabId": 10, "timeout": 2000}, profile=None, remote=None, key=None),
    ]

  def test_open_background_changes_same_tab(self, tab, mock_send):
    tab.open("https://new.example.com", background=True)
    mock_send.assert_called_once_with(
      "navigate.to",
      {"tabId": 10, "url": "https://new.example.com"},
      profile=None, remote=None, key=None,
    )

  def test_unbound_raises(self):
    tab = Tab(id=1, window_id=0, active=False, title="", url="")
    with pytest.raises(RuntimeError, match="not bound"):
      tab.close()

# ── Group model ───────────────────────────────────────────────────────────────

class TestGroupModel:
  @pytest.fixture()
  def group(self, b, mock_send):
    return b.group_from(GROUP_DATA)

  def test_close(self, group, mock_send):
    group.close()
    mock_send.assert_called_once_with("group.close", group_close_args(42), profile=None, remote=None, key=None)

  def test_tabs(self, group, mock_send):
    mock_send.return_value = [TAB_DATA]
    tabs = group.tabs()
    assert isinstance(tabs[0], Tab)
    mock_send.assert_called_once_with("group.tabs", {"groupId": 42}, profile=None, remote=None, key=None)

  def test_move_forward(self, group, mock_send):
    group.move(forward=True)
    mock_send.assert_called_once_with(
      "group.move", {"group": "42", "forward": True, "backward": False}, profile=None, remote=None, key=None
    )

  def test_move_backward(self, group, mock_send):
    group.move(backward=True)
    assert mock_send.call_args[0][1]["backward"] is True

  def test_add_tab(self, group, mock_send):
    mock_send.return_value = {"tabId": 77}
    result = group.add_tab("https://example.com")
    assert result == 77

  def test_add_tab_no_url(self, group, mock_send):
    mock_send.return_value = {"tabId": 78}
    group.add_tab()
    assert mock_send.call_args[0][1]["url"] is None

  def test_unbound_raises(self):
    group = Group(id=1, title="x", color="", collapsed=False, tab_count=0)
    with pytest.raises(RuntimeError, match="not bound"):
      group.close()

# ── SDK decorators ───────────────────────────────────────────────────────────

class TestSDKDecorators:
  def test_active_tab_injects_keyword_and_preserves_name(self, b, mock_send):
    mock_send.return_value = TAB_DATA

    @b.decorators.active_tab
    def current(*, tab):
      return tab.id

    assert current() == 10
    assert current.__name__ == "current"
    mock_send.assert_called_once_with("tabs.status", {"tabId": None}, profile=None, remote=None, key=None)

  def test_active_tab_can_inject_positional(self, b, mock_send):
    mock_send.return_value = TAB_DATA

    @b.decorators.active_tab(keyword=None)
    def current(tab):
      return tab.url

    assert current() == "https://example.com"

  def test_new_tab_injects_and_optionally_closes(self, b, mock_send):
    mock_send.return_value = {"id": 123, "url": "https://example.com"}

    @b.decorators.new_tab("https://example.com", wait=True, timeout=1.5, close=True)
    def work(*, tab):
      return tab.id

    assert work() == 123
    assert mock_send.mock_calls == [
      call(
        "navigate.open_wait",
        {"url": "https://example.com", "timeout": 1500, "background": True, "focus": False, "window": None, "group": None},
        profile=None,
        remote=None,
        key=None,
      ),
      call("tabs.close", tab_close_args(123), profile=None, remote=None, key=None),
    ]

  def test_wait_for_selector_runs_before_function_and_can_inject_result(self, b, mock_send):
    mock_send.return_value = {"selector": "#ready", "ok": True}
    seen = []

    @b.decorators.wait_for_selector("#ready", visible=True, timeout=2.0, keyword="wait_result")
    def work(*, wait_result):
      seen.append(wait_result)
      return "done"

    assert work() == "done"
    assert seen == [{"selector": "#ready", "ok": True}]
    mock_send.assert_called_once_with(
      "dom.wait_for",
      {"selector": "#ready", "timeout": 2000, "visible": True, "hidden": False, "tabId": None},
      profile=None,
      remote=None,
      key=None,
    )

  def test_performance_profile_restores_previous_profile(self, b, mock_send):
    mock_send.side_effect = [
      {"performanceProfile": "normal"},
      {"performanceProfile": "ultra"},
      {"performanceProfile": "normal"},
    ]

    @b.decorators.performance_profile("ultra")
    def work():
      return "ok"

    assert work() == "ok"
    assert mock_send.mock_calls == [
      call("perf.status", {}, profile=None, remote=None, key=None),
      call("perf.set_profile", {"profile": "ultra"}, profile=None, remote=None, key=None),
      call("perf.set_profile", {"profile": "normal"}, profile=None, remote=None, key=None),
    ]

class TestMoreSDKDecorators:
  def test_wait_for_url_injects_tab(self, b, mock_send):
    mock_send.return_value = TAB_DATA

    @b.decorators.wait_for_url(r"/done$", tab_id=10, timeout=1.25)
    def work(*, tab):
      return tab.id

    assert work() == 10
    mock_send.assert_called_once_with(
      "tabs.watch_url",
      {"pattern": r"/done$", "tabId": 10, "timeout": 1250},
      profile=None,
      remote=None,
      key=None,
    )

  def test_save_session_before_runs_before_function(self, b, mock_send):
    calls = []

    @b.decorators.save_session_before("backup")
    def work():
      calls.append("function")

    work()
    assert calls == ["function"]
    mock_send.assert_called_once_with("session.save", {"name": "backup"}, profile=None, remote=None, key=None)

  def test_retry_retries_sync_function(self, b):
    calls = []

    @b.decorators.retry(times=3)
    def flaky():
      calls.append("try")
      if len(calls) < 3:
        raise RuntimeError("not yet")
      return "ok"

    assert flaky() == "ok"
    assert calls == ["try", "try", "try"]

  def test_async_decorated_function_uses_nonblocking_browser_calls(self, b, mock_send):
    mock_send.return_value = TAB_DATA

    @b.decorators.active_tab
    async def current(*, tab):
      await asyncio.sleep(0)
      return tab.id

    assert asyncio.run(current()) == 10
    mock_send.assert_called_once_with("tabs.status", {"tabId": None}, profile=None, remote=None, key=None)

  def test_retry_retries_async_function(self, b):
    calls = []

    @b.decorators.retry(times=2)
    async def flaky():
      calls.append("try")
      if len(calls) == 1:
        raise RuntimeError("not yet")
      return "ok"

    assert asyncio.run(flaky()) == "ok"
    assert calls == ["try", "try"]

class TestAsyncBrowserCLI:
  def test_async_namespace_method_uses_async_transport(self):
    with patch("browser_cli.client.send_command_async") as mock_send_async:
      mock_send_async.return_value = 7

      async def run():
        b = AsyncBrowserCLI(browser="work", remote="browser-host.example:443", key="agent")
        return await b.tabs.count("github")

      assert asyncio.run(run()) == 7
      mock_send_async.assert_called_once_with(
        "tabs.count",
        {"pattern": "github"},
        profile="work",
        remote="browser-host.example:443",
        key="agent",
      )

  def test_async_command_and_clients(self):
    with patch("browser_cli.client.send_command_async") as mock_send_async:
      mock_send_async.side_effect = [{"ok": True}, [{"profile": "work"}]]

      async def run():
        b = AsyncBrowserCLI()
        return await b.command("custom.command", {"x": 1}), await b.clients()

      assert asyncio.run(run()) == ({"ok": True}, [{"profile": "work"}])
      assert mock_send_async.mock_calls == [
        call("custom.command", {"x": 1}, profile=None, remote=None, key=None),
        call("clients.list", {}, profile=None, remote=None, key=None),
      ]

  def test_async_decorator_new_tab_closes_after_function(self):
    with patch("browser_cli.client.send_command_async") as mock_send_async:
      mock_send_async.return_value = {"id": 55, "url": "https://example.com"}

      async def run():
        b = AsyncBrowserCLI()

        @b.decorators.new_tab("https://example.com", close=True)
        async def work(*, tab):
          return tab.id

        return await work()

      assert asyncio.run(run()) == 55
      assert mock_send_async.mock_calls == [
        call(
          "navigate.open",
          {"url": "https://example.com", "background": True, "focus": False, "window": None, "group": None},
          profile=None,
          remote=None,
          key=None,
        ),
        call("tabs.close", {"tabId": 55, "tabIds": None, "inactive": False, "duplicates": False, "gentleMode": "auto"}, profile=None, remote=None, key=None),
      ]

  def test_async_retry_decorator_accepts_sync_function(self):
    async def run():
      b = AsyncBrowserCLI()
      calls = []

      @b.decorators.retry(times=2)
      def flaky():
        calls.append("try")
        if len(calls) == 1:
          raise RuntimeError("not yet")
        return "ok"

      return await flaky(), calls

    assert asyncio.run(run()) == ("ok", ["try", "try"])