import subprocess
import sys
import tkinter as tk
from collections import deque
from os import system
from pathlib import Path
from time import sleep, time
from tkinter import PhotoImage
from tkinter.font import Font
from typing import (
    TYPE_CHECKING,
    Any,
    Callable,
    Deque,
    Dict,
    List,
    Optional,
    Set,
    Tuple,
    TypeVar,
    Union,
)


try:
    # noinspection PyUnresolvedReferences
    from PIL import Image, ImageTk

    print("Bibliothèque PIL chargée.", file=sys.stderr)
    PIL_AVAILABLE = True
except ImportError as e:
    PIL_AVAILABLE = False

if TYPE_CHECKING:
    from typing_extensions import Literal

    Anchor = Literal["nw", "n", "ne", "w", "center", "e", "sw", "s", "se"]
    TkEvent = tk.Event[tk.BaseWidget]
else:
    Anchor = str
    TkEvent = tk.Event
FltkEvent = Tuple[str, Optional[TkEvent]]

__all__ = [
    # gestion de fenêtre
    "cree_fenetre",
    "ferme_fenetre",
    "redimensionne_fenetre",
    "mise_a_jour",
    # dessin
    "ligne",
    "fleche",
    "polygone",
    "rectangle",
    "cercle",
    "point",
    "image",
    "texte",
    "taille_texte",
    # effacer
    "efface_tout",
    "efface",
    # utilitaires
    "attente",
    "capture_ecran",
    "touche_pressee",
    "abscisse_souris",
    "ordonnee_souris",
    "hauteur_fenetre",
    "largeur_fenetre",
    # événements
    "donne_ev",
    "attend_ev",
    "attend_clic_gauche",
    "attend_fermeture",
    "type_ev",
    "abscisse",
    "ordonnee",
    "touche",
]


class CustomCanvas:
    """
    Classe qui encapsule tous les objets tkinter nécessaires à la création
    d'un canevas.
    """

    _on_osx = sys.platform.startswith("darwin")

    _ev_mapping = {
        "ClicGauche": "<Button-1>",
        "ClicMilieu": "<Button-2>",
        "ClicDroit": "<Button-2>" if _on_osx else "<Button-3>",
        "Deplacement": "<Motion>",
        "Touche": "<Key>",
        "Redimension": "<Configure>",
    }

    _default_ev = ["ClicGauche", "ClicDroit", "Touche"]

    def __init__(
            self,
            width: int,
            height: int,
            refresh_rate: int = 100,
            events: Optional[List[str]] = None,
            resizing: bool = False,
    ) -> None:
        # width and height of the canvas
        self.width = width
        self.height = height
        self.interval = 1 / refresh_rate

        # root Tk object
        self.root = tk.Tk()

        # canvas attached to the root object
        self.canvas = tk.Canvas(
            self.root, width=width, height=height, highlightthickness=0
        )

        # adding the canvas to the root window and giving it focus
        self.canvas.pack(fill=tk.BOTH, expand=tk.YES)
        self.root.resizable(width=resizing, height=resizing)
        self.canvas.focus_set()
        self.first_resize = True

        # binding events
        self.ev_queue: Deque[FltkEvent] = deque()
        self.pressed_keys: Set[str] = set()
        self.events = CustomCanvas._default_ev if events is None else events
        self.bind_events()

        # update for the first time
        self.last_update = time()
        self.root.update()

        if CustomCanvas._on_osx:
            system(
                """/usr/bin/osascript -e 'tell app "Finder" \
                   to set frontmost of process "Python" to true' """
            )

    def update(self) -> None:
        t = time()
        self.root.update()
        sleep(max(0.0, self.interval - (t - self.last_update)))
        self.last_update = time()

    def resize(self, width: int, height: int) -> None:
        self.root.geometry(f"{int(width)}x{int(height)}")

    def bind_events(self) -> None:
        self.root.protocol("WM_DELETE_WINDOW", self.event_quit)
        self.canvas.bind("<Configure>", self.event_resize)
        self.canvas.bind("<KeyPress>", self.register_key)
        self.canvas.bind("<KeyRelease>", self.release_key)
        for name in self.events:
            self.bind_event(name)

    # noinspection PyUnresolvedReferences
    def register_key(self, ev: TkEvent) -> None:
        self.pressed_keys.add(ev.keysym)

    # noinspection PyUnresolvedReferences
    def release_key(self, ev: TkEvent) -> None:
        if ev.keysym in self.pressed_keys:
            self.pressed_keys.remove(ev.keysym)

    def event_quit(self) -> None:
        self.ev_queue.append(("Quitte", None))

    # noinspection PyUnresolvedReferences
    def event_resize(self, event: TkEvent) -> None:
        if event.widget.widgetName == "canvas":
            if self.width != event.width or self.height != event.height:
                self.width, self.height = event.width, event.height
                if not self.ev_queue or self.ev_queue[-1][0] != "Redimension":
                    self.ev_queue.append(("Redimension", event))

    def bind_event(self, name: str) -> None:
        e_type = CustomCanvas._ev_mapping.get(name, name)

        def handler(event: TkEvent, _name: str = name) -> None:
            self.ev_queue.append((_name, event))

        self.canvas.bind(e_type, handler, "+")

    def unbind_event(self, name: str) -> None:
        e_type = CustomCanvas._ev_mapping.get(name, name)
        self.canvas.unbind(e_type)


__canevas: Optional[CustomCanvas] = None
__img: Dict[Tuple[Path, int, int], PhotoImage] = {}


#############################################################################
# Exceptions
#############################################################################


class TypeEvenementNonValide(Exception):
    pass


class FenetreNonCree(Exception):
    pass


class FenetreDejaCree(Exception):
    pass


Ret = TypeVar("Ret")


def _fenetre_cree(func: Callable[..., Ret]) -> Callable[..., Ret]:
    def new_func(*args: Any, **kwargs: Any) -> Ret:
        if __canevas is None:
            raise FenetreNonCree(
                'La fenêtre n\'a pas été crée avec la fonction "cree_fenetre".'
            )
        return func(*args, **kwargs)

    return new_func


#############################################################################
# Initialisation, mise à jour et fermeture
#############################################################################


def cree_fenetre(
        largeur: int, hauteur: int, frequence: int = 100,
        redimension: bool = False
) -> None:
    """
    Crée une fenêtre de dimensions ``largeur`` x ``hauteur`` pixels.
    :rtype:
    """
    global __canevas
    if __canevas is not None:
        raise FenetreDejaCree(
            'La fenêtre a déjà été crée avec la fonction "cree_fenetre".'
        )
    __canevas = CustomCanvas(largeur, hauteur, frequence, resizing=redimension)


@_fenetre_cree
def ferme_fenetre() -> None:
    """
    Détruit la fenêtre.
    """
    global __canevas
    assert __canevas is not None
    __canevas.root.destroy()
    __canevas = None


@_fenetre_cree
def redimensionne_fenetre(largeur: int, hauteur: int) -> None:
    """
    Fixe les dimensions de la fenêtre à (``hauteur`` x ``largeur``) pixels.

    Le contenu du canevas n'est pas automatiquement mis à l'échelle et doit
    être redessiné si nécessaire.
    """
    assert __canevas is not None
    __canevas.resize(width=largeur, height=hauteur)


@_fenetre_cree
def mise_a_jour() -> None:
    """
    Met à jour la fenêtre. Les dessins ne sont affichés qu'après
    l'appel à  cette fonction.
    """
    assert __canevas is not None
    __canevas.update()


#############################################################################
# Fonctions de dessin
#############################################################################


# Formes géométriques


@_fenetre_cree
def ligne(
        ax: float,
        ay: float,
        bx: float,
        by: float,
        couleur: str = "black",
        epaisseur: float = 1,
        tag: str = "",
) -> int:
    """
    Trace un segment reliant le point ``(ax, ay)`` au point ``(bx, by)``.

    :param float ax: abscisse du premier point
    :param float ay: ordonnée du premier point
    :param float bx: abscisse du second point
    :param float by: ordonnée du second point
    :param str couleur: couleur de trait (défaut 'black')
    :param float epaisseur: épaisseur de trait en pixels (défaut 1)
    :param str tag: étiquette d'objet (défaut : pas d'étiquette)
    :return: identificateur d'objet
    """
    assert __canevas is not None
    return __canevas.canvas.create_line(
        ax, ay, bx, by, fill=couleur, width=epaisseur, tags=tag
    )


@_fenetre_cree
def fleche(
        ax: float,
        ay: float,
        bx: float,
        by: float,
        couleur: str = "black",
        epaisseur: float = 1,
        tag: str = "",
) -> int:
    """
    Trace une flèche du point ``(ax, ay)`` au point ``(bx, by)``.

    :param float ax: abscisse du premier point
    :param float ay: ordonnée du premier point
    :param float bx: abscisse du second point
    :param float by: ordonnée du second point
    :param str couleur: couleur de trait (défaut 'black')
    :param float epaisseur: épaisseur de trait en pixels (défaut 1)
    :param str tag: étiquette d'objet (défaut : pas d'étiquette)
    :return: identificateur d'objet
    """
    x, y = (bx - ax, by - ay)
    n = (x ** 2 + y ** 2) ** 0.5
    x, y = x / n, y / n
    points = [
        bx,
        by,
        bx - x * 5 - 2 * y,
        by - 5 * y + 2 * x,
        bx - x * 5 + 2 * y,
        by - 5 * y - 2 * x,
    ]
    assert __canevas is not None
    return __canevas.canvas.create_polygon(
        points, fill=couleur, outline=couleur, width=epaisseur, tags=tag
    )


@_fenetre_cree
def polygone(
        points: List[float],
        couleur: str = "black",
        remplissage: str = "",
        epaisseur: float = 1,
        tag: str = "",
) -> int:
    """
    Trace un polygone dont la liste de points est fournie.

    :param list points: liste de couples (abscisse, ordonnee) de points
    :param str couleur: couleur de trait (défaut 'black')
    :param str remplissage: couleur de fond (défaut transparent)
    :param float epaisseur: épaisseur de trait en pixels (défaut 1)
    :param str tag: étiquette d'objet (défaut : pas d'étiquette)
    :return: identificateur d'objet
    """
    assert __canevas is not None
    return __canevas.canvas.create_polygon(
        points, fill=remplissage, outline=couleur, width=epaisseur, tags=tag
    )


@_fenetre_cree
def rectangle(
        ax: float,
        ay: float,
        bx: float,
        by: float,
        couleur: str = "black",
        remplissage: str = "",
        epaisseur: float = 1,
        tag: str = "",
) -> int:
    """
    Trace un rectangle noir ayant les point ``(ax, ay)`` et ``(bx, by)``
    comme coins opposés.

    :param float ax: abscisse du premier coin
    :param float ay: ordonnée du premier coin
    :param float bx: abscisse du second coin
    :param float by: ordonnée du second coin
    :param str couleur: couleur de trait (défaut 'black')
    :param str remplissage: couleur de fond (défaut transparent)
    :param float epaisseur: épaisseur de trait en pixels (défaut 1)
    :param str tag: étiquette d'objet (défaut : pas d'étiquette)
    :return: identificateur d'objet
    """
    assert __canevas is not None
    return __canevas.canvas.create_rectangle(
        ax, ay, bx, by,
        outline=couleur, fill=remplissage, width=epaisseur, tags=tag
    )


@_fenetre_cree
def cercle(
        x: float,
        y: float,
        r: float,
        couleur: str = "black",
        remplissage: str = "",
        epaisseur: float = 1,
        tag: str = "",
) -> int:
    """
    Trace un cercle de centre ``(x, y)`` et de rayon ``r`` en noir.

    :param float x: abscisse du centre
    :param float y: ordonnée du centre
    :param float r: rayon
    :param str couleur: couleur de trait (défaut 'black')
    :param str remplissage: couleur de fond (défaut transparent)
    :param float epaisseur: épaisseur de trait en pixels (défaut 1)
    :param str tag: étiquette d'objet (défaut : pas d'étiquette)
    :return: identificateur d'objet
    """
    assert __canevas is not None
    return __canevas.canvas.create_oval(
        x - r,
        y - r,
        x + r,
        y + r,
        outline=couleur,
        fill=remplissage,
        width=epaisseur,
        tags=tag,
    )


@_fenetre_cree
def arc(
        x: float,
        y: float,
        r: float,
        ouverture: float = 90,
        depart: float = 0,
        couleur: str = "black",
        remplissage: str = "",
        epaisseur: float = 1,
        tag: str = "",
) -> int:
    """
    Trace un arc de cercle de centre ``(x, y)``, de rayon ``r`` et
    d'angle d'ouverture ``ouverture`` (défaut : 90 degrés, dans le sens
    contraire des aiguilles d'une montre) depuis l'angle initial ``depart``
    (défaut : direction 'est').

    :param float x: abscisse du centre
    :param float y: ordonnée du centre
    :param float r: rayon
    :param float ouverture: abscisse du centre
    :param float depart: ordonnée du centre
    :param str couleur: couleur de trait (défaut 'black')
    :param str remplissage: couleur de fond (défaut transparent)
    :param float epaisseur: épaisseur de trait en pixels (défaut 1)
    :param str tag: étiquette d'objet (défaut : pas d'étiquette)
    :return: identificateur d'objet
    """
    assert __canevas is not None
    return __canevas.canvas.create_arc(
        x - r,
        y - r,
        x + r,
        y + r,
        extent=ouverture,
        start=depart,
        style=tk.ARC,
        outline=couleur,
        fill=remplissage,
        width=epaisseur,
        tags=tag,
    )


@_fenetre_cree
def point(
        x: float, y: float,
        couleur: str = "black", epaisseur: float = 1,
        tag: str = ""
) -> int:
    """
    Trace un point aux coordonnées ``(x, y)`` en noir.

    :param float x: abscisse
    :param float y: ordonnée
    :param str couleur: couleur du point (défaut 'black')
    :param float epaisseur: épaisseur de trait en pixels (défaut 1)
    :param str tag: étiquette d'objet (défaut : pas d'étiquette)
    :return: identificateur d'objet
    """
    assert __canevas is not None
    return cercle(x, y, epaisseur,
                  couleur=couleur, remplissage=couleur, tag=tag)


# Image


@_fenetre_cree
def image(
        x: float,
        y: float,
        fichier: str,
        largeur: Optional[int] = None,
        hauteur: Optional[int] = None,
        ancrage: Anchor = "center",
        tag: str = "",
) -> int:
    """
    Affiche l'image contenue dans ``fichier`` avec ``(x, y)`` comme centre. Les
    valeurs possibles du point d'ancrage sont ``'center'``, ``'nw'``,
    etc. Les arguments optionnels ``largeur`` et ``hauteur`` permettent de
    spécifier des dimensions maximales pour l'image (sans changement de
    proportions).

    :param largeur: largeur de l'image
    :param hauteur: hauteur de l'image
    :param float x: abscisse du point d'ancrage
    :param float y: ordonnée du point d'ancrage
    :param str fichier: nom du fichier contenant l'image
    :param ancrage: position du point d'ancrage par rapport à l'image
    :param str tag: étiquette d'objet (défaut : pas d'étiquette)
    :return: identificateur d'objet
    """
    assert __canevas is not None
    if PIL_AVAILABLE:
        tk_image = _load_pil_image(fichier, hauteur, largeur)
    else:
        tk_image = _load_tk_image(fichier, hauteur, largeur)
    img_object = __canevas.canvas.create_image(
        x, y, anchor=ancrage, image=tk_image, tags=tag
    )
    return img_object


def _load_tk_image(fichier: str,
                   hauteur: Optional[int] = None,
                   largeur: Optional[int] = None) -> PhotoImage:
    chemin = Path(fichier)
    ph_image = PhotoImage(file=fichier)
    largeur_o = ph_image.width()
    hauteur_o = ph_image.height()
    if largeur is None:
        largeur = largeur_o
    if hauteur is None:
        hauteur = hauteur_o
    zoom_l = max(1, largeur // largeur_o)
    zoom_h = max(1, hauteur // hauteur_o)
    red_l = max(1, largeur_o // largeur)
    red_h = max(1, hauteur_o // hauteur)
    largeur = largeur_o * zoom_l // red_l
    hauteur = hauteur_o * zoom_h // red_h
    if (chemin, largeur, hauteur) in __img:
        return __img[(chemin, largeur, hauteur)]
    ph_image = ph_image.zoom(zoom_l, zoom_h)
    ph_image = ph_image.subsample(red_l, red_h)
    __img[(chemin, largeur, hauteur)] = ph_image
    return ph_image


def _load_pil_image(fichier: str,
                    hauteur: Optional[int] = None,
                    largeur: Optional[int] = None) -> PhotoImage:
    chemin = Path(fichier)
    img = Image.open(fichier)
    if largeur is None:
        largeur = img.width
    if hauteur is None:
        hauteur = img.height
    if (chemin, largeur, hauteur) in __img:
        return __img[(chemin, largeur, hauteur)]
    img = img.resize((largeur, hauteur))
    ph_image = ImageTk.PhotoImage(img)
    __img[(chemin, largeur, hauteur)] = ph_image  # type:ignore
    return ph_image  # type:ignore


# Texte


@_fenetre_cree
def texte(
        x: float,
        y: float,
        chaine: str,
        couleur: str = "black",
        ancrage: Anchor = "nw",
        police: str = "Helvetica",
        taille: int = 24,
        tag: str = "",
) -> int:
    """
    Affiche la chaîne ``chaine`` avec ``(x, y)`` comme point d'ancrage (par
    défaut le coin supérieur gauche).

    :param float x: abscisse du point d'ancrage
    :param float y: ordonnée du point d'ancrage
    :param str chaine: texte à afficher
    :param str couleur: couleur de trait (défaut 'black')
    :param ancrage: position du point d'ancrage (défaut 'nw')
    :param police: police de caractères (défaut : `Helvetica`)
    :param taille: taille de police (défaut 24)
    :param tag: étiquette d'objet (défaut : pas d'étiquette
    :return: identificateur d'objet
    """
    assert __canevas is not None
    return __canevas.canvas.create_text(
        x, y,
        text=chaine, font=(police, taille),
        tags=tag, fill=couleur, anchor=ancrage
    )


def taille_texte(
        chaine: str, police: str = "Helvetica", taille: int = 24
) -> Tuple[int, int]:
    """
    Donne la largeur et la hauteur en pixel nécessaires pour afficher
    ``chaine`` dans la police et la taille données.

    :param str chaine: chaîne à mesurer
    :param police: police de caractères (défaut : `Helvetica`)
    :param taille: taille de police (défaut 24)
    :return: couple (w, h) constitué de la largeur et la hauteur de la chaîne
        en pixels (int), dans la police et la taille données.
    """
    font = Font(family=police, size=taille)
    return font.measure(chaine), font.metrics("linespace")


#############################################################################
# Effacer
#############################################################################


@_fenetre_cree
def efface_tout() -> None:
    """
    Efface la fenêtre.
    """
    assert __canevas is not None
    __canevas.canvas.delete("all")


@_fenetre_cree
def efface(objet_ou_tag: Union[int, str]) -> None:
    """
    Efface ``objet`` de la fenêtre.

    :param: objet ou étiquette d'objet à supprimer
    :type: ``int`` ou ``str``
    """
    assert __canevas is not None
    __canevas.canvas.delete(objet_ou_tag)


#############################################################################
# Utilitaires
#############################################################################


def attente(temps: float) -> None:
    start = time()
    while time() - start < temps:
        mise_a_jour()


@_fenetre_cree
def capture_ecran(file: str) -> None:
    """
    Fait une capture d'écran sauvegardée dans ``file.png``.
    """
    assert __canevas is not None
    __canevas.canvas.postscript(  # type: ignore
        file=file + ".ps",
        height=__canevas.height,
        width=__canevas.width,
        colormode="color",
    )

    subprocess.call(
        "convert -density 150 -geometry 100% -background white -flatten"
        " " + file + ".ps " + file + ".png",
        shell=True,
    )
    subprocess.call("rm " + file + ".ps", shell=True)


@_fenetre_cree
def touche_pressee(keysym: str) -> bool:
    """
    Renvoie `True` si ``keysym`` est actuellement pressée.
    :param keysym: symbole associé à la touche à tester.
    :return: `True` si ``keysym`` est actuellement pressée, `False` sinon.
    """
    assert __canevas is not None
    return keysym in __canevas.pressed_keys


#############################################################################
# Gestions des évènements
#############################################################################


@_fenetre_cree
def donne_ev() -> Optional[FltkEvent]:
    """
    Renvoie immédiatement l'événement en attente le plus ancien,
    ou ``None`` si aucun événement n'est en attente.
    """
    assert __canevas is not None
    if not __canevas.ev_queue:
        return None
    return __canevas.ev_queue.popleft()


def attend_ev() -> FltkEvent:
    """Attend qu'un événement ait lieu et renvoie le premier événement qui
    se produit."""
    while True:
        ev = donne_ev()
        if ev is not None:
            return ev
        mise_a_jour()


def attend_clic_gauche() -> Tuple[int, int]:
    """Attend qu'un clic gauche sur la fenêtre ait lieu et renvoie ses
    coordonnées. **Attention**, cette fonction empêche la détection d'autres
    événements ou la fermeture de la fenêtre."""
    while True:
        ev = donne_ev()
        if ev is not None and type_ev(ev) == "ClicGauche":
            x, y = abscisse(ev), ordonnee(ev)
            assert isinstance(x, int) and isinstance(y, int)
            return x, y
        mise_a_jour()


def attend_fermeture() -> None:
    """Attend la fermeture de la fenêtre. Cette fonction renvoie None.
    **Attention**, cette fonction empêche la détection d'autres événements."""
    while True:
        ev = donne_ev()
        if ev is not None and type_ev(ev) == "Quitte":
            ferme_fenetre()
            return
        mise_a_jour()


def type_ev(ev: Optional[FltkEvent]) -> Optional[str]:
    """
    Renvoie une chaîne donnant le type de ``ev``. Les types
    possibles sont 'ClicDroit', 'ClicGauche', 'Touche' et 'Quitte'.
    Renvoie ``None`` si ``evenement`` vaut ``None``.
    """
    return ev if ev is None else ev[0]


def abscisse(ev: Optional[FltkEvent]) -> Optional[int]:
    """
    Renvoie la coordonnée x associé à ``ev`` si elle existe, None sinon.
    """
    x = attribut(ev, "x")
    assert isinstance(x, int) or x is None
    return x


def ordonnee(ev: Optional[FltkEvent]) -> Optional[int]:
    """
    Renvoie la coordonnée y associé à ``ev`` si elle existe, None sinon.
    """
    y = attribut(ev, "y")
    assert isinstance(y, int) or y is None
    return y


def touche(ev: Optional[FltkEvent]) -> str:
    """
    Renvoie une chaîne correspondant à la touche associé à ``ev``,
    si elle existe.
    """
    keysym = attribut(ev, "keysym")
    assert isinstance(keysym, str)
    return keysym


def attribut(ev: Optional[FltkEvent], nom: str) -> Any:
    if ev is None:
        raise TypeEvenementNonValide(
            f"Accès à l'attribut {nom} impossible sur un événement vide"
        )
    tev, evtk = ev
    if not hasattr(evtk, nom):
        raise TypeEvenementNonValide(
            f"Accès à l'attribut {nom} impossible "
            f"sur un événement de type {tev}"
        )
    attr = getattr(evtk, nom)
    return attr if attr != "??" else None


@_fenetre_cree
def abscisse_souris() -> int:
    assert __canevas is not None
    return __canevas.canvas.winfo_pointerx() - __canevas.canvas.winfo_rootx()


@_fenetre_cree
def ordonnee_souris() -> int:
    assert __canevas is not None
    return __canevas.canvas.winfo_pointery() - __canevas.canvas.winfo_rooty()


@_fenetre_cree
def largeur_fenetre() -> int:
    assert __canevas is not None
    return __canevas.width


@_fenetre_cree
def hauteur_fenetre() -> int:
    assert __canevas is not None
    return __canevas.height