# -*- coding: utf-8 -*-
# Copyright (c) Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.

"""vispy backend for Tkinter."""

from __future__ import division

from time import sleep
import warnings

from ..base import (BaseApplicationBackend, BaseCanvasBackend,
                    BaseTimerBackend)
from ...util import keys
from ...util.ptime import time
from ...gloo import gl

# -------------------------------------------------------------------- init ---

# Import
try:
    import sys

    _tk_on_linux, _tk_on_darwin, _tk_on_windows = \
        map(sys.platform.startswith, ("linux", "darwin", "win"))
    _tk_pyopengltk_imported = False

    import tkinter as tk
    import pyopengltk
except (ModuleNotFoundError, ImportError):
    available, testable, why_not, which = \
        False, False, "Could not import Tkinter or pyopengltk, module(s) not found.", None
else:
    which_pyopengltk = getattr(pyopengltk, "__version__", "???")
    which = f"Tkinter {tk.TkVersion} (with pyopengltk {which_pyopengltk})"

    if hasattr(pyopengltk, "OpenGLFrame"):
        _tk_pyopengltk_imported = True
        available, testable, why_not = True, True, None
    else:
        # pyopengltk does not provide an implementation for this platform
        available, testable, why_not = \
            False, False, f"pyopengltk {which_pyopengltk} is not supported on this platform ({sys.platform})!"

if _tk_pyopengltk_imported:
    # Put OpenGLFrame class in global namespace
    OpenGLFrame = pyopengltk.OpenGLFrame
else:
    # Create empty placeholder class
    class OpenGLFrame(object):
        pass

# Map native keys to vispy keys
# e.keysym_num -> vispy
KEYMAP = {
    65505: keys.SHIFT,
    65506: keys.SHIFT,
    65507: keys.CONTROL,
    65508: keys.CONTROL,
    65513: keys.ALT,
    65514: keys.ALT,
    65371: keys.META,
    65372: keys.META,

    65361: keys.LEFT,
    65362: keys.UP,
    65363: keys.RIGHT,
    65364: keys.DOWN,
    65365: keys.PAGEUP,
    65366: keys.PAGEDOWN,

    65379: keys.INSERT,
    65535: keys.DELETE,
    65360: keys.HOME,
    65367: keys.END,

    65307: keys.ESCAPE,
    65288: keys.BACKSPACE,

    32: keys.SPACE,
    65293: keys.ENTER,
    65289: keys.TAB,

    65470: keys.F1,
    65471: keys.F2,
    65472: keys.F3,
    65473: keys.F4,
    65474: keys.F5,
    65475: keys.F6,
    65476: keys.F7,
    65477: keys.F8,
    65478: keys.F9,
    65479: keys.F10,
    65480: keys.F11,
    65481: keys.F12,
}

# e.state -> vispy keyboard modifiers
KEY_STATE_MAP = {
    0x0001: keys.SHIFT,
    # 0x0002: CAPSLOCK,
    0x0004: keys.CONTROL,
    # 0x0008: keys.ALT,  # LEFT_ALT: Seems always pressed?
    # 0x0010: NUMLOCK,
    # 0x0020: SCROLLLOCK,
    0x0080: keys.ALT,
    # 0x0100: ?,  # Mouse button 1.
    # 0x0200: ?,  # Mouse button 2.
    # 0x0400: ?,  # Mouse button 3.
    0x20000: keys.ALT  # LEFT_ALT ?
}

# e.state -> vispy mouse buttons pressed
MOUSE_STATE_MAP = {
    0x0100: 1,  # Left mouse
    0x0200: 3,  # Middle mouse
    0x0400: 2,  # Right mouse
}

# e.num -> vispy
MOUSE_BUTTON_MAP = {
    1: 1,  # Mouse Left   == 1 -> Mouse Left
    2: 3,  # Mouse Middle == 2 -> Mouse Middle
    3: 2,  # Mouse Right  == 3 -> Mouse Right

    # TODO: If other mouse buttons are needed
    # and they differ from the Tkinter numbering, add them here.
    # e.g. BACK/FORWARD buttons or other custom mouse buttons
}

# -------------------------------------------------------------- capability ---

# These are all booleans. Note that they mirror many of the kwargs to
# the initialization of the Canvas class.
capability = dict(
    # if True they mean:
    title=True,           # can set title on the fly
    size=True,            # can set size on the fly
    position=True,        # can set position on the fly
    show=True,            # can show/hide window
    vsync=False,          # can set window to sync to blank
    resizable=True,       # can toggle resizability (e.g., no user resizing)
    decorate=True,        # can toggle decorations
    fullscreen=True,      # fullscreen window support
    context=False,        # can share contexts between windows
    multi_window=True,    # can use multiple windows at once
    scroll=True,          # scroll-wheel events are supported
    parent=True,          # can pass native widget backend parent
    always_on_top=True,   # can be made always-on-top
)


# ------------------------------------------------------- set_configuration ---
def _set_config(c):
    """Set gl configuration for template.
    Currently not used for Tkinter backend.
    """
    return []


# ------------------------------------------------------------- application ---

class _TkInstanceManager:
    _tk_inst = None         # Reference to tk.Tk instance
    _tk_inst_owned = False  # Whether we created the Tk instance or not
    _canvasses = []         # References to created CanvasBackends

    @classmethod
    def get_tk_instance(cls):
        """Return the Tk instance.

        Returns
        -------
        tk.Tk
            The tk.Tk instance.
        """
        if cls._tk_inst is None:
            if tk._default_root:
                # There already is a tk.Tk() instance available
                cls._tk_inst = tk._default_root
                cls._tk_inst_owned = False
            else:
                # Create our own top level Tk instance
                cls._tk_inst = tk.Tk()
                cls._tk_inst.withdraw()
                cls._tk_inst_owned = True
        return cls._tk_inst

    @classmethod
    def get_canvasses(cls):
        """Return a list of CanvasBackends.

        Returns
        -------
        list
            A list with CanvasBackends.
        """
        return cls._canvasses

    @classmethod
    def new_toplevel(cls, canvas, *args, **kwargs):
        """Create and return a new withdrawn Toplevel.
        Create a tk.Toplevel with the given args and kwargs,
        minimize it and add it to the list before returning

        Parameters
        ----------
        canvas : CanvasBackend
            The CanvasBackend instance that wants a new Toplevel.
        *args
            Variable length argument list.
        **kwargs
            Arbitrary keyword arguments.

        Returns
        -------
        tk.Toplevel
            Return the created tk.Toplevel
        """
        tl = tk.Toplevel(cls._tk_inst, *args, **kwargs)
        tl.withdraw()
        cls._canvasses.append(canvas)
        return tl

    @classmethod
    def del_toplevel(cls, canvas=None):
        """
        Destroy the given Toplevel, and if it was the last one,
        also destroy the Tk instance if we created it.

        Parameters
        ----------
        canvas : CanvasBackend
            The CanvasBackend to destroy, defaults to None.
        """
        if canvas:
            try:
                canvas.destroy()
                if canvas.top:
                    canvas.top.destroy()
                cls._canvasses.remove(canvas)
            except Exception:
                pass

        # If there are no Toplevels left, quit the mainloop.
        if cls._tk_inst and not cls._canvasses and cls._tk_inst_owned:
            cls._tk_inst.quit()
            cls._tk_inst.destroy()
            cls._tk_inst = None


class ApplicationBackend(BaseApplicationBackend):
    def _vispy_get_backend_name(self):
        """
        Returns
        -------
        str
            The name of the backend.
        """
        return tk.__name__

    def _vispy_process_events(self):
        """Process events related to the spawned Tk application window.
        First, update the Tk instance, then call `_delayed_update`
        on every created Toplevel (to force a redraw), and process some Tkinter
        GUI events by calling the Tk.mainloop and immediately exiting.
        """
        # Update idle tasks first (probably not required)
        app = self._vispy_get_native_app()
        app.update_idletasks()

        # Update every active Canvas window
        for c in _TkInstanceManager.get_canvasses():
            c._delayed_update()

        # Process some events in the main Tkinter event loop
        # And quit so we can continue elsewhere (call blocks normally)
        app.after(0, lambda: app.quit())
        app.mainloop()

    def _vispy_run(self):
        """Start the Tk.mainloop. This will block until all Tk windows are destroyed."""
        self._vispy_get_native_app().mainloop()

    def _vispy_quit(self):
        """Destroy each created Toplevel by calling _vispy_close on it.
        If there are no Toplevels left, also destroy the Tk instance.
        """
        for c in _TkInstanceManager.get_canvasses():
            c._vispy_close()
        _TkInstanceManager.del_toplevel()

    def _vispy_get_native_app(self):
        """Get or create the Tk instance.

        Returns
        -------
        tk.Tk
            The tk.Tk instance.
        """
        return _TkInstanceManager.get_tk_instance()


# ------------------------------------------------------------------ canvas ---


class CanvasBackend(BaseCanvasBackend, OpenGLFrame):
    """Tkinter backend for Canvas abstract class.
    Uses pyopengltk.OpenGLFrame as the internal tk.Frame instance that
    is able to receive OpenGL draw commands and display the results,
    while also being placeable in another Toplevel window.
    """

    def __init__(self, vispy_canvas, **kwargs):
        BaseCanvasBackend.__init__(self, vispy_canvas)
        p = self._process_backend_kwargs(kwargs)

        self._double_click_supported = True

        # Deal with config
        # ... use context.config
        # Deal with context
        p.context.shared.add_ref('tk', self)
        if p.context.shared.ref is self:
            self._native_context = None
        else:
            self._native_context = p.context.shared.ref._native_context

        # Pop args unrecognised by OpenGLFrame
        kwargs.pop("parent")
        kwargs.pop("title")
        kwargs.pop("size")
        kwargs.pop("position")
        kwargs.pop("show")
        kwargs.pop("vsync")
        kwargs.pop("resizable")
        kwargs.pop("decorate")
        kwargs.pop("always_on_top")
        kwargs.pop("fullscreen")
        kwargs.pop("context")

        if p.parent is None:
            # Create native window and top level
            self.top = _TkInstanceManager.new_toplevel(self)

            # Check input args and call appropriate set-up functions.
            if p.title:
                self._vispy_set_title(p.title)
            if p.size:
                self._vispy_set_size(p.size[0], p.size[1])
            if p.position:
                self._vispy_set_position(p.position[0], p.position[1])

            self.top.update_idletasks()

            if not p.resizable:
                self.top.resizable(False, False)
            if not p.decorate:
                self.top.overrideredirect(True)
            if p.always_on_top:
                self.top.wm_attributes("-topmost", "True")
            self._fullscreen = bool(p.fullscreen)

            self.top.protocol("WM_DELETE_WINDOW", self._vispy_close)
            parent = self.top
        else:
            # Use given parent as top level
            self.top = None
            parent = p.parent
            self._fullscreen = False

        self._init = False
        self.is_destroyed = False
        self._dynamic_keymap = {}

        OpenGLFrame.__init__(self, parent, **kwargs)

        if self.top:
            # Embed canvas in top (new window) if this was created
            self.top.configure(bg="black")
            self.pack(fill=tk.BOTH, expand=True)

            # Also bind the key events to the top window instead.
            self.top.bind("<Any-KeyPress>", self._on_key_down)
            self.top.bind("<Any-KeyRelease>", self._on_key_up)
        else:
            # If no top, bind key events to the canvas itself.
            self.bind("<Any-KeyPress>", self._on_key_down)
            self.bind("<Any-KeyRelease>", self._on_key_up)

        # Bind the other events to our internal methods.
        self.bind("<Enter>", self._on_mouse_enter)  # This also binds MouseWheel
        self.bind("<Leave>", self._on_mouse_leave)  # This also unbinds MouseWheel
        self.bind("<Motion>", self._on_mouse_move)
        self.bind("<Any-Button>", self._on_mouse_button_press)
        self.bind("<Double-Any-Button>", self._on_mouse_double_button_press)
        self.bind("<Any-ButtonRelease>", self._on_mouse_button_release)
        self.bind("<Configure>", self._on_configure, add='+')

        self._vispy_set_visible(p.show)
        self.focus_force()

    def initgl(self):
        """Overridden from OpenGLFrame
        Gets called on init or when the frame is remapped into its container.
        """
        if not hasattr(self, "_native_context") or self._native_context is None:
            # Workaround to get OpenGLFrame.__context for reference here
            # if access would ever be needed from self._native_context.
            # FIXME: Context sharing this way seems unsupported
            self._native_context = vars(self).get("_CanvasBackend__context", None)

        self.update_idletasks()
        gl.glClear(gl.GL_COLOR_BUFFER_BIT)
        gl.glClearColor(0.0, 0.0, 0.0, 0.0)

    def redraw(self, *args):
        """Overridden from OpenGLFrame
        Gets called when the OpenGLFrame redraws itself.
        It will set the current buffer, call self.redraw() and
        swap buffers afterwards.
        """
        if self._vispy_canvas is None:
            return
        if not self._init:
            self._initialize()
        self._vispy_canvas.set_current()
        self._vispy_canvas.events.draw(region=None)

    def _delayed_update(self):
        """
        Expose a new frame to the canvas. This will call self.redraw() internally.

        The self.animate sets the refresh rate in milliseconds. Using this is not
        necessary because VisPy will use the TimerBackend to periodically call
        self._vispy_update, resulting in the exact same behaviour.
        So we set it to `0` to tell OpenGLFrame not to redraw itself on its own.
        """
        if self.is_destroyed:
            return
        self.animate = 0
        self.tkExpose(None)

    def _on_configure(self, e):
        """Called when the frame get configured or resized."""
        if self._vispy_canvas is None or not self._init:
            return
        size_tup = e if isinstance(e, tuple) else (e.width, e.height)
        self._vispy_canvas.events.resize(size=size_tup)

    def _initialize(self):
        """Initialise the Canvas for drawing."""
        self.initgl()
        if self._vispy_canvas is None:
            return
        self._init = True
        self._vispy_canvas.set_current()
        self._vispy_canvas.events.initialize()
        self.update_idletasks()
        self._on_configure(self._vispy_get_size())

    def _vispy_warmup(self):
        """Provided for VisPy tests, so they can 'warm the canvas up'.
        Mostly taken from the wxWidgets backend.
        """
        tk_inst = _TkInstanceManager.get_tk_instance()

        etime = time() + 0.3
        while time() < etime:
            sleep(0.01)
            self._vispy_canvas.set_current()
            self._vispy_canvas.app.process_events()

            tk_inst.after(0, lambda: tk_inst.quit())
            tk_inst.mainloop()

    def _parse_state(self, e):
        """Helper to parse event.state into modifier keys.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.

        Returns
        -------
        list
            A list of modifier keys that are active (from vispy's keys)
        """
        return [key for mask, key in KEY_STATE_MAP.items() if e.state & mask]

    def _parse_keys(self, e):
        """Helper to parse key states into Vispy keys.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.

        Returns
        -------
        tuple
            A tuple (key.Key(), chr(key)), which has the vispy key object and
            the character representation if available.
        """
        if e.keysym_num in KEYMAP:
            return KEYMAP[e.keysym_num], ""
        # e.char, e.keycode, e.keysym, e.keysym_num
        if e.char:
            self._dynamic_keymap[e.keycode] = e.char
            return keys.Key(e.char), e.char

        if e.keycode in self._dynamic_keymap:
            char = self._dynamic_keymap[e.keycode]
            return keys.Key(char), char

        warnings.warn("The key you typed is not supported by the tkinter backend."
                      "Please map your functionality to a different key")
        return None, None

    def _on_mouse_enter(self, e):
        """Event callback when the mouse enters the canvas.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.
        """
        if self._vispy_canvas is None:
            return
        if _tk_on_linux:
            # On Linux, bind wheel as buttons instead
            self.bind_all("<Button-4>", self._on_mouse_wheel)
            self.bind_all("<Button-5>", self._on_mouse_wheel)
        else:
            # Other platforms, bind wheel event
            # FIXME: What to do on Darwin?
            self.bind_all("<MouseWheel>", self._on_mouse_wheel)

        self._vispy_mouse_move(
            pos=(e.x, e.y),
            buttons=self._pressed_mouse_buttons(e.state),
            modifiers=self._parse_state(e),
        )

    def _on_mouse_leave(self, e):
        """Event callback when the mouse leaves the canvas.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.
        """
        if self._vispy_canvas is None:
            return
        # Unbind mouse wheel events when not over the canvas any more.
        if _tk_on_linux:
            self.unbind_all("<Button-4>")
            self.unbind_all("<Button-5>")
        else:
            self.unbind_all("<MouseWheel>")

    def _on_mouse_move(self, e):
        """Event callback when the mouse is moved within the canvas.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.
        """
        if self._vispy_canvas is None:
            return
        self._vispy_mouse_move(
            pos=(e.x, e.y), buttons=self._pressed_mouse_buttons(e.state), modifiers=self._parse_state(e))

    def _on_mouse_wheel(self, e):
        """Event callback when the mouse wheel changes within the canvas.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.
        """
        if self._vispy_canvas is None:
            return
        if _tk_on_linux:
            # Fix mouse wheel delta
            e.delta = {4: 120, 5: -120}.get(e.num, 0)
        self._vispy_canvas.events.mouse_wheel(
            delta=(0.0, float(e.delta / 120)),
            pos=(e.x, e.y),
            buttons=self._pressed_mouse_buttons(e.state),
            modifiers=self._parse_state(e),
        )

    def _pressed_mouse_buttons(self, state: int) -> list[int]:
        """Determine which mouse buttons are currently pressed based on the tkinter event state."""
        return [key for mask, key in MOUSE_STATE_MAP.items() if state & mask]

    def _on_mouse_button_press(self, e):
        """Event callback when a mouse button is pressed within the canvas.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.
        """
        if self._vispy_canvas is None:
            return
        # Ignore MouseWheel on linux
        if _tk_on_linux and e.num in (4, 5):
            return
        self._vispy_mouse_press(
            pos=(e.x, e.y),
            button=MOUSE_BUTTON_MAP.get(e.num, e.num),
            buttons=self._pressed_mouse_buttons(e.state),
            modifiers=self._parse_state(e),
        )

    def _vispy_detect_double_click(self, e):
        """Override base class function
        since double click handling is native in Tk.
        """
        pass

    def _on_mouse_double_button_press(self, e):
        """Event callback when a mouse button is double clicked within the canvas.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.
        """
        if self._vispy_canvas is None:
            return
        # Ignore MouseWheel on linux
        if _tk_on_linux and e.num in (4, 5):
            return
        self._vispy_mouse_double_click(
            pos=(e.x, e.y),
            button=MOUSE_BUTTON_MAP.get(e.num, e.num),
            buttons=self._pressed_mouse_buttons(e.state),
            modifiers=self._parse_state(e),
        )

    def _on_mouse_button_release(self, e):
        """Event callback when a mouse button is released within the canvas.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.
        """
        if self._vispy_canvas is None:
            return
        # Ignore MouseWheel on linux
        if _tk_on_linux and e.num in (4, 5):
            return
        self._vispy_mouse_release(
            pos=(e.x, e.y),
            button=MOUSE_BUTTON_MAP.get(e.num, e.num),
            buttons=self._pressed_mouse_buttons(e.state),
            modifiers=self._parse_state(e),
        )

    def _on_key_down(self, e):
        """Event callback when a key is pressed within the canvas or window.

        Ignore keys.ESCAPE if this is an embedded canvas,
        as this would make it unresponsive (because it won't close the entire window),
        while still being updateable.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.
        """
        if self._vispy_canvas is None:
            return
        key, text = self._parse_keys(e)
        if not self.top and key == keys.ESCAPE:
            return
        self._vispy_canvas.events.key_press(
            key=key, text=text, modifiers=self._parse_state(e))

    def _on_key_up(self, e):
        """Event callback when a key is released within the canvas or window.

        Ignore keys.ESCAPE if this is an embedded canvas,
        as this would make it unresponsive (because it won't close the entire window),
        while still being updateable.

        Parameters
        ----------
        e : tk.Event
            The passed in Event.
        """
        if self._vispy_canvas is None:
            return
        key, text = self._parse_keys(e)
        if not self.top and key == keys.ESCAPE:
            return
        self._vispy_canvas.events.key_release(
            key=key, text=text, modifiers=self._parse_state(e))

    def _vispy_set_current(self):
        """Make this the current context."""
        if not self.is_destroyed:
            self.tkMakeCurrent()

    def _vispy_swap_buffers(self):
        """Swap front and back buffer. This is done internally inside OpenGLFrame."""
        self._vispy_canvas.set_current()

    def _vispy_set_title(self, title):
        """Set the window title. Has no effect for widgets."""
        if self.top:
            self.top.title(title)

    def _vispy_set_size(self, w, h):
        """Set size of the window. Has no effect for widgets."""
        if self.top:
            self.top.geometry(f"{w}x{h}")

    def _vispy_set_position(self, x, y):
        """Set location of the window. Has no effect for widgets."""
        if self.top:
            self.top.geometry(f"+{x}+{y}")

    def _vispy_set_visible(self, visible):
        """Show or hide the window. Has no effect for widgets."""
        if self.top:
            if visible:
                self.top.wm_deiconify()
                self.top.lift()
                self.top.attributes('-fullscreen', self._fullscreen)
            else:
                self.top.withdraw()

    def _vispy_set_fullscreen(self, fullscreen):
        """Set the current fullscreen state.

        Has no effect for widgets. If you want it to become fullscreen,
        while embedded in another Toplevel window, you should make that
        window fullscreen instead.
        """
        self._fullscreen = bool(fullscreen)
        if self.top:
            self._vispy_set_visible(True)

    def _vispy_update(self):
        """Invoke a redraw

        Delay this by letting Tk call it later, even a delay of 0 will do.
        Doing this, prevents EventEmitter loops that are caused
        by wanting to draw too fast.
        """
        self.after(0, self._delayed_update)

    def _vispy_close(self):
        """Force the window to close, destroying the canvas in the process.

        When this was the last VisPy window, also quit the Tk instance.
        This will not interfere if there is already another user window,
        unrelated top VisPy open.
        """
        if self.top and not self.is_destroyed:
            self.is_destroyed = True
            self._vispy_canvas.close()
            _TkInstanceManager.del_toplevel(self)

    def destroy(self):
        """Callback when the window gets closed.
        Destroy the VisPy canvas by calling close on it.
        """
        self._vispy_canvas.close()

    def _vispy_get_size(self):
        """Return the actual size of the frame."""
        if self.top:
            self.top.update_idletasks()
        return self.winfo_width(), self.winfo_height()

    def _vispy_get_position(self):
        """Return the widget or window position."""
        return self.winfo_x(), self.winfo_y()

    def _vispy_get_fullscreen(self):
        """Return the last set full screen state, regardless if it's actually in that state.

        When using the canvas as a widget, it will not go into fullscreen.
        See _vispy_set_fullscreen
        """
        return self._fullscreen


# ------------------------------------------------------------------- timer ---

class TimerBackend(BaseTimerBackend):
    def __init__(self, vispy_timer):
        BaseTimerBackend.__init__(self, vispy_timer)
        self._tk = _TkInstanceManager.get_tk_instance()
        if self._tk is None:
            raise Exception("TimerBackend: No toplevel?")
        self._id = None
        self.last_interval = 1

    def _vispy_start(self, interval):
        """Start the timer.
        Use Tk.after to schedule timer events.
        """
        self._vispy_stop()
        self.last_interval = max(0, int(round(interval * 1000)))
        self._id = self._tk.after(self.last_interval, self._vispy_timeout)

    def _vispy_stop(self):
        """Stop the timer.
        Unschedule the previous callback if it exists.
        """
        if self._id is not None:
            self._tk.after_cancel(self._id)
            self._id = None

    def _vispy_timeout(self):
        """Callback when the timer finishes.
        Also reschedules the next callback.
        """
        self._vispy_timer._timeout()
        self._id = self._tk.after(self.last_interval, self._vispy_timeout)