# Authors: The MNE-Python contributors.
# License: BSD-3-Clause
# Copyright the MNE-Python contributors.

from functools import partial
from pathlib import Path

import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import pytest
from matplotlib.colors import PowerNorm, TwoSlopeNorm
from matplotlib.patches import Circle
from numpy.testing import assert_almost_equal, assert_array_equal, assert_equal

from mne import (
    Epochs,
    EvokedArray,
    Projection,
    compute_proj_evoked,
    compute_proj_raw,
    create_info,
    find_layout,
    make_fixed_length_events,
    pick_types,
    read_cov,
    read_evokeds,
    read_proj,
)
from mne._fiff.compensator import get_current_comp
from mne._fiff.constants import FIFF
from mne._fiff.pick import _picks_to_idx, channel_indices_by_type, pick_info
from mne._fiff.proj import make_eeg_average_ref_proj
from mne.channels import (
    find_ch_adjacency,
    make_dig_montage,
    make_standard_montage,
    read_layout,
)
from mne.datasets import testing
from mne.io import RawArray, read_info, read_raw_fif
from mne.preprocessing import (
    ICA,
    compute_bridged_electrodes,
    compute_current_source_density,
)
from mne.time_frequency.tfr import AverageTFR, AverageTFRArray
from mne.viz import plot_evoked_topomap, plot_projs_topomap, topomap
from mne.viz.tests.test_raw import _proj_status
from mne.viz.topomap import (
    _get_pos_outlines,
    _onselect,
    plot_arrowmap,
    plot_bridged_electrodes,
    plot_ch_adjacency,
    plot_psds_topomap,
    plot_topomap,
)
from mne.viz.utils import _fake_click, _fake_keypress, _fake_scroll, _find_peaks

data_dir = testing.data_path(download=False)
subjects_dir = data_dir / "subjects"
ecg_fname = data_dir / "MEG" / "sample" / "sample_audvis_ecg-proj.fif"
triux_fname = data_dir / "SSS" / "TRIUX" / "triux_bmlhus_erm_raw.fif"
opm_fname = data_dir / "OPM" / "opm-evoked-ave.fif"


base_dir = Path(__file__).parents[2] / "io" / "tests" / "data"
evoked_fname = base_dir / "test-ave.fif"
raw_fname = base_dir / "test_raw.fif"
event_name = base_dir / "test-eve.fif"
ctf_fname = base_dir / "test_ctf_comp_raw.fif"
layout = read_layout("Vectorview-all")
cov_fname = base_dir / "test-cov.fif"

fast_test = dict(res=8, contours=0, sensors=False)


@pytest.mark.parametrize("layout", (None, "constrained"))
def test_plot_topomap_interactive(layout):
    """Test interactive topomap projection plotting."""
    evoked = read_evokeds(evoked_fname, baseline=(None, 0))[0]
    evoked.pick(picks="mag")
    with evoked.info._unlock():
        evoked.info["projs"] = []
    assert not evoked.proj
    evoked.add_proj(compute_proj_evoked(evoked, n_mag=1))

    plt.close("all")
    fig, ax = plt.subplots(layout=layout)
    canvas = fig.canvas

    kwargs = dict(
        vlim=(-240, 240), times=[0.1], colorbar=False, axes=ax, res=8, time_unit="s"
    )
    evoked.copy().plot_topomap(proj=False, **kwargs)
    canvas.draw()
    image_noproj = np.array(canvas.buffer_rgba())
    assert len(plt.get_fignums()) == 1

    ax.clear()
    evoked.copy().plot_topomap(proj=True, **kwargs)
    canvas.draw()
    image_proj = np.array(canvas.buffer_rgba())
    assert not np.array_equal(image_noproj, image_proj)
    assert len(plt.get_fignums()) == 1

    ax.clear()
    fig = evoked.copy().plot_topomap(proj="interactive", **kwargs)
    canvas.draw()
    image_interactive = np.array(canvas.buffer_rgba())
    assert_array_equal(image_noproj, image_interactive)
    assert not np.array_equal(image_proj, image_interactive)
    assert len(plt.get_fignums()) == 2

    proj_fig = plt.figure(plt.get_fignums()[-1])
    assert _proj_status(fig, "matplotlib") == [False]
    _fake_click(proj_fig, proj_fig.axes[0], [0.5, 0.5], xform="ax")
    proj_fig.canvas.draw_idle()
    assert _proj_status(fig, "matplotlib") == [True]
    canvas.draw()
    image_interactive_click = np.array(canvas.buffer_rgba())
    corr = np.corrcoef(image_proj.ravel(), image_interactive_click.ravel())[0, 1]
    assert 0.99 < corr <= 1
    corr = np.corrcoef(image_noproj.ravel(), image_interactive_click.ravel())[0, 1]
    assert 0.85 < corr < 0.9

    _fake_click(proj_fig, proj_fig.axes[0], [0.5, 0.5], xform="ax")
    canvas.draw()
    image_interactive_click = np.array(canvas.buffer_rgba())
    corr = np.corrcoef(image_noproj.ravel(), image_interactive_click.ravel())[0, 1]
    assert 0.99 < corr <= 1
    corr = np.corrcoef(image_proj.ravel(), image_interactive_click.ravel())[0, 1]
    assert 0.85 < corr < 0.9


@testing.requires_testing_data
def test_plot_projs_topomap():
    """Test plot_projs_topomap."""
    projs = read_proj(ecg_fname)
    info = read_info(raw_fname)
    plot_projs_topomap(projs, info=info, colorbar=True, **fast_test)
    _, ax = plt.subplots()
    projs[3].plot_topomap(info)
    plot_projs_topomap(projs[:1], info, axes=ax, **fast_test)  # test axes
    triux_info = read_info(triux_fname)
    plot_projs_topomap(triux_info["projs"][-1:], triux_info, **fast_test)
    plot_projs_topomap(triux_info["projs"][:1], triux_info, **fast_test)
    eeg_avg = make_eeg_average_ref_proj(info)
    eeg_avg.plot_topomap(info, **fast_test)
    # test vlims
    for vlim in ("joint", (-1, 1), (None, 0.5), (0.5, None), (None, None)):
        plot_projs_topomap(projs[:-1], info, vlim=vlim, colorbar=True)

    eeg_proj = make_eeg_average_ref_proj(info)
    info_meg = pick_info(info, pick_types(info, meg=True, eeg=False))
    with pytest.raises(ValueError, match="Missing channels"):
        plot_projs_topomap([eeg_proj], info_meg)


@pytest.mark.parametrize("vlim", ("joint", None))
@pytest.mark.parametrize("meg", ("combined", "separate"))
def test_plot_projs_topomap_joint(meg, vlim, raw):
    """Test that plot_projs_topomap works with joint vlim."""
    if vlim is None:
        vlim = (None, None)
    projs = compute_proj_raw(raw, meg=meg)
    fig = plot_projs_topomap(projs, info=raw.info, vlim=vlim, **fast_test)
    assert len(fig.axes) == 4  # 2 mag, 2 grad


def test_plot_topomap_animation(capsys):
    """Test topomap plotting."""
    # evoked
    evoked = read_evokeds(evoked_fname, "Left Auditory", baseline=(None, 0))

    # Test animation
    fig, anim = evoked.animate_topomap(
        ch_type="grad",
        times=[0, 0.1],
        cmap="viridis",
        butterfly=False,
        time_unit="s",
        verbose="debug",
    )
    anim._func(1)  # _animate has to be tested separately on 'Agg' backend.
    out, _ = capsys.readouterr()
    assert "extrapolation mode local to 0" in out
    assert fig.axes[0].images[0].get_cmap().name == "viridis"


def test_plot_topomap_animation_csd(capsys):
    """Test topomap plotting of CSD data."""
    # evoked
    evoked = read_evokeds(evoked_fname, "Left Auditory", baseline=(None, 0))
    evoked_csd = compute_current_source_density(evoked)

    # Test animation
    _, anim = evoked_csd.animate_topomap(
        ch_type="csd", times=[0, 0.1], butterfly=False, time_unit="s", verbose="debug"
    )
    anim._func(1)  # _animate has to be tested separately on 'Agg' backend.
    out, _ = capsys.readouterr()
    assert "extrapolation mode head to 0" in out


@pytest.mark.filterwarnings("ignore:.*No contour levels.*:UserWarning")
def test_plot_topomap_animation_nirs(fnirs_evoked, capsys):
    """Test topomap plotting for nirs data."""
    fig, anim = fnirs_evoked.animate_topomap(ch_type="hbo", verbose="debug")
    anim._func(1)  # _animate has to be tested separately on 'Agg' backend.
    out, _ = capsys.readouterr()
    assert "extrapolation mode head to 0" in out
    assert len(fig.axes) == 2


def test_plot_evoked_topomap_errors(evoked, monkeypatch):
    """Test error handling for evoked topomap plots."""
    # simplify data and set some params to make the test really fast
    evoked.pick(["EEG 001", "EEG 002"])
    fast_func = partial(evoked.plot_topomap, res=8, contours=0, sensors=False)
    fast_func_onetime = partial(fast_func, times=0.1)
    # wrong channel type
    with pytest.raises(ValueError, match="No channels of type 'mag'"):
        fast_func(ch_type="mag")
    # bad times
    with pytest.raises(ValueError, match="Times should be between 0.0 and"):
        fast_func(times=[-100])
    with pytest.raises(ValueError, match="times must be 1D, got 2 dimensions"):
        fast_func(times=[[0]])
    # times / average mismatch
    with pytest.raises(ValueError, match="3 time points.*2 periods for aver"):
        fast_func([0.05, 0.1, 0.15], ch_type="eeg", average=[0.01, 0.02])
    # average
    with pytest.raises(ValueError, match="number of seconds.* got -1000.0"):
        fast_func_onetime(average=-1e3)
    with pytest.raises(TypeError, match="number of seconds.* got type:"):
        fast_func_onetime(average="x")
    # image_interp
    with pytest.raises(RuntimeError, match="`image_interp` must be"):
        fast_func_onetime(image_interp="bilinear")
    # border
    with pytest.raises(TypeError, match="be an instance of numeric or str"):
        fast_func_onetime(extrapolate="head", border=[1, 2, 3])
    with pytest.raises(ValueError, match="allowed value.*'mean'.*got 'fancy'"):
        fast_func_onetime(extrapolate="head", border="fancy")
    # projs
    with pytest.raises(RuntimeError, match="Projs are already applied."):
        fast_func_onetime(proj="interactive")
    # too many subplots
    with monkeypatch.context() as m:  # speed it up by not actually plotting
        m.setattr(topomap, "_plot_topomap", lambda *args, **kwargs: (None, None, None))
        with pytest.warns(RuntimeWarning, match="More than 25 topomaps plots"):
            fast_func([0.1] * 26, colorbar=False)
    # missing channel locations
    with evoked.info._unlock():
        for ch in evoked.info["chs"]:
            ch["loc"][:3] = 0.0
    with pytest.raises(ValueError, match="points.*doesn't match.*channels."):
        evoked.plot_topomap()
    with evoked.info._unlock():
        evoked.info["dig"] = None
    with pytest.raises(RuntimeError, match="No digitization points found."):
        evoked.plot_topomap()


@pytest.mark.parametrize(
    "units, scalings, expected_unit",
    [
        (None, None, "µV"),
        ("foo", None, "foo"),
        (None, 7.0, "AU"),  # non-default scaling → "AU"
    ],
)
def test_plot_evoked_topomap_units(evoked, units, scalings, expected_unit):
    """Test that colorbar units respect scalings correctly."""
    evoked.pick(["EEG 001", "EEG 002", "EEG 003"])
    fig = evoked.plot_topomap(
        times=0.1, res=8, contours=0, sensors=False, units=units, scalings=scalings
    )
    cbar = [ax for ax in fig.axes if hasattr(ax, "_colorbar")]
    assert len(cbar) == 1
    cbar = cbar[0]
    assert cbar.get_title() == expected_unit


@pytest.mark.parametrize("extrapolate", ("box", "local", "head"))
def test_plot_evoked_topomap_extrapolation(evoked, extrapolate):
    """Test topomap extrapolation options."""
    evoked.pick(["EEG 001", "EEG 002", "EEG 003"])
    evoked.plot_topomap(
        times=0.1, extrapolate=extrapolate, res=8, contours=0, sensors=False
    )


def test_plot_evoked_topomap_border():
    """Test topomap extrapolation border values."""
    # make some fake sensor locations: 25 sensors at distances of 0.2 to 1.0
    # in steps of 0.2 in the ±x, ±y, and +z directions
    ch_pos = np.array(
        [
            [
                [r, 0, 0],  # +x
                [-r, 0, 0],  # -x
                [0, r, 0],  # +y
                [0, -r, 0],  # -y
                [0, 0, r],  # +z
            ]
            for r in np.linspace(0.2, 1, 5)
        ]
    ).reshape(-1, 3)
    info = create_info(len(ch_pos), 250, "eeg")
    ch_pos_dict = {name: pos for name, pos in zip(info["ch_names"], ch_pos)}
    dig = make_dig_montage(ch_pos_dict, coord_frame="head")
    info.set_montage(dig)
    # simulate data
    data = np.full(len(ch_pos), 5)
    kwargs = dict(res=15, extrapolate="head", sphere=1, sensors=False)
    idx = kwargs["res"] // 2

    # when border=0...
    img, _ = plot_topomap(data, info, border=0, **kwargs)
    img_data = img.get_array().data
    # middle pixel should exactly equal sensor data:
    assert_equal(img_data[idx, idx], data[0])
    # corner pixel should be close(ish) to zero:
    assert img_data[0, 0] < 1.5

    # when border='mean'...
    img, _ = plot_topomap(data, info, border="mean", **kwargs)
    img_data = img.get_array().data
    # middle pixel should exactly equal sensor data:
    assert_equal(img_data[idx, idx], data[0])
    # and corner pixel should *also* be very close to sensor data:
    assert_almost_equal(img_data[idx, idx], data[0], decimal=9)


@pytest.mark.slowtest
def test_plot_topomap_basic():
    """Test basics of topomap plotting."""
    evoked = read_evokeds(evoked_fname, "Left Auditory", baseline=(None, 0))
    res = 8
    fast_test_noscale = dict(res=res, contours=0, sensors=False)
    ev_bad = evoked.copy().pick(picks="eeg")
    ev_bad.pick(ev_bad.ch_names[:2])
    plt_topomap = partial(ev_bad.plot_topomap, **fast_test)
    plt_topomap(times=ev_bad.times[:2] - 1e-6)  # auto, plots EEG
    evoked.plot_topomap(
        [0.1],
        ch_type="eeg",
        scalings=1,
        res=res,
        contours=[-100, 0, 100],
        time_unit="ms",
    )

    # test channel placement when only 'grad' are picked:
    # ---------------------------------------------------
    info_grad = evoked.copy().pick("grad").info
    n_grads = len(info_grad["ch_names"])
    data = np.random.randn(n_grads)
    img, _ = plot_topomap(data, info_grad)

    # check that channels are scattered around x == 0
    pos = img.axes.collections[-1].get_offsets()
    prop_channels_on_the_right = (pos[:, 0] > 0).mean()
    assert prop_channels_on_the_right < 0.6

    # other:
    # ------
    plt_topomap = partial(evoked.plot_topomap, **fast_test)
    plt.close("all")
    axes = [plt.subplot(221), plt.subplot(222)]
    plt_topomap(axes=axes, colorbar=False)
    plt.close("all")
    plt_topomap(times=[-0.1, 0.2])
    plt.close("all")
    evoked_grad = evoked.copy().crop(0, 0).pick(picks="grad")
    mask = np.zeros((204, 1), bool)
    mask[[0, 3, 5, 6]] = True
    names = []

    def proc_names(x):
        names.append(x)
        return x[4:]

    evoked_grad.plot_topomap(
        ch_type="grad", times=[0], mask=mask, show_names=proc_names, **fast_test
    )
    want_names = np.array(evoked_grad.ch_names)[mask.squeeze()].tolist()
    assert_equal(
        [f"{name[:-1]}x" for name in want_names],
        ["MEG 011x", "MEG 012x", "MEG 013x", "MEG 014x"],
    )
    mask = np.zeros_like(evoked.data, dtype=bool)
    mask[[1, 5], :] = True
    plt_topomap(ch_type="mag", outlines=None)
    times = [0.1]
    plt_topomap(times, ch_type="grad", mask=mask)
    plt_topomap(times, ch_type="planar1")
    plt_topomap(times, ch_type="planar2")
    plt_topomap(
        times, ch_type="grad", mask=mask, show_names=True, mask_params={"marker": "x"}
    )
    plt.close("all")

    p = plt_topomap(
        times,
        ch_type="grad",
        image_interp="cubic",
        show_names=lambda x: x.replace("MEG", ""),
    )
    subplot = [
        x
        for x in p.get_children()
        if any(t in str(type(x)) for t in ("Axes", "Subplot"))
    ]
    assert len(subplot) >= 1, [type(x) for x in p.get_children()]
    subplot = subplot[0]

    have_all = all(
        "MEG" not in x.get_text()
        for x in subplot.get_children()
        if isinstance(x, matplotlib.text.Text)
    )
    assert have_all

    # Plot array
    for ch_type in ("mag", "grad"):
        evoked_ = evoked.copy().pick(picks=ch_type)
        plot_topomap(evoked_.data[:, 0], evoked_.info, **fast_test_noscale)
    # fail with multiple channel types
    pytest.raises(ValueError, plot_topomap, evoked.data[0, :], evoked.info)

    # Test title
    def get_texts(p):
        return [
            x.get_text()
            for x in p.get_children()
            if isinstance(x, matplotlib.text.Text)
        ]

    p = plt_topomap(times, ch_type="eeg", average=0.01)
    assert_equal(len(get_texts(p)), 0)
    plt.close("all")

    # Test averaging with a scalar input
    averaging_times = [ev_bad.times[0], times[0], ev_bad.times[-1]]
    p = plt_topomap(averaging_times, ch_type="eeg", average=0.01)

    expected_ax_titles = (
        "-0.200 – -0.195 s",  # clipped on the left
        "0.095 – 0.105 s",  # full range
        "0.494 – 0.499 s",  # clipped on the right
    )
    for idx, expected_title in enumerate(expected_ax_titles):
        assert p.axes[idx].get_title() == expected_title

    # Test averaging with an array-like input
    averaging_durations = [0.01, 0.02, None]
    p = plt_topomap(averaging_times, ch_type="eeg", average=averaging_durations)
    expected_ax_titles = (
        "-0.200 – -0.195 s",  # clipped on the left
        "0.090 – 0.110 s",  # full range
        "0.499 s",  # No averaging
    )
    for idx, expected_title in enumerate(expected_ax_titles):
        assert p.axes[idx].get_title() == expected_title

    del averaging_times, expected_ax_titles, expected_title

    # delaunay triangulation warning
    plt_topomap(times, ch_type="mag")

    # change to no-proj mode
    evoked = read_evokeds(evoked_fname, "Left Auditory", baseline=(None, 0), proj=False)
    plt.close("all")
    fig1 = evoked.plot_topomap(
        "interactive", ch_type="mag", proj="interactive", **fast_test
    )
    # TODO: Clicking the slider creates a *new* image rather than updating
    # the data directly. This makes it so that the projection is not applied
    # to the correct matplotlib Image object.
    # _fake_click(fig1, fig1.axes[1], (0.5, 0.5))  # click slider
    data_max = np.max(fig1.axes[0].images[0]._A)
    proj_fig = plt.figure(plt.get_fignums()[-1])
    assert fig1.mne.proj_checkboxes.get_status() == [False, False, False]
    pos = proj_fig.axes[0].texts[0].get_position() + np.array([0.01, 0])
    _fake_click(proj_fig, proj_fig.axes[0], pos)  # toggle projector
    # make sure projector gets toggled
    assert fig1.mne.proj_checkboxes.get_status() == [True, False, False]
    assert np.max(fig1.axes[0].images[0]._A) != data_max

    for ch in evoked.info["chs"]:
        if ch["coil_type"] == FIFF.FIFFV_COIL_EEG:
            ch["loc"].fill(0)

    # Remove extra digitization point, so EEG digitization points
    # correspond with the EEG electrodes
    del evoked.info["dig"][85]

    # Pass custom outlines without patch
    eeg_picks = pick_types(evoked.info, meg=False, eeg=True)
    pos, outlines = _get_pos_outlines(evoked.info, eeg_picks, 0.1)
    evoked.plot_topomap(times, ch_type="eeg", outlines=outlines, **fast_test)
    plt.close("all")

    # Test interactive cmap
    fig = plot_evoked_topomap(
        evoked, times=[0.0, 0.1], ch_type="eeg", cmap=("Reds", True), **fast_test
    )
    _fake_keypress(fig, "up")
    _fake_keypress(fig, " ")
    _fake_keypress(fig, "down")
    cbar = fig.get_axes()[0].CB  # Fake dragging with mouse.
    ax = cbar.cbar.ax
    _fake_click(fig, ax, (0.1, 0.1))
    _fake_click(fig, ax, (0.1, 0.2), kind="motion")
    _fake_click(fig, ax, (0.1, 0.3), kind="release")

    _fake_click(fig, ax, (0.1, 0.1), button=3)
    _fake_click(fig, ax, (0.1, 0.2), button=3, kind="motion")
    _fake_click(fig, ax, (0.1, 0.3), kind="release")

    _fake_scroll(fig, 0.5, 0.5, -0.5)  # scroll down
    _fake_scroll(fig, 0.5, 0.5, 0.5)  # scroll up

    plt.close("all")

    # Pass custom outlines with patch callable
    def patch():
        return Circle(
            (0.5, 0.4687), radius=0.46, clip_on=True, transform=plt.gca().transAxes
        )

    outlines["patch"] = patch
    plot_evoked_topomap(evoked, times, ch_type="eeg", outlines=outlines, **fast_test)

    # Test error messages for invalid pos parameter
    n_channels = len(pos)
    data = np.ones(n_channels)
    pos_1d = np.zeros(n_channels)
    pos_3d = np.zeros((n_channels, 2, 2))
    pytest.raises(ValueError, plot_topomap, data, pos_1d)
    pytest.raises(ValueError, plot_topomap, data, pos_3d)
    pytest.raises(ValueError, plot_topomap, data, pos[:3, :])

    pos_x = pos[:, :1]
    pos_xyz = np.c_[pos, np.zeros(n_channels)[:, np.newaxis]]
    pytest.raises(ValueError, plot_topomap, data, pos_x)
    pytest.raises(ValueError, plot_topomap, data, pos_xyz)

    # An #channels x 4 matrix should work though. In this case (x, y, width,
    # height) is assumed.
    pos_xywh = np.c_[pos, np.zeros((n_channels, 2))]
    plot_topomap(data, pos_xywh)
    plt.close("all")

    # Test peak finder
    axes = [plt.subplot(131), plt.subplot(132)]
    evoked.plot_topomap(times="peaks", axes=axes, **fast_test)
    plt.close("all")
    evoked.data = np.zeros(evoked.data.shape)
    evoked.data[50][1] = 1
    assert_array_equal(_find_peaks(evoked, 10), evoked.times[1])
    evoked.data[80][100] = 1
    assert_array_equal(_find_peaks(evoked, 10), evoked.times[[1, 100]])
    evoked.data[2][95] = 2
    assert_array_equal(_find_peaks(evoked, 10), evoked.times[[1, 95]])
    assert_array_equal(_find_peaks(evoked, 1), evoked.times[95])

    # Test excluding bads channels
    evoked_grad.info["bads"] += [evoked_grad.info["ch_names"][0]]
    orig_bads = evoked_grad.info["bads"]
    evoked_grad.plot_topomap(ch_type="grad", times=[0], time_unit="ms")
    assert_array_equal(evoked_grad.info["bads"], orig_bads)


def test_plot_psds_topomap_colorbar():
    """Test plot_psds_topomap colorbar option."""
    raw = read_raw_fif(raw_fname)
    picks = pick_types(raw.info, meg="grad")
    info = pick_info(raw.info, picks)
    freqs = np.arange(3.0, 9.5)
    rng = np.random.default_rng(42)
    psd = np.abs(rng.standard_normal((len(picks), len(freqs))))
    bands = {"theta": [4, 8]}

    plt.close("all")
    fig_cbar = plot_psds_topomap(psd, freqs, info, colorbar=True, bands=bands)
    assert len(fig_cbar.axes) == 2

    fig_nocbar = plot_psds_topomap(psd, freqs, info, colorbar=False, bands=bands)
    assert len(fig_nocbar.axes) == 1


def test_plot_tfr_topomap():
    """Test plotting of TFR data."""
    raw = read_raw_fif(raw_fname)
    times = np.linspace(-0.1, 0.1, 200)
    res = 8
    n_freqs = 3
    nave = 1
    rng = np.random.RandomState(42)
    picks = [93, 94, 96, 97, 21, 22, 24, 25, 129, 130, 315, 316, 2, 5, 8, 11]
    info = pick_info(raw.info, picks)
    data = rng.randn(len(picks), n_freqs, len(times))

    # test complex numbers
    tfr = AverageTFRArray(
        info=info,
        data=data * (1 + 1j),
        times=times,
        freqs=np.arange(n_freqs),
        nave=nave,
    )
    tfr.plot_topomap(
        ch_type="mag", tmin=0.05, tmax=0.150, fmin=0, fmax=10, res=res, contours=0
    )

    # test data with taper dimension (real)
    data = np.expand_dims(data, axis=1)
    weights = np.random.rand(1, n_freqs)
    tfr = AverageTFRArray(
        info=info,
        data=data,
        times=times,
        freqs=np.arange(n_freqs),
        nave=nave,
        weights=weights,
    )
    tfr.plot_topomap(
        ch_type="mag", tmin=0.05, tmax=0.150, fmin=0, fmax=10, res=res, contours=0
    )
    # test data with taper dimension (complex)
    state = tfr.__getstate__()
    tfr = AverageTFR(inst=state | dict(data=data * (1 + 1j)))
    tfr.plot_topomap(
        ch_type="mag", tmin=0.05, tmax=0.150, fmin=0, fmax=10, res=res, contours=0
    )
    # remove taper dim before proceeding
    data = data[:, 0]

    # test real numbers
    tfr = AverageTFRArray(
        info=info, data=data, times=times, freqs=np.arange(n_freqs), nave=nave
    )
    tfr.plot_topomap(
        ch_type="mag", tmin=0.05, tmax=0.150, fmin=0, fmax=10, res=res, contours=0
    )

    eclick = matplotlib.backend_bases.MouseEvent(
        "button_press_event", plt.gcf().canvas, 0, 0, 1
    )
    eclick.xdata = eclick.ydata = 0.1
    eclick.inaxes = plt.gca()
    erelease = matplotlib.backend_bases.MouseEvent(
        "button_release_event", plt.gcf().canvas, 0.9, 0.9, 1
    )
    erelease.xdata = 0.3
    erelease.ydata = 0.2
    pos = np.array([[0.11, 0.11], [0.25, 0.5], [0.0, 0.2], [0.2, 0.39]])
    _onselect(eclick, erelease, tfr, pos, "grad", 1, 3, 1, 3, "RdBu_r", list())
    _onselect(eclick, erelease, tfr, pos, "mag", 1, 3, 1, 3, "RdBu_r", list())
    eclick.xdata = eclick.ydata = 0.0
    erelease.xdata = erelease.ydata = 0.9
    tfr._onselect(eclick, erelease, None, "mean", None)
    plt.close("all")

    # test plot_psds_topomap
    info = raw.info.copy()
    chan_inds = channel_indices_by_type(info)
    info = pick_info(info, chan_inds["grad"][:4])

    fig, axes = plt.subplots()
    freqs = np.arange(3.0, 9.5)
    bands = [(4, 8, "Theta")]
    psd = np.random.rand(len(info["ch_names"]), freqs.shape[0])
    plot_psds_topomap(psd, freqs, info, bands=bands, axes=[axes])


def test_ctf_plotting():
    """Test CTF topomap plotting."""
    raw = read_raw_fif(ctf_fname, preload=True)
    assert raw.compensation_grade == 3
    events = make_fixed_length_events(raw, duration=0.01)
    assert len(events) > 10
    evoked = Epochs(raw, events, tmin=0, tmax=0.01, baseline=None).average()
    assert get_current_comp(evoked.info) == 3
    # smoke test that compensation does not matter
    evoked.plot_topomap(time_unit="s")
    # better test that topomaps can still be used without plotting ref
    evoked.pick(picks="meg")
    evoked.plot_topomap()


@pytest.mark.slowtest  # can be slow on OSX
@testing.requires_testing_data
def test_plot_arrowmap(evoked):
    """Test arrowmap plotting."""
    with pytest.raises(ValueError, match="Multiple channel types"):
        plot_arrowmap(evoked.data[:, 0], evoked.info)
    evoked_eeg = evoked.copy().pick("eeg")
    with pytest.raises(ValueError, match="Multiple channel types"):
        plot_arrowmap(evoked_eeg.data[:, 0], evoked.info)
    evoked_mag = evoked.copy().pick("mag")
    evoked_grad = evoked.pick("grad", exclude="bads")
    plot_arrowmap(evoked_mag.data[:, 0], info_from=evoked_mag.info)
    plot_arrowmap(
        evoked_grad.data[:, 0], info_from=evoked_grad.info, info_to=evoked_mag.info
    )


@testing.requires_testing_data
def test_plot_topomap_neuromag122():
    """Test topomap plotting."""
    evoked = read_evokeds(evoked_fname, "Left Auditory", baseline=(None, 0))
    evoked.pick(picks="grad")
    evoked.pick(evoked.ch_names[:122])
    ch_names = [f"MEG {k:03}" for k in range(1, 123)]
    for c in evoked.info["chs"]:
        c["coil_type"] = FIFF.FIFFV_COIL_NM_122
    evoked.rename_channels(
        {c_old: c_new for (c_old, c_new) in zip(evoked.ch_names, ch_names)}
    )
    layout = find_layout(evoked.info)
    assert layout.kind.startswith("Neuromag_122")
    evoked.plot_topomap(times=[0.1], **fast_test)

    proj = Projection(
        active=False,
        desc="test",
        kind=1,
        data=dict(
            nrow=1,
            ncol=122,
            row_names=None,
            col_names=evoked.ch_names,
            data=np.ones(122),
        ),
        explained_var=0.5,
    )

    plot_projs_topomap([proj], evoked.info, **fast_test)


def test_plot_topomap_bads():
    """Test plotting topomap with bad channels (gh-7213)."""
    data = np.random.RandomState(0).randn(3, 1000)
    raw = RawArray(data, create_info(3, 1000.0, "eeg"))
    ch_pos_dict = {name: pos for name, pos in zip(raw.ch_names, np.eye(3))}
    raw.info.set_montage(make_dig_montage(ch_pos_dict, coord_frame="head"))
    for count in range(3):
        raw.info["bads"] = raw.ch_names[:count]
        raw.info._check_consistency()
        plot_topomap(data[:, 0], raw.info)


def test_plot_topomap_channel_distance():
    """
    Test topomap plotting with spread out channels (gh-9511, gh-9526).

    Test topomap plotting when the distance between channels is greater than
    the head radius.
    """
    ch_names = ["TP9", "AF7", "AF8", "TP10"]

    info = create_info(ch_names, 100, ch_types="eeg")
    evoked = EvokedArray(np.random.randn(4, 10) * 1e-6, info)
    ten_five = make_standard_montage("standard_1005")
    evoked.set_montage(ten_five)

    evoked.plot_topomap(sphere=0.05, res=8)


def test_plot_topomap_bads_grad():
    """Test plotting topomap with bad gradiometer channels (gh-8802)."""
    data = np.random.RandomState(0).randn(203)
    info = read_info(evoked_fname)
    info["bads"] = ["MEG 2242"]
    picks = pick_types(info, meg="grad")
    info = pick_info(info, picks)
    assert len(info["chs"]) == 203
    plot_topomap(data, info, res=8)


@testing.requires_testing_data
def test_plot_topomap_opm():
    """Test plotting topomap with OPM data."""
    # load data
    evoked = read_evokeds(opm_fname, kind="average")[0]

    # plot evoked topomap
    fig_evoked = evoked.plot_topomap(
        times=[-0.1, 0, 0.1, 0.2], ch_type="mag", show=False
    )
    assert len(fig_evoked.axes) == 5


def test_plot_topomap_nirs_overlap(fnirs_epochs):
    """Test plotting nirs topomap with overlapping channels (gh-7414)."""
    fig = fnirs_epochs["A"].average(picks="hbo").plot_topomap()
    assert len(fig.axes) == 5


def test_plot_topomap_nirs_ica(fnirs_epochs):
    """Test plotting nirs ica topomap."""
    pytest.importorskip("sklearn")
    fnirs_epochs = fnirs_epochs.load_data().pick(picks="hbo")
    fnirs_epochs = fnirs_epochs.pick(picks=range(30))

    # fake high-pass filtering and hide the fact that the epochs were
    # baseline corrected
    with fnirs_epochs.info._unlock():
        fnirs_epochs.info["highpass"] = 1.0
    fnirs_epochs.baseline = None

    ica = ICA().fit(fnirs_epochs)
    fig = ica.plot_components()
    assert len(fig[0].axes) == 20


def test_plot_cov_topomap():
    """Test plotting a covariance topomap."""
    cov = read_cov(cov_fname)
    info = read_info(evoked_fname)
    cov.plot_topomap(info)
    cov.plot_topomap(info, noise_cov=cov)


def test_plot_topomap_cnorm():
    """Test colormap normalization."""
    rng = np.random.default_rng(42)
    v = rng.uniform(low=-1, high=2.5, size=64)
    v[:3] = [-1, 0, 2.5]

    montage = make_standard_montage("biosemi64")
    info = create_info(montage.ch_names, 256, "eeg").set_montage("biosemi64")
    cnorm = TwoSlopeNorm(vmin=-1, vcenter=0, vmax=2.5)

    # pass only cnorm, no vmin/vmax
    plot_topomap(v, info, cnorm=cnorm)

    # pass cnorm and vmin
    with pytest.warns(RuntimeWarning, match="implicitly defines vmin=-1"):
        plot_topomap(v, info, vlim=(-10, None), cnorm=cnorm)

    # pass cnorm and vmax
    with pytest.warns(RuntimeWarning, match="implicitly defines .* vmax=2.5"):
        plot_topomap(v, info, vlim=(None, 10), cnorm=cnorm)

    # try another subclass of mpl.colors.Normalize
    plot_topomap(v, info, cnorm=PowerNorm(0.5))


def test_plot_bridged_electrodes():
    """Test plotting of bridged electrodes."""
    rng = np.random.default_rng(42)
    montage = make_standard_montage("biosemi64")
    info = create_info(montage.ch_names, 256, "eeg").set_montage("biosemi64")
    bridged_idx = [(0, 1), (2, 3)]
    n_epochs = 10
    ed_matrix = np.zeros((n_epochs, len(info.ch_names), len(info.ch_names))) * np.nan
    triu_idx = np.triu_indices(len(info.ch_names), 1)
    for i in range(n_epochs):
        ed_matrix[i][triu_idx] = rng.random() + rng.random(triu_idx[0].size)
    fig = plot_bridged_electrodes(
        info,
        bridged_idx,
        ed_matrix,
        topomap_args=dict(names=info.ch_names, vlim=(None, 1)),
    )
    # two bridged lines plus head outlines
    assert len(fig.axes[0].lines) == 6
    # test with sphere="eeglab"
    fig = plot_bridged_electrodes(
        info,
        bridged_idx,
        ed_matrix,
        topomap_args=dict(names=info.ch_names, sphere="eeglab", vlim=(None, 1)),
    )

    with pytest.raises(RuntimeError, match="Expected"):
        plot_bridged_electrodes(info, bridged_idx, np.zeros((5, 6, 7)))

    # test with multiple channel types
    raw = read_raw_fif(raw_fname, preload=True)
    picks = _picks_to_idx(raw.info, "eeg")
    raw._data[picks[0]] = raw._data[picks[1]]  # artificially bridge electrodes
    bridged_idx, ed_matrix = compute_bridged_electrodes(raw)
    plot_bridged_electrodes(raw.info, bridged_idx, ed_matrix)


def test_plot_ch_adjacency():
    """Test plotting of adjacency matrix."""
    xyz_pos = np.array(
        [
            [-0.1, 0.1, 0.1],
            [0.1, 0.1, 0.1],
            [0.0, 0.0, 0.12],
            [-0.1, -0.1, 0.1],
            [0.1, -0.1, 0.1],
        ]
    )

    info = create_info(list("abcde"), 23, ch_types="eeg")
    montage = make_dig_montage(
        ch_pos={ch: pos for ch, pos in zip(info.ch_names, xyz_pos)}, coord_frame="head"
    )
    info.set_montage(montage)

    # construct adjacency
    adj_sparse, ch_names = find_ch_adjacency(info, "eeg")

    # plot adjacency
    fig = plot_ch_adjacency(info, adj_sparse, ch_names, kind="2d", edit=True)

    # find channel positions
    collection = fig.axes[0].collections[0]
    pos = collection.get_offsets().data

    # get adjacency lines
    lines = fig.axes[0].lines[4:]  # (first four lines are head outlines)

    # make sure lines match adjacency relations in the matrix
    for line in lines:
        x, y = line.get_data()
        ch_idx = [
            np.where((pos == [[x[ix], y[ix]]]).all(axis=1))[0][0] for ix in range(2)
        ]
        assert adj_sparse[ch_idx[0], ch_idx[1]]

    # make sure additional point is generated after clicking a channel
    _fake_click(fig, fig.axes[0], pos[0], xform="data")
    collections = fig.axes[0].collections
    assert len(collections) == 2

    # make sure the point is green
    green = matplotlib.colors.to_rgba("tab:green")
    assert (collections[1].get_facecolor() == green).all()

    # make sure adjacency entry is modified after second click on another node
    assert adj_sparse[0, 1]
    assert adj_sparse[1, 0]
    n_lines_before = len(lines)
    _fake_click(fig, fig.axes[0], pos[1], xform="data")

    assert not adj_sparse[0, 1]
    assert not adj_sparse[1, 0]

    # and there is one line less
    lines = fig.axes[0].lines[4:]
    n_lines_after = len(lines)
    assert n_lines_after == n_lines_before - 1

    # make sure there is still one green point ...
    collections = fig.axes[0].collections
    assert len(collections) == 2
    assert (collections[1].get_facecolor() == green).all()

    # ... but its at a different location
    point_pos = collections[1].get_offsets().data
    assert (point_pos == pos[1]).all()

    # check that clicking again removes the green selection point
    _fake_click(fig, fig.axes[0], pos[1], xform="data")
    collections = fig.axes[0].collections
    assert len(collections) == 1

    # clicking the points again adds a green line
    _fake_click(fig, fig.axes[0], pos[1], xform="data")
    _fake_click(fig, fig.axes[0], pos[0], xform="data")

    lines = fig.axes[0].lines[4:]
    assert len(lines) == n_lines_after + 1
    assert lines[-1].get_color() == "tab:green"

    # smoke test for 3d option
    adj = adj_sparse.toarray()
    fig = plot_ch_adjacency(info, adj, ch_names, kind="3d")

    # test errors
    # -----------
    # number of channels in the adjacency matrix and info must match
    msg = (
        "``adjacency`` must have the same number of rows as the number of "
        "channels in ``info``"
    )
    with pytest.raises(ValueError, match=msg):
        plot_ch_adjacency(info, adj_sparse, ch_names[:3], kind="2d")

    # edition mode only available for 2d plot
    msg = "Editing a 3d adjacency plot is not supported."
    with pytest.raises(ValueError, match=msg):
        plot_ch_adjacency(info, adj, ch_names, kind="3d", edit=True)


@pytest.mark.parametrize("ch_type", ("mag", "grad"))
def test_plot_topomap_info_names_ordering(ch_type):
    """Regression test for GH-12700.

    plot_topomap() must preserve correct sensor name ordering when
    passing an Info object as pos with a names argument.
    This must be tested with MEG data including gradiometers, since the
    bug only affected the gradiometer code path.
    """
    evoked = read_evokeds(evoked_fname, baseline=(None, 0))[0]
    evoked = evoked.copy().crop(0, 0).pick(picks=ch_type)
    info = evoked.info
    data = evoked.data[:, 0]
    names = info["ch_names"]
    if ch_type == "grad":
        # grad pairs are merged so only every other name is displayed
        expected_names = names[::2]
    else:
        expected_names = names
    im, _ = plot_topomap(data, info, names=names, show=False)
    displayed_names = [t.get_text() for t in im.axes.texts]
    assert displayed_names == list(expected_names), (
        f"Expected {list(expected_names)}, got {displayed_names}"
    )
