#include <EEPROM.h>
#include "entree.hpp"
#include "sortie.hpp"
#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"



// CONFIGURATION

SoftwareSerial Serial2( A0, A1 );        // pins RX et TX du module MP3
uint8_t mp3_volume = 20;                 // volume des sons entre 0 et 30
uint8_t mp3_eq     = DFPLAYER_EQ_NORMAL; // DFPLAYER_EQ_<mode> : NORMAL, POP, ROCK, JAZZ, CLASSIC, BASS

Sortie verrou( 2 );                // La sortie à activer lorsque la combinaison est correcte
Sortie led_status( LED_BUILTIN );  // LED status (utilisée lors de l'enregistrement)

Entree bouton_enregistrement( 4 ); // pin pour le bouton d'enregistrement de la séquence

Entree entrees[] =
{
  { 12, INPUT_PULLUP, true }, // entrée 1 - switch 1
  { 11, INPUT_PULLUP, true }, // entrée 2 - switch 2
  { 10, INPUT_PULLUP, true }, // entrée 3 - switch 3
  {  9, INPUT_PULLUP, true }, // entrée 4 - switch 4
  {  8, INPUT_PULLUP, true }, // entrée 5 - switch 5
  {  7, INPUT_PULLUP, true }, // entrée 6 - switch 6
  {  6, INPUT_PULLUP, true }, // entrée 7 - switch 7
  {  5, INPUT_PULLUP, true }, // entrée 8 - switch 8
};


// FIN DE LA CONFIGURATION



const uint8_t nb_entrees = sizeof( entrees ) / sizeof( entrees[0] );
bool enregistrement = false;
bool mp3_ok = true;
DFRobotDFPlayerMini mp3;


struct puzzle_t
{
  uint8_t version;
  bool defini;
  uint8_t combinaisons[2];
  bool etat_initial;

  bool afficher_etat()
  {
    Serial.print( F( "Le puzzle " ) );
    Serial.print( etat_initial == true ? F( "est" ) : F( "n'est pas" ) );
    Serial.println( F( " à son état initial." ) );
  }

  bool verifier_combinaison( uint8_t index )
  {
    uint8_t combinaison = combinaisons[ index ];
    bool ok = true;

    for ( uint8_t i = 0; i < nb_entrees; ++i )
    {
      if ( entrees[i].etat() != ( ( ( combinaison >> ( nb_entrees - 1 - i ) ) & 1 ) == 1 ) )
      {
        ok = false;
        break;
      }
    }
    
    if ( index == 0 )
    {
      etat_initial = ok;
    }

    return ok;
  }

  void afficher()
  {
    Serial.print( F( "La version du puzzle est: v" ) );
    Serial.println( version );

    Serial.println( F( "L'état initial est: " ) );
    for ( uint8_t i = 0; i < nb_entrees; ++i )
    {
      Serial.print( F( "Entrée " ) );
      Serial.print( i + 1 );
      Serial.print( F( " " ) );
      Serial.println( ( ( ( combinaisons[0] >> ( nb_entrees - 1 - i ) ) & 1 ) == 1 ) ? F( "HIGH" ) : F( "LOW" ) );
    }

    Serial.println( F( "La combinaison est: " ) );
    for ( uint8_t i = 0; i < nb_entrees; ++i )
    {
      Serial.print( F( "Entrée " ) );
      Serial.print( i + 1 );
      Serial.print( F( " " ) );
      Serial.println( ( ( ( combinaisons[1] >> ( nb_entrees - 1 - i ) ) & 1 ) == 1 ) ? F( "HIGH" ) : F( "LOW" ) );
    }
  }
};

puzzle_t puzzle;


void son( uint8_t id )
{
  //if ( mp3_ok == true )
  {
    char son[5];
    snprintf( son, 5, "%04d", (int)id );
    Serial.print( F( "Lecture du son " ) );
    Serial.print( son );
    Serial.println( F( ".mp3" ) );
    mp3.playMp3Folder( id );
  }
}


void gestion_bouton_enregistrement( Entree const & entree )
{
  if ( entree.etat() == true )
  {
    if ( enregistrement == false )
    {
      verrou.off();
      led_status.blink( 500 );

      enregistrement = true;
      Serial.println( F( "\nDéfinir l'état initial du puzzle puis rappuyer sur le bouton d'enregistrement" ) );
    }
    else
    {
      static uint8_t mode = 0;

      uint8_t etats_entrees = 0;
      for ( uint8_t i = 0; i < nb_entrees; ++i )
      {
        bool etat_entree = entrees[i].etat();
        etats_entrees = etats_entrees | ( etat_entree << ( nb_entrees - 1 - i ) );
      }

      if ( mode == 0 )
      {
        mode = 1;
        puzzle.combinaisons[0] = etats_entrees;
        Serial.println( F( "L'état initial du puzzle a été enregistré!" ) );
        Serial.println( F( "\nDéfinir la combinaison du puzzle puis rappuyer sur le bouton d'enregistrement" ) );
      }
      else if ( mode == 1 )
      {
        if ( etats_entrees == puzzle.combinaisons[0] )
        {
          Serial.println( F( "\nErreur : La combinaison du puzzle doit être différente de l'état initial!" ) );
        }
        else
        {
          mode = 0;
          puzzle.version = 1;
          puzzle.defini = true;
          puzzle.etat_initial = false;
          puzzle.combinaisons[1] = etats_entrees;
          puzzle.afficher();
          Serial.println( F( "La combinaison du puzzle a été enregistrée!" ) );
          EEPROM.put( 0, puzzle );
          Serial.println( F( "\nLe puzzle a été sauvegardé!" ) );
          enregistrement = false;
          led_status.off();
        }
      }
    }
  }
}


void gestion_entrees( Entree const & entree )
{
  uint8_t id = entree.id();
  bool etat = entree.etat();

  if ( enregistrement == true )
  {
  }
  else if( puzzle.defini == false )
  {
    Serial.println( F( "Le puzzle n'est pas défini!" ) );
  }
  else
  {
    static bool ok = puzzle.etat_initial;

    if ( ok == false )
    {
      ok = puzzle.verifier_combinaison( 0 );
      puzzle.afficher_etat();

      if ( ok == true )
      {
        son( nb_entrees + 2 );
        led_status.off();
        verrou.off();
      }
    }

    else //if ( ok == true )
    {
      if ( puzzle.verifier_combinaison( 1 ) == true )
      {
        ok = false;
        Serial.println( F( "La porte est déverrouillée!" ) );
        led_status.blink( 250, 5 );
        verrou.on();
        son( nb_entrees + 1 );
      }

      else if ( etat == true )
      {
        son( id );
      }
    }
  }
}


void setup()
{
  Serial.begin( 115200 );
  Serial2.begin( 9600 );

  Serial.print( F( "Connexion au module MP3" ) );
  while ( !mp3.begin( Serial2 ) )
  {
    Serial.print( F( "." ) );
    static uint8_t compteur = 0;
    if ( ++compteur == 10 )
    {
      mp3_ok = false;
      break;
    }
  }

  if ( mp3_ok == true )
  {
    Serial.println( F( "OK!" ) );
    mp3.setTimeOut( 500 );
    mp3.volume( mp3_volume );
    mp3.EQ( mp3_eq );
    mp3.outputDevice( DFPLAYER_DEVICE_SD );
  }
  else
  {
    Serial.println( F( "Erreur!" ) );
  }

  bouton_enregistrement.setup( gestion_bouton_enregistrement );

  for ( uint8_t i = 0; i < nb_entrees; ++i )
  {
    entrees[i].setup( gestion_entrees );
  }

  led_status.setup();
  verrou.setup();

  EEPROM.get( 0, puzzle );

  if ( puzzle.version != UINT8_MAX )
  {
    puzzle.afficher();
    puzzle.verifier_combinaison( 0 );
    puzzle.afficher_etat();
  }
  else
  {
    puzzle.defini = false;
    Serial.println( F( "Le puzzle n'est pas défini!" ) );
    Serial.println( F( "1 - Appuyer sur le bouton d'enregistrement pour démarrer l'enregistrement" ) );
    Serial.println( F( "2 - Définir l'état initial du puzzle" ) );
    Serial.println( F( "3 - Appuyer sur le bouton d'enregistrement pour enregistrer l'état initial du puzzle" ) );
    Serial.println( F( "4 - Définir la combinaison du puzzle" ) );
    Serial.println( F( "5 - Appuyer sur le bouton d'enregistrement pour enregistrer la combinaison du puzzle" ) );
  }
}


void loop()
{
  bouton_enregistrement.loop();

  for ( uint8_t i = 0; i < nb_entrees; ++i )
  {
    entrees[i].loop();
  }

  verrou.loop();
  led_status.loop();
}