#!/usr/bin/python3
# -*- coding: utf-8 -*-
"""
test d'aide à l'écriture de message en morse
sur raspberry pi + sense hat

principe : saisie d'un message en morse via le joystick de la sense hat
la grille LED permet d'avoir un retour / analyse de ce qui est saisi
une fois le message construit, transmission via la matrice LED

utilisation du joystick de la sense hat
haut = saisir un point
bas = saisir un trait
droite = valider (selon le contexte : lettre, mot, message), ajouter un espace
gauche = corriger / annuler la dernière entrée

utilise la lib morse-talk pour le decodage / encodage. pour l'installation :
$ pip install morse-talk

utilisation :
$ python sense_morse.py
"""

from sense_hat import SenseHat, ACTION_PRESSED, ACTION_HELD, ACTION_RELEASED
from signal import pause
import time, morse_talk

class MorseSenseHatKeyer:

    green = [0, 255, 0]
    yellow = [255, 255, 0]
    red = [255, 0, 0]

    def __init__(self):
        self.sense = SenseHat()
        # association des evenements générés par le joystick de la SenseHat
        # aux méthodes de traitement internes
        self.sense.stick.direction_up = self.pushed_up
        self.sense.stick.direction_down = self.pushed_down
        self.sense.stick.direction_left = self.pushed_left
        self.sense.stick.direction_right = self.pushed_right
        self.sense.stick.direction_any = self.refresh
        # initalisation des variables de traitement
        self.message_ascii = '' # message construit sous forme ASCII
        self.current_morse_char = '' # caractère morse en cours de construction

    def pushed_left(self, event):
        """ correction (réinitialise caractère courant) """
        # correction
        if event.action != ACTION_RELEASED:
            self.current_morse_char = ''

    def pushed_right(self, event):
        """ validation : caractère, mot, message """
        # selon le cas : validation de la lettre, du mot etc
        if event.action != ACTION_RELEASED:
            if self.current_morse_char == '': # pas de lettre en cours, validation du mot, et affichage
                self.sense.show_message(self.message_ascii)
            elif self.current_morse_char != '': # validation de la lettre
                self.validate_char()

    def pushed_down(self, event):
        """ ajout d'un trait """
        if event.action == ACTION_HELD: # tant que le bouton est pressé
            self.show_dash() # affichage d'un trait
        if event.action == ACTION_RELEASED: # au relachement
            self.add_dash() # ajout du trait si possible

    def pushed_up(self, event):
        """ ajout point """
        if event.action == ACTION_HELD: # tant que le bouton est pressé
            self.show_dot() # affichage d'un point
        if event.action == ACTION_RELEASED:
            self.add_dot() # ajout du point si possible

    def show_dot(self, rgb=None):
        # affichage d'un point sur la matrice LED
        rgb = rgb or [150, 150, 150]
        self.sense.clear()
        for x in range(3, 5):
            for y in range(3, 5):
                self.sense.set_pixel(x, y, rgb)

    def show_dash(self, rgb=None):
        # affichage d'un trait sur la matrice LED
        rgb = rgb or [150, 150, 150]
        self.sense.clear()
        for x in range(1, 7):
            for y in range(3, 5):
                self.sense.set_pixel(x, y, rgb)

    def refresh(self, event):
        pass
        # self.sense.clear()

    def show_char(self, char, rgb=None):
        """ affiche un caractère dans la couleur définie (gris par defaut)"""
        rgb = rgb or [150, 150, 150]
        self.sense.clear()
        self.sense.show_letter(char, rgb)

    def add_dot(self):
        """ ajout d'un point au caractère courant
        tant que le caractère courant reste interpretable
        sinon, affichage d'une erreur et reinitialise le caractère courant """
        try:
            self.current_morse_char += '.'
            char = morse_talk.decode(self.current_morse_char)
            self.show_char(char, self.yellow)
        except KeyError as err: # l'ajout ne donne pas un caractère interprétable
            self.show_char('X', self.red)
            self.current_morse_char = ''

    def add_dash(self):
        """ ajout d'un trait au caractère courant
        tant que le caractère courant reste interpretable
        sinon, affichage d'une erreur et reinitialise le caractère courant """
        self.current_morse_char += '-'
        try:
            char = morse_talk.decode(self.current_morse_char)
            self.show_char(char, self.yellow)
        except KeyError as err: # l'ajout ne donne pas un caractère interprétable
            self.show_char('X', self.red)
            self.current_morse_char = ''

    def show_error(self):
        pass

    def reset_char(self):
        """ annule le caractère courant """
        self.current_morse_char = ''

    def validate_char(self):
        """ valide la lettre courante, et donne un retour visuel """
        char = morse_talk.decode(self.current_morse_char)
        self.show_char(char, self.green)
        self.message_ascii += char
        self.current_morse_char = ''

    def show_message(self):
        """ affiche le message courant """


if __name__ == "__main__": # lors de l'execution du script en standalone
    try:
        keyer = MorseSenseHatKeyer()
        keyer.sense.show_message("morse://", 0.02)
        # waiting for joystick events and directing them to keyer
        pause()
    except (KeyboardInterrupt, SystemExit) as err: # lors d'un CTRL+C pour interruption
        sense = SenseHat()
        sense.show_message('bye', 0.02)
        sense.clear()