#include <FastLED.h>
#include <AsyncTimer.h>
// #include <DmxSimple.h>

// #define DMXPIN 3
//const int numLights = 3;

#define LED_PIN 2
#define NUM_LEDS 14
#define LEDS_LEFT 5
#define LEDS_RIGHT 9
CRGB leds[NUM_LEDS];

#define HUE_PIN A0
#define SPEED_PIN A1
#define BRIGHTNESS_PIN A2
#define SCALE_PIN A3

#define BRIGHTNESS 200
uint8_t maxBrightness = BRIGHTNESS;
uint8_t currentBrightness = maxBrightness;

uint16_t xPosition;

uint8_t starIntensity[NUM_LEDS];
uint8_t starIncreasing[NUM_LEDS];


uint8_t tailLength = 6;
uint8_t currentPulseStep = 0;
bool pulseActive = false;


DEFINE_GRADIENT_PALETTE(NorthernLightsPalette) {
  0, 0, 207, 82,
  62, 3, 46, 62,
  143, 25, 100, 106,
  192, 0, 198, 144,
  255, 0, 223, 150
};

DEFINE_GRADIENT_PALETTE(WarmNorthernLightsPalette) {
  0, 207, 34, 44,
  61, 233, 160, 58,
  130, 219, 61, 49,
  187, 233, 160, 58,
  255, 26, 26, 26
};

CRGBPalette16 currentPalette = CRGBPalette16(NorthernLightsPalette);
CRGBPalette16 warmPalette = CRGBPalette16(WarmNorthernLightsPalette);

enum State { STARS,
             PULSE,
             NOISE
           };
State currentState = NOISE;
State targetState = NOISE;
uint16_t caseEffectsDuration = 10000;
bool effectStarted = false;
bool transitionInProgress = false;
AsyncTimer t;

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

  //DmxSimple.usePin(DMXPIN);
  //DmxSimple.maxChannel(numLights * 3);


  FastLED.addLeds<WS2811, LED_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(BRIGHTNESS);

  /* --- INITIALIZE POTENTIOMETERS --- */
  pinMode(HUE_PIN, OUTPUT);
  pinMode(SPEED_PIN, OUTPUT);
  pinMode(BRIGHTNESS_PIN, OUTPUT);
  pinMode(SCALE_PIN, OUTPUT);

  memset(starIntensity, 0, NUM_LEDS);
  memset(starIncreasing, false, NUM_LEDS);
}

void loop() {

  /* --- READ POTENTIOMETERS --- */
  int potValueHue = map(analogRead(HUE_PIN), 0, 1023, 0, 255);
  int potValueSpeed = map(analogRead(SPEED_PIN), 0, 1023, 10, 100);
  int potValueScale = map(analogRead(SCALE_PIN), 0, 1023, 1, 50);

  if (currentState == NOISE && transitionInProgress == false) {
    maxBrightness = map(analogRead(BRIGHTNESS_PIN), 0, 1023, 0, BRIGHTNESS);
    currentBrightness = maxBrightness;
    FastLED.setBrightness(currentBrightness);
  }

  t.handle();

  if (currentState != targetState && transitionInProgress) {
    EVERY_N_MILLISECONDS(40) {
      FastLED.setBrightness(currentBrightness);
      currentBrightness--;
      if (FastLED.getBrightness() <= 0) {
        currentState = targetState;
        currentBrightness = 0;
      }
    }
  }
  if (currentState == targetState && transitionInProgress) {
    EVERY_N_MILLISECONDS(40) {
      FastLED.setBrightness(currentBrightness);
      currentBrightness++;
      if (FastLED.getBrightness() >= maxBrightness) {
        currentBrightness = maxBrightness;
        transitionInProgress = false;
      }
    }
  }




  switch (currentState) {
    case STARS:
      // Stars effect
      EVERY_N_MILLISECONDS(20) {
        addRandomStars(potValueSpeed * 10);
      }

      if (transitionInProgress == false && effectStarted == true) {
        effectStarted = false;
        t.setTimeout(resetTransition, caseEffectsDuration);
      }

      break;

    case PULSE:

      EVERY_N_SECONDS(2) {
        startPulse();
      }

      EVERY_N_MILLISECONDS(50) {
        // Pulse effect
        if (pulseActive) {
          updatePulse();
        } else {
          for (int i = 0; i < NUM_LEDS; i++) {
            leds[i] = CRGB::Black;

            /* DmxSimple.write(i * 3 + 1, 0);
              DmxSimple.write(i * 3 + 2, 0);
              DmxSimple.write(i * 3 + 3, 0); */
          }
        }
      }

      if (transitionInProgress == false && effectStarted == true) {
        effectStarted = false;
        t.setTimeout(resetTransition, caseEffectsDuration);
      }

      break;

    case NOISE:
      // Noise effect code
      EVERY_N_SECONDS(10) {
        if (!transitionInProgress) {
          uint8_t rNumber = random8();
          if (rNumber <= 4) {
            Serial.println("STARS");
            currentState = STARS;
            effectStarted = true;
          } else if (rNumber > 4 && rNumber < 8) {
            Serial.println("PULSE");
            targetState = PULSE;
            transitionInProgress = true;
            effectStarted = true;
          }
        }
      }

      EVERY_N_MILLISECONDS(10) {
        addNoise(potValueHue, potValueScale);
        xPosition += potValueSpeed * 0.1;
      }

      break;
  }



  FastLED.show();


}

void startPulse() {
  currentPulseStep = 0;
  pulseActive = true;
}

void updatePulse() {
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i] = CRGB::Black;

    /* DmxSimple.write(i * 3 + 1, 0);
       DmxSimple.write(i * 3 + 2, 0);
       DmxSimple.write(i * 3 + 3, 0); */
  }

  int leftStart = 0;
  int leftEnd = LEDS_LEFT - 1;
  int rightStart = LEDS_LEFT;
  int rightEnd = NUM_LEDS - 1;

  int rightPulsePosition = rightEnd - currentPulseStep; 

  for (int i = 0; i < tailLength; i++) {
    int pos = rightPulsePosition + i;

    uint8_t brightness = maxBrightness - (i * (maxBrightness / tailLength));

    if (pos >= rightStart && pos <= rightEnd) {
      leds[pos] = CRGB(0, brightness, 0);

      /* DmxSimple.write(pos * 3 + 1, brightness);
        DmxSimple.write(pos * 3 + 2, 0);
        DmxSimple.write(pos * 3 + 3, 0); */
    }

    int mirrorStartRight = rightStart;
    int mirrorEndRight = rightStart + LEDS_LEFT - 1;

    if (pos >= mirrorStartRight && pos <= mirrorEndRight) {

      int leftPos = leftStart + (mirrorEndRight - pos);
      if (leftPos >= leftStart && leftPos <= leftEnd) {
        leds[leftPos] = CRGB(0, brightness, 0);

        /* DmxSimple.write(leftPos * 3 + 1, brightness);
          DmxSimple.write(leftPos * 3 + 2, 0);
          DmxSimple.write(leftPos * 3 + 3, 0); */
      }
    }
  }

  currentPulseStep++;

  if (rightPulsePosition + tailLength - 1 < rightStart) {
    pulseActive = false;
  }
}






void addNoise(int hue, int scale) {
  uint8_t blendFactor = hue;

  for (int i = 0; i < NUM_LEDS; i++) {
    if (i < LEDS_LEFT) {
      uint8_t noise = inoise8(i * scale - xPosition, 0, i * scale - xPosition);
      CRGB color1 = ColorFromPalette(currentPalette, noise);
      CRGB color2 = ColorFromPalette(warmPalette, noise);
      CRGB blendedColor = blend(color1, color2, blendFactor);

      leds[i] = blendedColor;

      /* DmxSimple.write(i * 3 + 1, blendedColor.r);
        DmxSimple.write(i * 3 + 2, blendedColor.g);
        DmxSimple.write(i * 3 + 3, blendedColor.b); */
    } else {
      uint8_t noise = inoise8(i * scale + xPosition, 0, i * scale + xPosition);
      CRGB color1 = ColorFromPalette(currentPalette, noise);
      CRGB color2 = ColorFromPalette(warmPalette, noise);
      CRGB blendedColor = blend(color1, color2, blendFactor);

      leds[i] = blendedColor;

      /* DmxSimple.write(i * 3 + 1, blendedColor.r);
        DmxSimple.write(i * 3 + 2, blendedColor.g);
        DmxSimple.write(i * 3 + 3, blendedColor.b); */
    }
  }
}





void addRandomStars(int speed) {
  for (int i = 0; i < NUM_LEDS; i++) {
    if (random16() < speed && starIntensity[i] == 0) {
      starIntensity[i] = 1;
      starIncreasing[i] = true;
    }

    if (starIntensity[i] > 0) {
      if (starIncreasing[i]) {
        if (starIntensity[i] < 245) {
          starIntensity[i] += 10;
        } else {
          starIntensity[i] = 255;
          starIncreasing[i] = false;
        }
      } else {
        if (starIntensity[i] > 10) {
          starIntensity[i] -= 10;
        } else {
          starIntensity[i] = 0;
          leds[i] = CRGB::Black;

          /* DmxSimple.write(i * 3 + 1, 0);
            DmxSimple.write(i * 3 + 2, 0);
            DmxSimple.write(i * 3 + 3, 0); */
        }

        // Update the LED color
        if (starIntensity[i] > 0) {
          leds[i] = CRGB(starIntensity[i], starIntensity[i], starIntensity[i]);

          /* DmxSimple.write(i * 3 + 1, starIntensity[i]);
            DmxSimple.write(i * 3 + 2, starIntensity[i]);
            DmxSimple.write(i * 3 + 3, starIntensity[i]); */
        }
      }
    }
  }
}

void resetTransition() {
  transitionInProgress = true;
  targetState = NOISE;
}