#include <Arduino.h>

#include <Adafruit_NeoPixel.h>
#include <Encoder.h>

#include "pin_map.hpp"
#include "Button.hpp"


/* Types and Constants                                                                            */
/* ---------------------------------------------------------------------------------------------- */

/* State machine */
#define FOREACH_MODE(MODE) \
        MODE(ControlOff) \
        MODE(LightOn) \
        MODE(SetColor) \
        MODE(SetSaturation) \
        MODE(SetBrightness) \
        MODE(Shift) \

#define GENERATE_MODE_ENUM(ENUM) ENUM,

enum class Mode_e {FOREACH_MODE(GENERATE_MODE_ENUM)};

Mode_e& operator++(Mode_e& mode)
{
     if (mode == Mode_e::Shift) {
      return mode = Mode_e::ControlOff;
    }

    return mode = static_cast<Mode_e>(static_cast<int>(mode) + 1);
}

#ifdef DEBUG
  #define GENERATE_MODE_STRING(STRING) #STRING,
   char static const * mode_str[] = {FOREACH_MODE(GENERATE_MODE_STRING)};
#endif /*DEBUG*/

/* Leds */
uint16_t static const LedCount{24};
uint8_t static const ColorSaturation{128};
uint8_t static const ColorArray[3][3] = 
  {{ColorSaturation, 0, 0}, {0, ColorSaturation, 0}, {0, 0, ColorSaturation}};

/* Led ring state */
typedef struct {
  uint16_t ledOnCounter;
  uint16_t ledOnShift;
  uint16_t hue;
  uint8_t saturation;
  uint8_t brightness;
} LedRingState_t;

/* Button */
int const AnalogButtonVRef{970};


/* Global variables                                                                               */
/* ---------------------------------------------------------------------------------------------- */

/* State machine */
Mode_e currentMode{Mode_e::ControlOff};

/* Led ring state */
LedRingState_t ledRingState {
  .ledOnCounter = 1,
  .ledOnShift = 0,
  .hue = 0,
  .saturation = 255,
  .brightness = 16,
};

/*  IO Objects */
Adafruit_NeoPixel ledRing{LedCount, LedPin, NEO_GRB + NEO_KHZ800};
Encoder encoder{EncoderPinA, EncoderPinB};
AnalogButton button{AnalogButtonPin, AnalogButtonVRef};

/* debug Serial definition */
#ifdef DEBUG
  #ifdef ARDUINO_AVR_ATTINYX5
      #include <SoftwareSerial.h>
      SoftwareSerial debugSerial{RxPin, TxPin}; // RX, TX
  #endif /*ARDUINO_AVR_ATTINYX5*/
  #ifdef ARDUINO_AVR_UNO
    #include <HardwareSerial.h>
    HardwareSerial &debugSerial = Serial;
  #endif /*ARDUINO_AVR_UNO*/
#endif /*DEBUG*/


/* Private function declarations                                                                  */
/* ---------------------------------------------------------------------------------------------- */

/* State machine */
#define GENERATE_MODE_EXEC_DECLARTION(MODE) void MODE ## _execute (int shift);
FOREACH_MODE(GENERATE_MODE_EXEC_DECLARTION)

/* Encoder */
int get_encoder_shift(void);

void refresh_led_ring(void);

void analog_button_calibration(void);

/* Function definitions                                                                           */
/* ---------------------------------------------------------------------------------------------- */
void setup()
{
  #ifdef DEBUG
    debugSerial.begin(9600);
    while(!debugSerial.available());
    debugSerial.println("Init ... ");
  #endif /*DEBUG*/

  analog_button_calibration();

  ledRing.begin();
  ledRing.setBrightness(50);
  ledRing.show();

  get_encoder_shift();

  #ifdef DEBUG
    debugSerial.println(mode_str[static_cast<int>(currentMode)]);
  #endif /*DEBUG*/
}

void loop() {
  int shift{get_encoder_shift()};
  
  if (button.is_button_pressed()) {
    while(button.is_button_pressed()){
      delay(150);
    }
    ++currentMode;
    #ifdef DEBUG
      debugSerial.println(mode_str[static_cast<int>(currentMode)]);
    #endif /*DEBUG*/
  }

  if (shift != 0) {
    switch (currentMode) {
      case Mode_e::ControlOff:
        ControlOff_execute(shift);
        break;
        
      case Mode_e::LightOn:
        LightOn_execute(shift);
        break;
        
      case Mode_e::SetColor:
        SetColor_execute(shift);
        break;
        
      case Mode_e::SetBrightness:
        SetBrightness_execute(shift);
        break;

      case Mode_e::SetSaturation:
        SetSaturation_execute(shift);
        break;

      case Mode_e::Shift:
        Shift_execute(shift);
        break;

      default:
        break;
    }
  }

  if (currentMode != Mode_e::ControlOff && shift != 0) {
    refresh_led_ring();
  }
}

void ControlOff_execute (int shift) {
}

void LightOn_execute (int shift) {
  uint16_t & ledOnCounter = ledRingState.ledOnCounter;

  if (shift > 0) {
    ++ledOnCounter;
    if (ledOnCounter > LedCount) {
      ledOnCounter = 0;
    }
  } else {
    --ledOnCounter;
    if (ledOnCounter == UINT16_MAX) {
      ledOnCounter = LedCount;
    }
  }
  
  #if defined(DEBUG) && defined(ARDUINO_AVR_UNO)
    if (shift != 0) {
      debugSerial.print(__func__);
      debugSerial.print(" : shift=");
      debugSerial.print(shift, DEC);
      debugSerial.print(", ledOnCounter=");
      debugSerial.println(ledOnCounter, DEC);
    }
  #endif /*defined(DEBUG) && defined(ARDUINO_AVR_UNO)*/
}
    
void SetColor_execute (int shift) {
  uint16_t & hue = ledRingState.hue;

  hue += (shift << 8);
  
  #if defined(DEBUG) && defined(ARDUINO_AVR_UNO)
    if (shift != 0) {
      debugSerial.print(__func__);
      debugSerial.print(" : shift=");
      debugSerial.print(shift, DEC);
      debugSerial.print(", hue=");
      debugSerial.println(hue, DEC);
    }
  #endif /*defined(DEBUG) && defined(ARDUINO_AVR_UNO)*/
}
    
void SetBrightness_execute (int shift) {
  uint8_t & brightness = ledRingState.brightness;

  brightness += (shift << 2);
  
  #if defined(DEBUG) && defined(ARDUINO_AVR_UNO)
    if (shift != 0) {
      debugSerial.print(__func__);
      debugSerial.print(" : shift=");
      debugSerial.print(shift, DEC);
      debugSerial.print(", brightness=");
      debugSerial.println(brightness, DEC);
    }
  #endif /*defined(DEBUG) && defined(ARDUINO_AVR_UNO)*/
}

void Shift_execute (int shift) {
  uint16_t & ledOnShift = ledRingState.ledOnShift;

  if (shift > 0) {
    ++ledOnShift;
    if (ledOnShift == LedCount) {
      ledOnShift = 0;
    }
  } else {
    --ledOnShift;
    if (ledOnShift == UINT16_MAX) {
      ledOnShift = LedCount - 1;
    }
  }
  
  #if defined(DEBUG) && defined(ARDUINO_AVR_UNO)
    if (shift != 0) {
      debugSerial.print(__func__);
      debugSerial.print(" : shift=");
      debugSerial.print(shift, DEC);
      debugSerial.print(", ledOnShift=");
      debugSerial.println(ledOnShift, DEC);
    }
  #endif /*defined(DEBUG) && defined(ARDUINO_AVR_UNO)*/
}

void SetSaturation_execute (int shift) {
  uint8_t & saturation = ledRingState.saturation;

  saturation += (shift << 2);
  
  #if defined(DEBUG) && defined(ARDUINO_AVR_UNO)
    if (shift != 0) {
      debugSerial.print(__func__);
      debugSerial.print(" : shift=");
      debugSerial.print(shift, DEC);
      debugSerial.print(", saturation=");
      debugSerial.println(saturation, DEC);
    }
  #endif /*defined(DEBUG) && defined(ARDUINO_AVR_UNO)*/
}

int get_encoder_shift(void) {
  int32_t static _previousValue{encoder.read()};

  int32_t currentValue{encoder.read()};
  int32_t diff{currentValue - _previousValue};

  if (diff <= -4) {
    _previousValue = currentValue;
    return diff >> 2;

  } else if (diff >= 4) {
    _previousValue = currentValue;
    return diff >> 2;

  } else {
    return 0;
  }
}

void refresh_led_ring(void) {
  ledRing.fill(0);
  for (size_t i = 0; i < ledRingState.ledOnCounter; ++i) {
    unsigned int ledId = i + ledRingState.ledOnShift;
    if (ledId >= LedCount) {
      ledId -= LedCount;
    }
    ledRing.setPixelColor(ledId, Adafruit_NeoPixel::ColorHSV
      (ledRingState.hue, ledRingState.saturation, ledRingState.brightness));
  }
  ledRing.show();
}

void analog_button_calibration(void) {
  int hRef;

  do {
      hRef = analogRead(AnalogButtonPin);
      delay(300);

      #ifdef DEBUG
        debugSerial.println(hRef);
      #endif /*DEBUG*/
  } while (hRef < 1000);


  int lRef = analogRead(AnalogButtonPin);
  while (hRef - lRef < 50) {
      #ifdef DEBUG
        debugSerial.println(lRef);
      #endif /*DEBUG*/

      lRef = analogRead(AnalogButtonPin);
      delay(300);
  }

  #ifdef DEBUG
    debugSerial.println(lRef);
  #endif /*DEBUG*/

  button = AnalogButton{AnalogButtonPin, lRef + 10};

  while(analogRead(AnalogButtonPin) < lRef + 10){
    delay(150);
  }

}