#include <Arduino.h>
#include <Adafruit_GFX.h>
#include <Adafruit_NeoPixel.h>
#include <Adafruit_NeoMatrix.h>

#include "constants.h"
#include "bitmaps.h"


/*
 * Infos pour la programmation :
 * Le pixel (0,0) est TOUJOURS situé en haut à gauche de l'écran
 * L'écran fait WIDTH de large par HEIGHT de haut, vous pouvez utiliser ces constantes dans les boucles
 * La luminosité (BRIGHTNESS) est définie par l'utilisateur et donc ne peut pas être modifiée par un jeu
 * Pour pouvoir combiner tous les jeux suivez l'exemple et créer une classe ayant le nom de votre jeu
 *
 *
 * La librairie vous donne accès à des fonctions de dessin la liste est détaille ci-dessous :
 *
 * ATTENTION : TOUTES LES FONCTIONS CI DESSOUS DOIVENT ETRE PREFIXEES DE "matrix."
 * Exemple matrix.Color(1,2,3)
 *
 * - Color(R, G, B) : une couleur représentée selon ses valeurs en rouge (Red), vert (Green) et bleu (Blue) entre 0 et 255
 * La couleur (0,0,0) correspond au noir complet (pixel éteint) et (255,255,255) au blanc le plus blanc
 * Site pour choisir les valeurs pour sa couleur : https://htmlcolorcodes.com/fr/
 *
 * - drawPixel(x, y, color) : met le pixel en (x,y) à la couleur color
 *
 * - drawLine(x0, y0, x1, y1, color) : dessine une ligne droite entre (x0, y0) et (x1, y1) de la couleur color
 *
 * - drawRect(x0, y0, w, h, color) OU fillRect(x0, y0, w, h, color) : dessine un rectangle avec le côté haut-gauche en (x0, y0) de largeur w et de hauteur h avec la couleur color
 * drawRect va dessiner uniquement le contour du rectangle tandis que fillRect va aussi le remplir
 *
 * - drawCircle(x0, y0, r, color) OU fillCircle(x0, y0, r, color) : dessine un cercle de centre (x0, y0) et de rayon r avec la couleur color
 * drawCircle va dessiner uniquement le contour du cercle tandis que fillCircle va aussi le remplir
 *
 * - drawRoundRect(x0, y0, w, h, r, color) OU fillRoundRect(x0, y0, w, h, r, color) : dessine un rectangle avec le côté haut-gauche en (x0, y0) de largeur w et hauteur h avec des bords arrondis de rayon r et la couleur color
 * drawRoundRect va dessiner uniquement le contour du rectangle tandis que fillRoundRect va aussi le remplir
 *
 * - drawTriangle(x0, y0, x1, y1, x2, y2, color) OU fillTriangle(x0, y0, x1, y1, x2, y2, color) : dessine un triangle entre les points (x0, y0), (x1, y1), (x2, y2) avec la couleur color
 * drawTriangle va dessiner uniquement le contour du triangle tandis que fillTriangle va aussi le remplir
 *
 * - drawBitmap(x, y, bitmap, w, h, color) : dessine une image bitmap avec l'angle haut-gauche en (x, y) de largeur w, hauteur h et couleur color
 * L'image bitmap doit être convertie avec ce site http://javl.github.io/image2cpp/ et les paramètres suivants :
 *  - Background color : White
 *  - Invert Image Color : Permet d'inverser les couleurs (les pixels blancs seront allumés, les noirs éteints)
 *  - Brightness Threshold : A ajuster pour que l'aperçu ressemble à l'image qui vous intéresse
 *  - Scaling : scale to fit (vous pouvez expérimenter pour trouver ce qui marche le mieux)
 *  - Center : Permet de centrer votre image dans le cadre (utile pour une image qui prend tout l'écran)
 *  - Code output format : Arduino Code
 *  - Identifier : Un nom pour votre image bitmap
 *  - Draw mode : Horizontal
 *
 * - fillScreen(color) : Remplit l'écran avec la couleur color
 *
 *
 *
 * Infos pour l'utilisation des boutons poussoirs :
 * La fonction permettant d'actualiser l'état des boutons est readButtons(), elle est appelée automatiquement
 * mais il est possible de l'appeler vous même si besoin (ex: longue boucle)
 *
 * Pour tester si un bouton est pressé il suffit d'utiliser la condition
 * if (buttons & BOUTON_CHOISI) {}
 *
 * Les boutons disponibles sont
 * RIGHT_1, LEFT_1, UP_1, DOWN_1 pour le joueur 1 et RIGHT_2, LEFT_2, UP_2, DOWN_2 pour le joueur 2
 */

// Initialisation de la librairie
Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(WIDTH, HEIGHT, PIN,
  NEO_MATRIX_BOTTOM  + NEO_MATRIX_RIGHT +
  NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
  NEO_GRB            + NEO_KHZ800);

short buttons = 0x00;
void readButtons() {
  for (int i = 0; i < BUTTONS; i++) {
    int state = digitalRead(buttons_pins[i]);
    bitWrite(buttons, i, !state);
  }
}

/*
 * Jeux
 */
class Program {
public:
  virtual void setup() = 0;
  virtual void loop() = 0;
};

/*******************************************************************************************************************
 *
 *                                                         LE JEU VA ICI
 *
 *******************************************************************************************************************/

class Jeu: public Program {
public:
  Jeu() {}

  int xj1=7;
  int yj1=0;
  int pxj1=7;
  int pyj1=0;
  int vxj1 = 0;
  int vyj1 = 1;
  int t=0;
  int pixels_occupe[t][t];
  int draw_delay = 100;
  long last_draw = millis();

  int input_delay = 100;
  long last_input = millis();

  int update_delay = 200;
  long last_update = millis();

  void setup() {

  }

  void loop() {
    // Vérifie les boutons
    if (millis() > last_input + input_delay) {
      last_input = millis();

      input();
    }

    // Vérifie le jeu
    if (millis() > last_update + update_delay) {
      last_update = millis();

      update();
    }

    // Vérifie l'écran
    if (millis() > last_draw + draw_delay) {
      last_draw = millis();

      draw();
      matrix.show();
    }
  }

  // Regarde l'état des boutons
  void input() {
    if (buttons & UP_1){
      if (vyj1==0){
        vyj1++;
        vxj1=0;
      }
    }
    if (buttons & DOWN_1){
      if (vyj1==0){
        vyj1--;
        vxj1=0;
      }
    }
    if (buttons & LEFT_1){
      if (vxj1==0){
        vxj1--;
        vyj1=0;
      }
    }
    if (buttons & RIGHT_1){
      if (vxj1==0){
        vxj1--;
        vyj1=0;
      }
    }
  }

  // Gère les mises à jour du jeu
  void update() {
    pxj1=xj1;
    pyj1=yj1;
    xj1+=vxj1;
    yj1+=vyj1;
    if (xj1>= matrix.width() || yj1>= matrix.height()|| xj1<0 || yj1<0){
      // le joueur 1 à perdu
    }
    for (int i=0; i <= t; i++){
      if (xj1==pixels_occupe[i][0] && yj1==pixels_occupe[i][1])
      {
        // le joueur 1  à perdu
      }
    }

  }

  // Gère l'affichage
  void draw() {
    matrix.drawPixel(xj1, yj1, matrix.Color(160,200,255));
    int pixels_occupe[t]={xj1,yj1};
    t++;
    matrix.drawPixel(pxj1, pyj1, matrix.Color(0,0,255));
  }
};

/*******************************************************************************************************************
 *
 *                                              RIEN D'INTERRESSANT EN DESSOUS
 *
 *******************************************************************************************************************/

// Initialisation des jeux
Jeu jeu;

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

  matrix.begin();
  matrix.setBrightness(BRIGHTNESS);

  // Remplit avec la couleur "noire" (= éteint) tout l'écran
  matrix.fillScreen(0);
  // Affiche les pixels sur l'écran
  matrix.show();

  // Initialise le générateur d'aléatoire
  randomSeed(analogRead(A0));

  // Initialise les boutons poussoirs
  for (int i = 0; i < BUTTONS; i++) {
    pinMode(buttons_pins[i], INPUT_PULLUP);
  }

  jeu.setup();
}

void loop() {
  // Gestion des boutons poussoirs
  readButtons();

  jeu.loop();
}