#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     0xC0C0n
#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[255];
extern const unsigned short B[255];
extern const unsigned short mascara[255];
extern const unsigned short mascara1[255];
extern const unsigned short IMG1[255];
extern const unsigned short mascaraA[255];
extern const unsigned short mascaraB[255];
extern const unsigned short Picto1[255];
extern const unsigned short Picto2[255];
extern const unsigned short Bandeira[255];

/*===================================================================*/
extern const unsigned short a[255];
extern const unsigned short b[255];
extern const unsigned short c[255];
extern const unsigned short d[255];
extern const unsigned short e[255];
extern const unsigned short f[255];
extern const unsigned short g[255];
extern const unsigned short h[255];
extern const unsigned short i[255];
extern const unsigned short j[255];
extern const unsigned short k[255];
extern const unsigned short l[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, 255); //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 < 255; i = i + 2)
  {
    leds.setPixelColor(i, 0x0000FF); //RGB
    leds.setPixelColor(i + 1, 0xFF0000); //RGB
    leds.show();
    delay(30);
  }
  leds.fill(0x000000, 0, 255); //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();

  /* Inicia o PWM no pino especificado para o controle para Wemos D1 ESP32
  ledcSetup(0, 5000, 8); // Canal 0, frequência de 5kHz, resolução de 8 bits
  ledcAttachPin(PIN, 0); // Associa o pino ao canal 0*/

}

void loop()
{
  //matriz.drawPixel(5,2,0xFF00);
  //matriz.drawPixel(2,5,matriz.Color(0x00,0xFF,0xFF));
  //matriz.drawPixel(3,5,ORANGE);
  //matriz.show();
  /* fill_matriz(BLACK);
  atualiza();
  draw_smile();
  atualiza();
  delay(1000);
  fill_matriz(GREEN);
  atualiza();
  delay(1000);
  pisca(BLUE, ORANGE, 300, 5);
  delay(1000); 
  fill_matriz(BLACK); atualiza();
  linha(1, 1, 5, 1, RED); atualiza();
  delay(1000);
  linha(1, 1, 1, 5, RED); atualiza();
  delay(1000);
  linha(1, 1, 5, 8, RED); atualiza();
  delay(1000);
  linha(1, 1, 9, 9, BLUE); atualiza();
  delay(1000);
  linha(1, 1, 9, 14, PINK); atualiza();
  delay(1000);
  linha(1, 10, 5, 2, GREEN); atualiza();
  
  linha_hor(1, 5, 2, sorteia_cor_forte()); atualiza();
  delay(300);
  linha_hor(0, 10, 5, sorteia_cor_forte()); atualiza();
  delay(300);
  linha_ver(1, 5, 2, sorteia_cor_forte()); atualiza();
  delay(300);
  linha_ver(0, 10, 5, sorteia_cor_forte()); atualiza();
  delay(300);
  retangulo(3, 6, 4, 5, sorteia_cor_forte()); atualiza();
  */

  fill_matriz(BLACK);
  mostra_pictograma(Teste_Picto);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(B);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(mascara);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(mascara1);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(IMG1);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(mascaraA);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(mascaraB);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(Picto1);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(Picto2);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(Bandeira);

  delay(1000);

  /*fill_matriz(BLACK);
  mostra_pictograma(a);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(b);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(c);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(d);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(e);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(f);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(g);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(h);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(i);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(j);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(k);

  delay(1000);

  fill_matriz(BLACK);
  mostra_pictograma(l);

  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);
}

// 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 < 255; 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();
}