// INCLUDES
#include <Adafruit_NeoPixel.h>
#include <stdio.h>
#include <stdint.h>

// DEFINES
#define RGB_PIN 22
#define LED_RGB_QTY 16

//STRUCTS & ENUMS
typedef enum
{
  LED_MODE_OFF = 0,   /* Off mode */
  LED_MODE_ON,        /* On mode*/
  LED_MODE_BLINK,     /* Blink mode */
  LED_MODE_BLINK_QTY, /* Blink for x times */
  LED_MODE_FADE_IN,
  LED_MODE_FADE_OUT,
  LED_MODE_FADE_INOUT,
  LED_MODE_CHARGED
} LED_Mode_t;

typedef struct
{
  LED_Mode_t led_mode;
  uint32_t led_period;
  uint32_t led_blink_qty;
  uint8_t led_duty_max;
  uint8_t led_duty_min;
  uint8_t led_duty;
  uint8_t led_step;
} LED_Map_t;

typedef enum {
    COLOR_RED     = 0xFF0000, // Vermelho
    COLOR_GREEN   = 0x008000, // Verde
    COLOR_BLUE    = 0x0000FF, // Azul
    COLOR_YELLOW  = 0xFFFF00, // Amarelo
    COLOR_CYAN    = 0x00FFFF, // Ciano
    COLOR_MAGENTA = 0xFF00FF, // Magenta
    COLOR_BLACK   = 0x000000, // Preto
    COLOR_WHITE   = 0xFFFFFF, // Branco
    COLOR_GRAY    = 0x808080, // Cinza
    COLOR_ORANGE  = 0xFFA500, // Laranja
    COLOR_PINK    = 0xFFC0CB, // Rosa
    COLOR_PURPLE  = 0x800080, // Roxo
    COLOR_BROWN   = 0xA52A2A  // Marrom
} Color_t;

class RGB : private Adafruit_NeoPixel{
  public:
  RGB(int RGB_DATA_IN, int LED_QTY);
  //~RBG();
  void Start();

  void ConvertToHex(uint32_t hex);
  void Blink();
  void Write(LED_Mode_t state);
  void Write(LED_Mode_t state, int led_pos);
  
  bool IsEnable();
  bool IsCharged();

  void FadeIn(uint8_t dutyMin, uint8_t dutyMax, uint8_t step);
  void FadeOut(uint8_t dutyMin, uint8_t dutyMax, uint8_t step);
  void FadeInOut(uint8_t dutyMin, uint8_t dutyMax, uint8_t step);
  void Slide(uint8_t dutyMin, uint8_t dutyMax, uint8_t step);
  void UpdateMode();

  void ChangeBrithness(uint8_t brightness);
  

  private:

  uint32_t color = 0x000000;
  uint8_t m_duty = 0;
  uint8_t m_duty_min = 0;
  uint8_t m_duty_max;
  uint8_t m_step = 0;
  uint8_t m_mode = 0;
  uint8_t m_rgb_dataIn;
  uint8_t m_red;
  uint8_t m_green;
  uint8_t m_blue;
  uint8_t m_brightness;
  int m_qtd_leds;
  bool m_isCharged = false;
  bool m_direction = true;
  bool m_isFree = false;
  bool m_initialized = false;
};

RGB::RGB(int LED_QTY, int RGB_DATA_IN) : Adafruit_NeoPixel(LED_QTY, RGB_DATA_IN)
{
  m_duty = 0;
  m_duty_min = 0;
  m_duty_max = 255;

  m_step = 0;
  m_mode = LED_MODE_OFF;
  m_rgb_dataIn = RGB_DATA_IN;
  m_qtd_leds = LED_QTY;

  m_brightness = 0;
  m_red = 0;
  m_green = 0;
  m_blue = 0;
  color = COLOR_BLACK;

  m_isCharged = false;
  m_direction = true;
 
}

void RGB::Start() {
  pinMode(m_rgb_dataIn, OUTPUT);
  begin();
  clear();
  show();
  m_isFree = true;
  m_initialized = true;
}
void RGB::ConvertToHex(uint32_t hex) 
{
  m_red = (hex >> 16) & 0xFF;
  m_green = (hex >> 8) & 0xFF;
  m_blue = hex & 0xFF;
  Serial.print("RED: ");
  Serial.println(m_red);
  Serial.print("GREEN: ");
  Serial.println(m_green);
  Serial.print("BLUE: ");
  Serial.println(m_blue);
}

void RGB::Write(LED_Mode_t state) 
{
  if (m_initialized) {
    if (state == LED_MODE_OFF) {
      for(int i = 0; i < LED_RGB_QTY; i++) {
        setPixelColor(i, 0, 0, 0);
        Serial.println("LED OFF");
      }
      show();
    }
    else if (state == LED_MODE_ON) {
      for(int i = 0; i < LED_RGB_QTY; i++) {
        setPixelColor(i, m_red, m_green, m_blue);
        Serial.println("LED ON");
      }
      show();
    }
  }
}

void RGB::Write(LED_Mode_t state, int led_pos) 
{
  if (m_initialized) {
    if (state == LED_MODE_OFF) {
        setPixelColor(led_pos, 0, 0, 0);
        Serial.println("LED OFF");
      show();
    }
    else if (state == LED_MODE_ON) {
        setPixelColor(led_pos, m_red, m_green, m_blue);
        Serial.println("LED ON");
      }
      show();
    }
}

void RGB::ChangeBrithness(uint8_t brightness)
{
  m_brightness = brightness;
  setBrightness(m_brightness);
}

bool RGB::IsEnable(){
  return m_initialized;
} 

void RGB::Blink(){

}

void RGB::FadeIn(uint8_t dutyMin, uint8_t dutyMax, uint8_t step) 
{
  m_mode = LED_MODE_FADE_IN;
  m_duty_min = dutyMin;
  m_duty_max = dutyMax;
  m_step = step;
  m_direction = true;
  m_duty = dutyMin;
}

void RGB::FadeOut(uint8_t dutyMin, uint8_t dutyMax, uint8_t step) 
{
  m_mode = LED_MODE_FADE_OUT;
  m_duty_min = dutyMin;
  m_duty_max = dutyMax;
  m_step = step;
  m_direction = false;
  m_duty = dutyMax;
}

void RGB::FadeInOut(uint8_t dutyMin, uint8_t dutyMax, uint8_t step) 
{

}


bool RGB::IsCharged(){
  return m_isCharged;
}

void RGB::Slide(uint8_t dutyMin, uint8_t dutyMax, uint8_t step){

}

void RGB::UpdateMode() {
  if (m_initialized) {
    switch (m_mode)
    {
    case LED_MODE_FADE_IN:
      if (m_direction)
      {
        if( (m_duty + m_step) <= m_duty_max )
        {
          m_duty += m_step;
          for (int i = 0; i <= m_qtd_leds; i++) 
          {
            setPixelColor(i, m_duty, 0, 0);
            Serial.print("DUTY: ");
            Serial.println(m_duty);
            show();
          }
        
      //delay(100);
        }
        else
        {
          m_duty = m_duty_max;
        }
  }
      break;
    case LED_MODE_FADE_OUT:
    Serial.println("FADE OUT");
      if (!m_direction)
      {
        Serial.println("REVERSE DIR");
        if ( (m_duty - m_step) >= m_duty_min )
        {
          m_duty -= m_step;
          for (int i = 0; i <= m_qtd_leds; i++) 
          {
            setPixelColor(i, m_duty, 0, 0);
            Serial.print("DUTY: ");
            Serial.println(m_duty);
            show();
          }
        }
        else
        {
          m_duty = m_duty_min;
        }
      }
      break;
    case LED_MODE_FADE_INOUT:
      if (m_direction) {
  if( (m_duty + m_step) <= m_duty_max ) {
    m_duty += m_step;
    for (int i = 0; i <= 16; i++) {
      setPixelColor(i, m_duty, 0, 0);
      show();
    }
      
    //delay(100);
  }
  else{
    m_duty = m_duty_max;
    m_direction = false;
  }
  }
  //m_duty = m_duty_max;
  
  else if (!m_direction) {

    if(m_duty_max >= m_duty_min) {

      if ( (m_duty - m_step) >= m_duty_min) {
        m_duty -= m_step;
        for (int i = 0; i <= 16; i++) {
          setPixelColor(i, m_duty, 0, 0);
        }
        show();
        //delay(100);
      }
    }
    else {
      m_duty = m_duty_min;
      m_direction = true;
    }
  }
      break;
    
    default:
      break;
    }
  }

}

void UpdateState(){

}



//GLOBAL VARIABLES
/*
uint8_t m_duty = 0;
uint8_t m_duty_min = 0;
uint8_t m_duty_max;
uint8_t m_step = 0;
uint8_t m_mode = 0;
uint8_t m_rgb_dataIn = RGB_PIN;
uint8_t m_red;
uint8_t m_green;
uint8_t m_blue;

bool m_isCharged = false;
bool m_direction = true;
bool m_isFree = true;
bool m_initialized = false; 
*/

/* OBJECTS */
//Adafruit_NeoPixel rgb(LED_RGB_QTY, RGB_PIN);
RGB rgb(LED_RGB_QTY, RGB_PIN);

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  Serial.println("Hello, ESP32!");
  rgb.Start();
  uint32_t color = COLOR_GREEN;
  rgb.ConvertToHex(color);
  

  

  /*
  rgb.begin();
  rgb.clear();
  rgb.show();
  m_initialized = true;
 
  rgb.clear();
  rgb.show();
  m_duty_max = 255;
  m_duty_min = 0;
  m_step = 5;
  */

  /* 
  ConvertToHex(color);
  Serial.print("RED: ");
  Serial.println(m_red);
  Serial.print("GREEN: ");
  Serial.println(m_green);
  Serial.print("BLUE: ");
  Serial.println(m_blue);
  for (int i = 0; i<16; i++) {
    rgb.setPixelColor(i, m_green, m_blue, m_red);
  }
  rgb.show();
  */
rgb.FadeOut(50, 255, 10);
}

void loop() {
  
  rgb.UpdateMode();
}


/* Functions Created */