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

#define PIN         4 //Pino de entrada no fita de leds
#define NUMPIXELS   255 //Quantidde de pixels
#define FALHA       21  //Chave de falha
#define LINHAS      15
#define COLUNAS     17

// Define as cores básicas
#define BLACK      0x0000
#define WHITE      0xFFFF
#define RED        0xF800
#define GREEN      0x07E0
#define BLUE       0x001F
#define YELLOW     0xFFE0
#define CYAN       0x07FF
#define MAGENTA    0xF81F
#define ORANGE     0xFC00
#define PINK       0xFBE0
#define BROWN      0xA450
#define GRAY       0x8410
#define LIGHT_GRAY 0xC618
#define DARK_GRAY  0x4208

// Define outras cores
#define MAROON     0x8000
#define OLIVE      0x8080
#define PURPLE     0x801F
#define TEAL       0x0080
#define NAVY       0x000F
#define SILVER     0xC0C0
#define GOLD        0xFFD7
#define BURGUNDY   0x803F
#define TAN         0xD2B4
#define PEACH       0xFFC0
#define SKYBLUE     0x87CE
#define PLUM        0xDD84
#define VIOLET      0x8E40

extern const unsigned short Teste_Picto[150];
extern const unsigned short loco[150];
extern const unsigned short miranha[150];
extern const unsigned short teste_pictograma[150];
extern const unsigned short deadpoolBryan[150];
extern const unsigned short LedSamuel[150];
extern const unsigned short Mascara[150];
extern const unsigned short MascaraVerde[255];

//Cria um pixel
Adafruit_NeoPixel leds = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
//Cria uma matriz
Adafruit_NeoMatrix matriz = Adafruit_NeoMatrix(COLUNAS, LINHAS, PIN,
                            NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ZIGZAG,
                            NEO_GRB + NEO_KHZ800 );


void setup_off1()
{
  pinMode(FALHA, INPUT_PULLUP);

  //Inicializa a serial
  Serial.begin(9600);
  //Initicializa a bilbioteca NeoPixel
  leds.begin();
  //Limpa a cor
  leds.fill(0x000000, 0, 150); //Cor, Primeiro, Quantidade
  //Atualiza o pixel
  leds.show();
  //Escreve uma cor
  //leds.setPixelColor(0, 0xAA, 0x0F, 0xF0); //RGB
  //leds.setPixelColor(1, 0x00, 0xAA, 0xF0); //RGB
  //leds.setPixelColor(2, 0xAA, 0x0F, 0xAA); //RGB
  //leds.show();
}
void loop_off1()
{
  leds.setPixelColor(0, 0xFF, 0x00, 0x00); //RGB - Vermelho
  leds.setPixelColor(1, 0x00, 0x00, 0x00); //RGB - Apagado
  leds.setPixelColor(2, 0x00, 0x00, 0x00); //RGB - Apagado
  leds.show();
  delay(2000);

  leds.setPixelColor(0, 0x00, 0x00, 0x00); //RGB - Apagado
  leds.setPixelColor(1, 0x00, 0x00, 0x00); //RGB - Apagado
  leds.setPixelColor(2, 0x00, 0xFF, 0x00); //RGB - Verde
  leds.show();
  delay(2000);

  //np1p.setPixelColor(0, 0x00, 0x00, 0xFF); //RGB - Azul
  leds.setPixelColor(0, 0x00, 0x00, 0x00); //RGB - Apagado
  leds.setPixelColor(1, 0xFF, 0xFF, 0x00); //RGB - Amarelo
  leds.setPixelColor(2, 0x000000); //RGB - Apagado
  leds.show();
  delay(1000);

  while (digitalRead(FALHA))
  {
    leds.setPixelColor(0, 0x00, 0x00, 0x00); //RGB - Apagado
    leds.setPixelColor(1, 0xFF, 0xFF, 0x00); //RGB - Amarelo
    leds.setPixelColor(2, 0x00, 0x00, 0x00); //RGB - Apagado
    leds.show();
    delay(500);

    leds.setPixelColor(0, 0x00, 0x00, 0x00); //RGB - Apagado
    leds.setPixelColor(1, 0x00, 0x00, 0x00); //RGB - Apagado
    leds.setPixelColor(2, 0x00, 0x00, 0x00); //RGB - Apagado
    leds.show();
    delay(500);
  }

  Serial.println("loop");
}

void loop_off2()
{
  int valor = analogRead(35);
  Serial.println(valor);
  valor = valor >> 4;

  leds.setPixelColor(0, valor, 0x00, 0x00); //RGB - Vermelho
  leds.setPixelColor(1, 0x00, valor, 0x00); //RGB - Verde
  leds.setPixelColor(2, 0x00, 0x00, valor); //RGB - Azul
  leds.show();
  delay(20);
}

void loop_off3()
{
  for (int i = 0; i < 150; i = i + 2)
  {
    leds.setPixelColor(i, 0x0000FF); //RGB
    leds.setPixelColor(i + 1, 0xFF0000); //RGB
    leds.show();
    delay(30);
  }
  leds.fill(0x000000, 0, 150); //Cor, Primeiro, Quantidade
  leds.show();
}

void setup()
{
  pinMode(FALHA, INPUT_PULLUP);

  //Inicializa a serial
  Serial.begin(9600);
  //Initicializa a bilbioteca NeoMatrix
  matriz.begin();
  //Limpa a cor
  matriz.fillScreen(0x0000); //Cor
  //Atualiza o pixel
  matriz.show();
}

void loop()
{
  fill_matriz(RED);
  atualiza();
  delay(1000);
  mostra_pictograma(MascaraVerde);
  delay(1000);
  mascara_aula();
  delay(1000);
  matriz.show();
  delay(1000);
  fill_matriz(BLACK);
  atualiza();
  delay(1000);
  fill_matriz(GREEN);
  atualiza();
  delay(1000);


}

// Define a função para acender um LED
void led_on(int x, int y)
{
  matriz.drawPixel(x, y, ORANGE);
}

// Define a função para apagar um LED
void led_off(int x, int y)
{
  matriz.drawPixel(x, y, 0x0000);
}

// Desenha o sorriso na matriz de LEDs
void draw_smile()
{
  // Olhos
  led_on(2, 4);
  led_on(3, 4);
  led_on(7, 4);
  led_on(8, 4);

  // Boca
  led_on(2, 8);
  led_on(3, 8);
  led_on(4, 8);
  led_on(5, 8);
  led_on(6, 8);
  led_on(7, 8);
  led_on(8, 8);

  // Dentes
  led_on(4, 7);
  led_on(5, 7);
  led_on(6, 7);
  led_on(4, 9);
  led_on(5, 9);
  led_on(6, 9);
  // Marcas
  led_on(0, 0);
}

// Atualiza
void atualiza()
{
  matriz.show();
}

// Preenche a matriz
void fill_matriz(uint16_t cor)
{
  matriz.fillScreen(cor);
}

// Pixel
void pixel(uint8_t x, uint8_t y, uint16_t cor)
{
  matriz.drawPixel(x, y, cor);
}

// Pisca
void pisca(uint16_t cor1, uint16_t cor2, uint16_t tempo, uint16_t vezes)
{
  for (uint16_t i = 0; i < vezes; i++)
  {
    fill_matriz(cor1);
    atualiza();
    delay(tempo);
    fill_matriz(cor2);
    atualiza();
    delay(tempo);
  }
}

// Linha
void linha(uint8_t xi, uint8_t yi, uint8_t xf, uint8_t yf, uint16_t cor)
{
  uint8_t aux;
  float inc, inter, a, b;
  //Desinverte o valor final com o valor inicial
  //if(xi > xf)   { aux = xi;    xi  = xf;    xf = aux; }
  //if(yi > yf)   { aux = yi;    yi  = yf;    yf = aux; }

  if ((abs(xf - xi)) > (abs(yf - yi)))
  {
    if (xi > xf)
    {
      aux = xi;    xi  = xf;    xf = aux;
      aux = yi;    yi  = yf;    yf = aux;
    }
    //Equação da reta y = ax + b
    //a = delta y / delta x
    //b = y - ax
    a = (float)(yf - yi) / (float)(xf - xi);
    b = (float)yf - a * (float)xf;

    Serial.print("a="); Serial.println(a);
    Serial.print("b="); Serial.println(b);

    while (true)
    {
      pixel(xi, yi, cor);

      Serial.print("x,y =");
      Serial.print(xi); Serial.print(","); Serial.println(yf);

      //Testa os limites
      if (((xi + 1) > xf) && ((yi + 1) > yf))
        break;
      if (xi < xf)
        xi++;
      if (yi < yf)
        yi = (uint8_t)(a * xi + b);
    }
  }
  else
  {
    if (yi > yf)
    {
      aux = xi;    xi  = xf;    xf = aux;
      aux = yi;    yi  = yf;    yf = aux;
    }
    //Equação da reta y = ax + b
    //a = delta x / delta y
    //b = x - ay
    a = (float)(xf - xi) / (float)(yf - yi);
    b = (float)xf - a * (float)yf;

    Serial.print("a="); Serial.println(a);
    Serial.print("b="); Serial.println(b);

    while (true)
    {
      pixel(xi, yi, cor);

      Serial.print("x,y =");
      Serial.print(xi); Serial.print(","); Serial.println(yf);

      //Testa os limites
      if (((xi + 1) > xf) && ((yi + 1) > yf))
        break;
      if (yi < yf)
        yi++;
      if (xi < xf)
        xi = (uint8_t)(a * yi + b);
    }
  }

  /*
    if(xi > xf)
    {
      aux = xi;    xi  = xf;    xf = aux;
    }
    if(yi > yf)
    {
      aux = xi;    xi  = xf;    xf = aux;
    }
    while(true)
    {
      pixel(xi, yi, cor);

      //Testa os limites
      if(((xi+1) > xf) && ((yi+1) > yf))
        break;
      if(xi < xf)
        xi++;
      if(yi < yf)
        yi++;
    }
  */
}

void linha_hor(uint8_t xi, uint8_t delta, uint8_t y, uint16_t cor)
{
  for (int i = 0; i < delta; i++)
  {
    pixel(xi++, y, cor);
  }
}

void linha_ver(uint8_t yi, uint8_t delta, uint8_t x, uint16_t cor)
{
  for (int i = 0; i < delta; i++)
  {
    pixel(x, yi++, cor);
  }
}

//Retângulo
void retangulo(uint8_t xi, uint8_t yi, uint8_t largura, uint8_t altura, uint16_t cor)
{
  for (int i = 0; i < altura; i++)
  {
    linha_hor(xi, largura, yi++, cor);
  }
}

//Cores RGB 565
uint16_t RGB565(uint8_t r, uint8_t g, uint8_t b)
{
  return matriz.Color(r, g, b);
}

//Sortei cores
uint16_t sorteia_cor(uint8_t min, uint8_t max)
{
  uint8_t r = random(min, max + 1);
  uint8_t g = random(min, max + 1);
  uint8_t b = random(min, max + 1);
  return matriz.Color(r, g, b);
}

//Sortei cores
uint16_t sorteia_cor_forte()
{
  uint8_t r = random(0, 2) * 0xFF;
  uint8_t g = random(0, 2) * 0xFF;
  uint8_t b = random(0, 2) * 0xFF;
  return matriz.Color(r, g, b);
}

void espiral(uint8_t xi, uint8_t yi, uint16_t cor, uint16_t tempo)
{
  uint8_t avanco = 1;

  pixel(xi, yi, cor);
  atualiza();
  delay(tempo);
  xi++;
  while (true)
  {
    linha_hor(xi, avanco, yi, cor);
    yi--;
    linha_ver(yi, avanco, xi, cor);

    avanco++;
    xi -= avanco;
    linha_hor(xi, avanco, yi, cor);
    yi += avanco;
    linha_ver(yi, avanco, xi, cor);

    avanco++;
  }
}

void mostra_pictograma(const uint16_t* picto)
{
  uint16_t x, y;

  //Varredura de pixels
  for (uint16_t i = 0; i < LINHAS*COLUNAS ; i++)
  {
    y = i / COLUNAS;
    x = i % COLUNAS;

    //Usar uma ou outra
    //matriz.drawPixel(x, y, picto[i]);
    pixel(x, y, picto[i]);
  }
  //Usar uma ou outra
  //matriz.show();
  atualiza();
}

bool recebe_comando(char* cmd)
{
  //Serial.setTimeout(1000);
  static int i = 0;
  if (Serial.available() > 0)
  {
    cmd[i] = Serial.read();
    i++;
  }
  cmd[i] = '\0';
  if (cmd[--i] == 'n' || i >= 4)
  {
    i = 0;
    Serial.println(cmd); //Eco (debug)
    if (cmd[0] == 'M' && cmd[3] == 'n')
      return true;
  }
  return false;
}

void trata_comando(char cmd)
{
  switch (cmd)
  {
    case '1': mostra_pictograma(Teste_Picto); break;
    case '2': mostra_pictograma(LedSamuel); break;
    case '3': draw_smile();
      atualiza();
      break;
    case '4': fill_matriz(GREEN);
      atualiza();
      break;
  }
}
void mascara_aula()
{
  //Marcas Superior Direita
  matriz.drawPixel(0, 0, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 1, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 2, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 3, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 4, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 5, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(1, 0, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(1, 1, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(1, 2, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(1, 3, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(2, 0, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(2, 1, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(2, 2, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(0, 0, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 1, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 2, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 3, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(3, 0, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(3, 1, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(4, 0, matriz.Color(0xFF, 0xFF, 0x00));


  //Marcas Superior esquerda
  matriz.drawPixel(14, 0, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(14, 1, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(14, 2, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(14, 3, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(14, 4, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(14, 5, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(13, 0, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(13, 1, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(13, 2, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(13, 3, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(12, 0, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(12, 1, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(12, 2, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(11, 0, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(11, 1, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(10, 0, matriz.Color(0xFF, 0xFF, 0x00));

  //Marcas inferior esquerda
  matriz.drawPixel(14, 16, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(14, 15, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(14, 14, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(14, 13, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(14, 12, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(14, 11, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(13, 16, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(13, 15, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(13, 14, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(13, 13, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(12, 16, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(12, 15, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(12, 14, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(11, 16, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(11, 15, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(10, 16, matriz.Color(0xFF, 0xFF, 0x00));

  // Mascara Inferior Direira

  matriz.drawPixel(0, 16, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 15, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 14, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 13, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 12, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 11, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(1, 16, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(1, 15, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(1, 14, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(1, 13, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(2, 16, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(2, 15, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(2, 14, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(0, 16, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 14, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 13, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(0, 12, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(3, 16, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(3, 15, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(4, 16, matriz.Color(0xFF, 0xFF, 0x00));

  //Boca
  matriz.drawPixel(4, 12, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(5, 12, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(6, 12, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(7, 12, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(8, 12, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(9, 12, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(10, 12, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(4, 10, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(5, 10, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(6, 10, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(7, 10, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(8, 10, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(9, 10, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(10, 10, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(4, 11, matriz.Color(0xFF, 0xFF, 0x00));
  matriz.drawPixel(10, 11, matriz.Color(0xFF, 0xFF, 0x00));

  matriz.drawPixel(5, 11, matriz.Color( 0x00, 0x00, 0xFF));
  matriz.drawPixel(6, 11, matriz.Color( 0x00, 0x00, 0xFF));
  matriz.drawPixel(7, 11, matriz.Color( 0x00, 0x00, 0xFF));
  matriz.drawPixel(8, 11, matriz.Color( 0x00, 0x00, 0xFF));
  matriz.drawPixel(9, 11, matriz.Color( 0x00, 0x00, 0xFF));
}