import sys
from unittest.mock import Mock, patch

import pytest

from npe2._command_registry import CommandHandler, CommandRegistry
from npe2._plugin_manager import PluginManager
from npe2.manifest.schema import PluginManifest
from npe2.types import PythonName

SAMPLE_PLUGIN_NAME = "my-plugin"


@pytest.fixture
def pm(sample_path):
    pm = PluginManager()
    pm.discover()
    assert len(pm._manifests) == 0
    sys.path.append(str(sample_path))
    try:
        pm.discover()
        yield pm
    finally:
        sys.path.remove(str(sample_path))


def test_discover_clear(uses_sample_plugin):
    pm = PluginManager.instance()
    assert SAMPLE_PLUGIN_NAME in pm._manifests
    reg_mock = Mock()
    pm.events.plugins_registered.connect(reg_mock)
    with patch.object(pm, "register", wraps=pm.register) as mock:
        pm.discover()
        mock.assert_not_called()  # nothing new to register
        reg_mock.assert_not_called()

        mock.reset_mock()
        pm.discover(clear=True)  # clear forces reregister
        mock.assert_called_once()
        reg_mock.assert_called_once_with({pm._manifests[SAMPLE_PLUGIN_NAME]})


def test_plugin_manager(pm: PluginManager):
    assert pm.get_command(f"{SAMPLE_PLUGIN_NAME}.hello_world")

    assert SAMPLE_PLUGIN_NAME not in pm._contexts
    ctx = pm.activate(SAMPLE_PLUGIN_NAME)
    assert SAMPLE_PLUGIN_NAME in pm._contexts
    assert pm.get_manifest(SAMPLE_PLUGIN_NAME)

    # dual activation is prevented
    assert pm.activate(SAMPLE_PLUGIN_NAME) is ctx

    assert pm.get_command(f"{SAMPLE_PLUGIN_NAME}.hello_world")

    assert pm.get_submenu("mysubmenu")
    with pytest.raises(KeyError):
        pm.get_submenu("not-a-submenu")
    assert len(list(pm.iter_menu("/napari/layer_context"))) == 2

    # deactivation
    assert SAMPLE_PLUGIN_NAME in pm._contexts
    pm.deactivate(SAMPLE_PLUGIN_NAME)
    assert SAMPLE_PLUGIN_NAME not in pm._contexts
    pm.deactivate(SAMPLE_PLUGIN_NAME)  # second time is a no-op
    assert SAMPLE_PLUGIN_NAME not in pm._contexts


def test_plugin_manager_register(sample_path):
    sys.path.append(str(sample_path))
    try:
        pm = PluginManager()
        pm.register(str(sample_path / "my_plugin" / "napari.yaml"))
        assert "my-plugin" in pm._manifests
        pm.unregister("my-plugin")
        assert "my-plugin" not in pm._manifests
        pm.register("my_plugin")
        assert "my-plugin" in pm._manifests
    finally:
        sys.path.remove(str(sample_path))


def test_plugin_manager_raises(pm: PluginManager):
    with pytest.raises(KeyError):
        pm.get_manifest("not-a-pluginxxx")
    with pytest.raises(KeyError):
        pm.activate("not a thing")
    with pytest.raises(KeyError):
        pm.get_command(f"{SAMPLE_PLUGIN_NAME}.not_a_thing")
    with pytest.raises(ValueError) as e:
        pm.register(PluginManifest(name=SAMPLE_PLUGIN_NAME))
    assert f"A manifest with name {SAMPLE_PLUGIN_NAME!r} already" in str(e.value)


def test_command_handler():
    with pytest.raises(RuntimeError):
        # cannot resolve something without either a python_name or function
        CommandHandler("hi").resolve()

    with pytest.raises(RuntimeError):
        # cannot resolve something without either a python_name or function
        CommandHandler("hi", python_name=PythonName("cannot.import.this")).resolve()


def test_command_reg_register():
    reg = CommandRegistry()
    with pytest.raises(ValueError):
        # must register non empty string id
        reg.register(1, lambda: None)  # type: ignore
    with pytest.raises(TypeError):
        # neither a string or a callable
        reg.register("other.id", 8)  # type: ignore

    with pytest.raises(ValueError):
        # must register non empty string id
        reg.register("some.id", "1_is_not.a_valid_python_name")
    reg.register("some.id", "this.is.a_valid_python_name")

    with pytest.raises(ValueError):
        # already registered
        reg.register("some.id", "this.is.a_valid_python_name")

    with pytest.raises(KeyError) as e:
        reg.get("not.a.command")
    assert "command 'not.a.command' not registered" in str(e.value)


def test_command_reg_get():
    def f(x, y):
        return x + y

    reg = CommandRegistry()
    reg.register("id", f)
    assert "id" in reg
    assert reg.get("id") is f
    assert reg.execute("id", (1, 2)) == 3


def _assert_sample_enabled(plugin_manager: PluginManager, enabled=True):
    i = SAMPLE_PLUGIN_NAME in plugin_manager._contrib._indexed
    assert i if enabled else not i

    _not = "not " if not enabled else ""
    # command
    if enabled:
        assert plugin_manager.get_command(f"{SAMPLE_PLUGIN_NAME}.hello_world")
    else:
        with pytest.raises(KeyError):
            assert plugin_manager.get_command(f"{SAMPLE_PLUGIN_NAME}.hello_world")

    # reader
    cmds = [r.command for r in plugin_manager.iter_compatible_readers("*.fzy")]
    b = f"{SAMPLE_PLUGIN_NAME}.some_reader" in cmds
    assert b if enabled else not b, f"Reader should {_not}be enabled"

    # writer
    cmds = [r.command for r in plugin_manager.iter_compatible_writers(["image"] * 2)]
    c = f"{SAMPLE_PLUGIN_NAME}.my_writer" in cmds
    assert c if enabled else not c, f"Writer should {_not}be enabled"

    d = "SampleTheme" in [t.label for t in plugin_manager.iter_themes()]
    assert d if enabled else not d, f"Theme should {_not}be enabled"


def test_enable_disable(uses_sample_plugin, plugin_manager: PluginManager, tmp_path):
    _assert_sample_enabled(plugin_manager)
    # just to test the enabled= kwarg on iter_manifests
    # (this would show *only* disabled plugins)
    assert not list(plugin_manager.iter_manifests(disabled=True))

    # Do disable
    mock = Mock()
    plugin_manager.events.enablement_changed.connect(mock)
    plugin_manager.disable(SAMPLE_PLUGIN_NAME)
    mock.assert_called_once_with({}, {SAMPLE_PLUGIN_NAME})  # enabled, disabled

    _assert_sample_enabled(plugin_manager, False)

    # stuff you can't do while disabled:
    with pytest.raises(ValueError):
        plugin_manager.activate(SAMPLE_PLUGIN_NAME)

    # re-enable
    mock.reset_mock()
    plugin_manager.enable(SAMPLE_PLUGIN_NAME)
    mock.assert_called_once_with({SAMPLE_PLUGIN_NAME}, {})  # enabled, disabled
    _assert_sample_enabled(plugin_manager)


def test_warn_on_register_disabled(uses_sample_plugin, plugin_manager: PluginManager):
    assert SAMPLE_PLUGIN_NAME in plugin_manager
    mf = plugin_manager[SAMPLE_PLUGIN_NAME]
    plugin_manager.disable(SAMPLE_PLUGIN_NAME)
    plugin_manager._manifests.pop(SAMPLE_PLUGIN_NAME)  # NOT good way to "unregister"
    with pytest.warns(UserWarning):
        plugin_manager.register(mf)


def test_plugin_manager_dict(uses_sample_plugin, plugin_manager: PluginManager):
    """Test exporting the plugin manager state with `dict()`."""
    d = plugin_manager.dict()
    assert SAMPLE_PLUGIN_NAME in d["plugins"]
    assert "disabled" in d
    assert "activated" in d

    d = plugin_manager.dict(
        include={"contributions", "package_metadata.version"},
        exclude={"contributions.writers", "contributions.readers"},
    )
    plugin_dict = d["plugins"][SAMPLE_PLUGIN_NAME]
    assert set(plugin_dict) == {"contributions", "package_metadata"}
    contribs = set(plugin_dict["contributions"])
    assert "readers" not in contribs
    assert "writers" not in contribs


def test_plugin_context_dispose():
    pm = PluginManager()
    mf = PluginManifest(name="test")
    pm.register(mf)
    mock = Mock()
    pm.get_context("test").register_disposable(mock)
    pm.deactivate("test")
    mock.assert_called_once()


def test_plugin_context_dispose_error(caplog):
    """Test errors when executing dispose functions caught correctly."""
    pm = PluginManager()
    mf = PluginManifest(name="test")
    pm.register(mf)

    def dummy_error():
        raise ValueError("This is an error")

    pm.get_context("test").register_disposable(dummy_error)
    pm.deactivate("test")
    assert caplog.records[0].msg == "Error while disposing test; This is an error"


def test_command_menu_map(uses_sample_plugin, plugin_manager: PluginManager):
    """Test that the command menu map is correctly populated."""
    pm = PluginManager.instance()
    assert SAMPLE_PLUGIN_NAME in pm._manifests
    assert SAMPLE_PLUGIN_NAME in pm._command_menu_map

    # contains correct commands
    command_menu_map = pm._command_menu_map[SAMPLE_PLUGIN_NAME]
    assert "my-plugin.hello_world" in command_menu_map
    assert "my-plugin.another_command" in command_menu_map

    # commands point to correct menus
    cmd_menu = command_menu_map["my-plugin.hello_world"]
    assert len(cmd_menu) == 1
    assert "/napari/layer_context" in cmd_menu
    cmd_menu = command_menu_map["my-plugin.another_command"]
    assert len(cmd_menu) == 1
    assert "mysubmenu" in cmd_menu

    # enable/disable
    pm.disable(SAMPLE_PLUGIN_NAME)
    assert SAMPLE_PLUGIN_NAME not in pm._command_menu_map
    pm.enable(SAMPLE_PLUGIN_NAME)
    assert SAMPLE_PLUGIN_NAME in pm._command_menu_map

    # register/unregister
    pm.unregister(SAMPLE_PLUGIN_NAME)
    assert SAMPLE_PLUGIN_NAME not in pm._command_menu_map
    pm.register(SAMPLE_PLUGIN_NAME)
    assert SAMPLE_PLUGIN_NAME in pm._command_menu_map


def test_command_menu_map_npe1(uses_npe1_plugin, plugin_manager: PluginManager):
    pm = PluginManager.instance()
    pm.discover(include_npe1=True)

    # ensuring that even for NPE1 adapters, which cannot declare menu items
    # we can fully index into the command menu map and get an empty list
    assert isinstance(pm._command_menu_map["npe1-plugin"], dict)
    command_menu_map = pm._command_menu_map["npe1-plugin"]
    assert command_menu_map["npe1-plugin.any_command"]["napari/layer_context"] == []


def test_get_shimmed_plugins(pm: PluginManager, uses_npe1_plugin):
    assert len(pm.get_shimmed_plugins()) == 0
    pm.discover(include_npe1=True)
    shimmed = pm.get_shimmed_plugins()
    assert len(shimmed) == 1
    assert shimmed[0] == "npe1-plugin"