"""Tests for pylab tools module.
"""

# Copyright (c) IPython Development Team.
# Distributed under the terms of the Modified BSD License.


from binascii import a2b_base64
from io import BytesIO

import pytest

matplotlib = pytest.importorskip("matplotlib")
matplotlib.use('Agg')
from matplotlib.figure import Figure

from matplotlib import pyplot as plt
from matplotlib_inline import backend_inline
import numpy as np

from IPython.core.getipython import get_ipython
from IPython.core.interactiveshell import InteractiveShell
from IPython.core.display import _PNG, _JPEG
from .. import pylabtools as pt

from IPython.testing import decorators as dec


def test_figure_to_svg():
    # simple empty-figure test
    fig = plt.figure()
    assert pt.print_figure(fig, "svg") is None

    plt.close('all')

    # simple check for at least svg-looking output
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    ax.plot([1,2,3])
    plt.draw()
    svg = pt.print_figure(fig, "svg")[:100].lower()
    assert "doctype svg" in svg


def _check_pil_jpeg_bytes():
    """Skip if PIL can't write JPEGs to BytesIO objects"""
    # PIL's JPEG plugin can't write to BytesIO objects
    # Pillow fixes this
    from PIL import Image
    buf = BytesIO()
    img = Image.new("RGB", (4,4))
    try:
        img.save(buf, 'jpeg')
    except Exception as e:
        ename = e.__class__.__name__
        raise pytest.skip("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e)) from e

@dec.skip_without("PIL.Image")
def test_figure_to_jpeg():
    _check_pil_jpeg_bytes()
    # simple check for at least jpeg-looking output
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    ax.plot([1,2,3])
    plt.draw()
    jpeg = pt.print_figure(fig, 'jpeg', pil_kwargs={'optimize': 50})[:100].lower()
    assert jpeg.startswith(_JPEG)

def test_retina_figure():
    # simple empty-figure test
    fig = plt.figure()
    assert pt.retina_figure(fig) == None
    plt.close('all')

    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    ax.plot([1,2,3])
    plt.draw()
    png, md = pt.retina_figure(fig)
    assert png.startswith(_PNG)
    assert "width" in md
    assert "height" in md


_fmt_mime_map = {
    'png': 'image/png',
    'jpeg': 'image/jpeg',
    'pdf': 'application/pdf',
    'retina': 'image/png',
    'svg': 'image/svg+xml',
}

def test_select_figure_formats_str():
    ip = get_ipython()
    for fmt, active_mime in _fmt_mime_map.items():
        pt.select_figure_formats(ip, fmt)
        for mime, f in ip.display_formatter.formatters.items():
            if mime == active_mime:
                assert Figure in f
            else:
                assert Figure not in f

def test_select_figure_formats_kwargs():
    ip = get_ipython()
    kwargs = dict(bbox_inches="tight")
    pt.select_figure_formats(ip, "png", **kwargs)
    formatter = ip.display_formatter.formatters["image/png"]
    f = formatter.lookup_by_type(Figure)
    cell = f.keywords
    expected = kwargs
    expected["base64"] = True
    expected["fmt"] = "png"
    assert cell == expected

    # check that the formatter doesn't raise
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    ax.plot([1,2,3])
    plt.draw()
    formatter.enabled = True
    png = formatter(fig)
    assert isinstance(png, str)
    png_bytes = a2b_base64(png)
    assert png_bytes.startswith(_PNG)

def test_select_figure_formats_set():
    ip = get_ipython()
    for fmts in [
        {'png', 'svg'},
        ['png'],
        ('jpeg', 'pdf', 'retina'),
        {'svg'},
    ]:
        active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
        pt.select_figure_formats(ip, fmts)
        for mime, f in ip.display_formatter.formatters.items():
            if mime in active_mimes:
                assert Figure in f
            else:
                assert Figure not in f

def test_select_figure_formats_bad():
    ip = get_ipython()
    with pytest.raises(ValueError):
        pt.select_figure_formats(ip, 'foo')
    with pytest.raises(ValueError):
        pt.select_figure_formats(ip, {'png', 'foo'})
    with pytest.raises(ValueError):
        pt.select_figure_formats(ip, ['retina', 'pdf', 'bar', 'bad'])

def test_import_pylab():
    ns = {}
    pt.import_pylab(ns, import_all=False)
    assert "plt" in ns
    assert ns["np"] == np


class TestPylabSwitch(object):
    class Shell(InteractiveShell):
        def init_history(self):
            """Sets up the command history, and starts regular autosaves."""
            self.config.HistoryManager.hist_file = ":memory:"
            super().init_history()

        def enable_gui(self, gui):
            pass

    def setup(self):
        import matplotlib
        def act_mpl(backend):
            matplotlib.rcParams['backend'] = backend

        # Save rcParams since they get modified
        self._saved_rcParams = matplotlib.rcParams
        self._saved_rcParamsOrig = matplotlib.rcParamsOrig
        matplotlib.rcParams = dict(backend="QtAgg")
        matplotlib.rcParamsOrig = dict(backend="QtAgg")

        # Mock out functions
        self._save_am = pt.activate_matplotlib
        pt.activate_matplotlib = act_mpl
        self._save_ip = pt.import_pylab
        pt.import_pylab = lambda *a,**kw:None
        self._save_cis = backend_inline.configure_inline_support
        backend_inline.configure_inline_support = lambda *a, **kw: None

    def teardown(self):
        pt.activate_matplotlib = self._save_am
        pt.import_pylab = self._save_ip
        backend_inline.configure_inline_support = self._save_cis
        import matplotlib
        matplotlib.rcParams = self._saved_rcParams
        matplotlib.rcParamsOrig = self._saved_rcParamsOrig

    def test_qt(self):
        s = self.Shell()
        gui, backend = s.enable_matplotlib(None)
        assert gui == "qt"
        assert s.pylab_gui_select == "qt"

        gui, backend = s.enable_matplotlib("inline")
        assert gui is None
        assert s.pylab_gui_select == "qt"

        gui, backend = s.enable_matplotlib("qt")
        assert gui == "qt"
        assert s.pylab_gui_select == "qt"

        gui, backend = s.enable_matplotlib("inline")
        assert gui is None
        assert s.pylab_gui_select == "qt"

        gui, backend = s.enable_matplotlib()
        assert gui == "qt"
        assert s.pylab_gui_select == "qt"

    def test_inline(self):
        s = self.Shell()
        gui, backend = s.enable_matplotlib("inline")
        assert gui is None
        assert s.pylab_gui_select == None

        gui, backend = s.enable_matplotlib("inline")
        assert gui is None
        assert s.pylab_gui_select == None

        gui, backend = s.enable_matplotlib("qt")
        assert gui == "qt"
        assert s.pylab_gui_select == "qt"

    def test_inline_twice(self):
        "Using '%matplotlib inline' twice should not reset formatters"

        ip = self.Shell()
        gui, backend = ip.enable_matplotlib("inline")
        assert gui is None

        fmts =  {'png'}
        active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
        pt.select_figure_formats(ip, fmts)

        gui, backend = ip.enable_matplotlib("inline")
        assert gui is None

        for mime, f in ip.display_formatter.formatters.items():
            if mime in active_mimes:
                assert Figure in f
            else:
                assert Figure not in f

    def test_qt_gtk(self):
        s = self.Shell()
        gui, backend = s.enable_matplotlib("qt")
        assert gui == "qt"
        assert s.pylab_gui_select == "qt"

        gui, backend = s.enable_matplotlib("gtk3")
        assert gui == "qt"
        assert s.pylab_gui_select == "qt"


def test_no_gui_backends():
    for k in ['agg', 'svg', 'pdf', 'ps']:
        assert k not in pt.backend2gui


def test_figure_no_canvas():
    fig = Figure()
    fig.canvas = None
    pt.print_figure(fig)


@pytest.mark.parametrize(
    "name, expected_gui, expected_backend",
    [
        # name is gui
        ("gtk3", "gtk3", "gtk3agg"),
        ("gtk4", "gtk4", "gtk4agg"),
        ("headless", "headless", "agg"),
        ("osx", "osx", "macosx"),
        ("qt", "qt", "qtagg"),
        ("qt5", "qt5", "qt5agg"),
        ("qt6", "qt6", "qt6agg"),
        ("tk", "tk", "tkagg"),
        ("wx", "wx", "wxagg"),
        # name is backend
        ("agg", None, "agg"),
        ("cairo", None, "cairo"),
        ("pdf", None, "pdf"),
        ("ps", None, "ps"),
        ("svg", None, "svg"),
        ("template", None, "template"),
        ("gtk3agg", "gtk3", "gtk3agg"),
        ("gtk3cairo", "gtk3", "gtk3cairo"),
        ("gtk4agg", "gtk4", "gtk4agg"),
        ("gtk4cairo", "gtk4", "gtk4cairo"),
        ("macosx", "osx", "macosx"),
        ("nbagg", "nbagg", "nbagg"),
        ("notebook", "nbagg", "notebook"),
        ("qtagg", "qt", "qtagg"),
        ("qtcairo", "qt", "qtcairo"),
        ("qt5agg", "qt5", "qt5agg"),
        ("qt5cairo", "qt5", "qt5cairo"),
        ("qt6agg", "qt", "qt6agg"),
        ("qt6cairo", "qt", "qt6cairo"),
        ("tkagg", "tk", "tkagg"),
        ("tkcairo", "tk", "tkcairo"),
        ("webagg", "webagg", "webagg"),
        ("wxagg", "wx", "wxagg"),
        ("wxcairo", "wx", "wxcairo"),
    ],
)
def test_backend_builtin(name, expected_gui, expected_backend):
    # Test correct identification of Matplotlib built-in backends without importing and using them,
    # otherwise we would need to ensure all the complex dependencies such as windowing toolkits are
    # installed.

    mpl_manages_backends = pt._matplotlib_manages_backends()
    if not mpl_manages_backends:
        # Backends not supported before _matplotlib_manages_backends or supported
        # but with different expected_gui or expected_backend.
        if (
            name.endswith("agg")
            or name.endswith("cairo")
            or name in ("headless", "macosx", "pdf", "ps", "svg", "template")
        ):
            pytest.skip()
        elif name == "qt6":
            expected_backend = "qtagg"
        elif name == "notebook":
            expected_backend, expected_gui = expected_gui, expected_backend

    gui, backend = pt.find_gui_and_backend(name)
    if not mpl_manages_backends:
        gui = gui.lower() if gui else None
        backend = backend.lower() if backend else None
    assert gui == expected_gui
    assert backend == expected_backend


def test_backend_entry_point():
    gui, backend = pt.find_gui_and_backend("inline")
    assert gui is None
    expected_backend = (
        "inline"
        if pt._matplotlib_manages_backends()
        else "module://matplotlib_inline.backend_inline"
    )
    assert backend == expected_backend


def test_backend_unknown():
    with pytest.raises(RuntimeError if pt._matplotlib_manages_backends() else KeyError):
        pt.find_gui_and_backend("name-does-not-exist")