/*
  Author: Siddhant Shah (21122012)

  Aim: To Control LED Ring using Node-RED via MQTT.

  Apparatus: Wokwi & Node-RED
*/

/*
  Modes:
  0:  Off
  1:  Static
  2:  Static Random Color
  3:  Flash
  4:  Flash Random Color
  5:  Fade
  6:  Fade Random Color
  7:  Rotate
  8:  Rotate Random Color
  9:  Fill
  10: Fill Random Color
  11: Boomerang
  12: Boomerang Random Color
*/

// Libraries
#include <WiFi.h>
#include <PubSubClient.h>
#include <FastLED.h>

// WiFi
#define WIFI_SSID "Wokwi-GUEST"
#define WIFI_PASS ""

// MQTT
#define MQTT_ID                "LED_Ring"
#define MQTT_SERVER            "test.mosquitto.org"
#define MQTT_SERVER_PORT       1883
// Topics Subscibed to
#define MQTT_TOPIC_MODE        "NUV/LED_Ring/MODE"
#define MQTT_TOPIC_SPEED       "NUV/LED_Ring/SPEED"
#define MQTT_TOPIC_RANGE_START "NUV/LED_Ring/RANGE_START"
#define MQTT_TOPIC_RANGE_END   "NUV/LED_Ring/RANGE_END"
#define MQTT_TOPIC_COLOR       "NUV/LED_Ring/COLOR"
// Topics Published on
#define MQTT_TOPIC_ACK         "NUV/LED_Ring/ACK" // Send Acknowledgement Back to Node-RED when anything is Received.
// Publish Messages
#define MQTT_ACK_MESSAGE_OK    "Ok!"
#define MQTT_ACK_MESSAGE_ERROR "Error! "

// LED Ring
#define LED_RING_DIN_PIN 12
#define TOTAL_LEDS       60

// Instances
WiFiClient   wifiClient;
PubSubClient pubSubClient(wifiClient);
CRGB         ledRing[TOTAL_LEDS];

// Constants
// LED Mode
#define LED_MODE_OFF                    0
#define LED_MODE_STATIC                 1
#define LED_MODE_STATIC_RANDOM_COLOR    2
#define LED_MODE_FLASH                  3
#define LED_MODE_FLASH_RANDOM_COLOR     4
#define LED_MODE_FADE                   5
#define LED_MODE_FADE_RANDOM_COLOR      6
#define LED_MODE_ROTATE                 7
#define LED_MODE_ROTATE_RANDOM_COLOR    8
#define LED_MODE_FILL                   9
#define LED_MODE_FILL_RANDOM_COLOR      10
#define LED_MODE_BOOMERANG              11
#define LED_MODE_BOOMERANG_RANDOM_COLOR 12
#define LED_MODE_FIRST                  LED_MODE_OFF
#define LED_MODE_LAST                   LED_MODE_BOOMERANG_RANDOM_COLOR
// LED Speed
#define LED_SPEED_MIN                   1
#define LED_SPEED_MAX                   100
// LED Range
#define LED_RANGE_MIN                   1
#define LED_RANGE_MAX                   TOTAL_LEDS
// LED Color
#define LED_COLOR_FORMAT                "rgb"
#define LED_COLOR_MIN                   0
#define LED_COLOR_MAX                   255
// Animation Step Interval (Inversely Proportional to LED Speed)
#define MIN_INTERVAL                    1    // ms (Highest Speed -> Speed Slider set to 100%)
#define MAX_INTERVAL                    1000 // ms (Lowest Speed  -> Speed Slider set to 1%)

// Variables
uint8_t  ledMode       = 0;
uint8_t  lastLedMode   = 0;
uint8_t  ledSpeed      = 1;
uint16_t ledRangeStart = 1;
uint16_t ledRangeEnd   = 1;
uint8_t  ledColorR     = 0;
uint8_t  ledColorG     = 0;
uint8_t  ledColorB     = 0;

// Functions
// MQTT Call-Back Function
void callback(char* topic, uint8_t* payload, unsigned int length)
{
  String  topicStr = String(topic);
  String  data     = "";

  uint16_t tempInt = 0;
  bool    error    = 0;
  String  errorStr = String(MQTT_ACK_MESSAGE_ERROR);

  uint8_t lcsi = 0; // Last Color Seperator Index
  uint8_t ncsi = 0; // Next Color Seperator Index

  // Convert Raw Bytes to Character String.
  for (uint8_t i = 0; i < length; i++)
  {
    data += char(payload[i]);
  }

  Serial.println("Received: \"" + data +  "\" on Topic: \"" + topicStr + "\"");

  tempInt = data.toInt();

  // Check Topic
  if (topicStr == String(MQTT_TOPIC_MODE))
  {
    // Mode
    // Set it if it's in Range, otherwise Show an Error.
    if ((tempInt >= LED_MODE_FIRST) && (tempInt <= LED_MODE_LAST))
    {
      ledMode = tempInt;
      Serial.println("LED Mode Set to: " + String(ledMode));

      lastLedMode = !ledMode; // Re-Run
    }
    else
    {
      error = 1;
      errorStr += "Value Out of Range! Can't Set Mode.";
      Serial.println(errorStr);
    }
  }
  else if (topicStr == String(MQTT_TOPIC_SPEED))
  {
    // Speed
    // Set it if it's in Range, otherwise Show an Error.
    if ((tempInt >= LED_SPEED_MIN) && (tempInt <= LED_SPEED_MAX))
    {
      ledSpeed = tempInt;
      Serial.println("LED Speed Set to: " + String(ledSpeed));
    }
    else
    {
      error = 1;
      errorStr += "Value Out of Range! Can't Set Speed.";
      Serial.println(errorStr);
    }
  }
  else if (topicStr == String(MQTT_TOPIC_RANGE_START))
  {
    // Range Start
    // Set it if it's in Range, otherwise Show an Error.
    if ((tempInt >= LED_RANGE_MIN) && (tempInt <= LED_RANGE_MAX))
    {
      ledRangeStart = tempInt;
      Serial.println("LED Range Start Set to: " + String(ledRangeStart));

      lastLedMode = !ledMode; // Re-Run
    }
    else
    {
      error = 1;
      errorStr += "Value Out of Range! Can't Set Range Start.";
      Serial.println(errorStr);
    }
  }
  else if (topicStr == String(MQTT_TOPIC_RANGE_END))
  {
    // Range End
    // Set it if it's in Range, otherwise Show an Error.
    if ((tempInt >= LED_RANGE_MIN) && (tempInt <= LED_RANGE_MAX))
    {
      ledRangeEnd = tempInt;
      Serial.println("LED Range End Set to: " + String(ledRangeEnd));

      lastLedMode = !ledMode; // Re-Run
    }
    else
    {
      error = 1;
      errorStr += "Value Out of Range! Can't Set Range End.";
      Serial.println(errorStr);
    }
  }
  else if (topicStr == String(MQTT_TOPIC_COLOR))
  {
    // Color
    if (data.startsWith(LED_COLOR_FORMAT))
    {
      Serial.println("Valid Color Format!"); // Valid Color Format -> "rgb(r, g, b)" Where r / g / b are 8-bit Values for Red, Green and Blue Components of the Color Respectively.
      data.replace(" ", "");                 // Remove White Spaces -> "rgb(r,g,b)"

      // Example for Explanation: rgb(255,127,63)

      // Extract Red Color
      ncsi = data.indexOf(",");                                      // Get the Position of the First Color Seperator "," -> "rgb(r," -> e.g. "rgb(255," -> "7" (as Index Starts from 0)
      tempInt = data.substring(data.indexOf("(") + 1, ncsi).toInt(); // Get the Numerical/Integer Value of Red Color that starts after the Position of "(" (4) and ends before "," (7 - from the Example Above).
      lcsi = ncsi;                                                   // Save the First Color Seperator Index as Previously Found Index to use it to Find the Next/Second Color Seperator, which is used to Extract the Green Color.
      // Set it if it's in Range, otherwise Show an Error.
      if ((tempInt >= LED_COLOR_MIN) && (tempInt <= LED_COLOR_MAX))
      {
        ledColorR = tempInt;
        Serial.println("LED Color Red Set to: " + String(ledColorR));
      }
      else
      {
        error = 1;
        errorStr += "Value Out of Range! Can't Set Red Color.";
        Serial.println(errorStr);
      }

      // Extract Green Color (only if there was No Error Processing the Red Color, otherwise Skip the Extraction)
      if (!error)
      {
        ncsi = data.indexOf(",", lcsi + 1);               // Get the Position of the Next Color Seperator "," By Starting the Search from One Position Greater than the Last Seperator -> "rgb(r,g," -> "g," -> e.g. "rgb(255,127," -> "127," -> "11" (as the Search Index starts from 8 (lcsi + 1))
        tempInt = data.substring(lcsi + 1, ncsi).toInt(); // Get the Numerical/Integer Value of Green Color that starts after the Position of First Color Seperator "," (8 - from the Example Above) and ends before Second Color Seperator "," (11 - from the Example Above).
        lcsi = ncsi;                                      // Save the Second Color Seperator Index as Previously Found Index, which is used to Extract the Blue Color.
        // Set it if it's in Range, otherwise Show an Error.
        if ((tempInt >= LED_COLOR_MIN) && (tempInt <= LED_COLOR_MAX))
        {
          ledColorG = tempInt;
          Serial.println("LED Color Green Set to: " + String(ledColorG));
        }
        else
        {
          error = 1;
          errorStr += "Value Out of Range! Can't Set Green Color.";
          Serial.println(errorStr);
        }
      }
      else
      {
        Serial.println("Green Color Extraction Skipped!");
      }

      // Extract Blue Color (only if there was No Error Processing the Red & Green Colors, otherwise Skip the Extraction)
      if (!error)
      {
        tempInt = data.substring(lcsi + 1, data.indexOf(")")).toInt(); // Get the Numerical/Integer Value of Blue Color that starts after the Position of Second Color Seperator "," (12 - from the Example Above) and ends before ")" (14 - from the Example Above).
        // Set it if it's in Range, otherwise Show an Error.
        if ((tempInt >= LED_COLOR_MIN) && (tempInt <= LED_COLOR_MAX))
        {
          ledColorB = tempInt;
          Serial.println("LED Color Blue Set to: " + String(ledColorB));
        }
        else
        {
          error = 1;
          errorStr += "Value Out of Range! Can't Set Blue Color.";
          Serial.println(errorStr);
        }
        
      }
      else
      {
        Serial.println("Blue Color Extraction Skipped!");
      }

      if (!error)
      {
        lastLedMode = !ledMode; // Re-Run
      }
    }
    else
    {
      error = 1;
      errorStr += "Invalid Color Format! Can't Set Color.";
      Serial.println(errorStr);
    }
  }

  if (!error)
  {
    pubSubClient.publish(MQTT_TOPIC_ACK, MQTT_ACK_MESSAGE_OK);
  }
  else
  {
    pubSubClient.publish(MQTT_TOPIC_ACK, errorStr.c_str());
  }
}

// Setup
void setup() 
{
  // Serial (Debug Monitor)
  Serial.begin(115200);

  // WiFi
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);

  Serial.print("\nConnecting to WiFi Network: " + String(WIFI_SSID) + " ");
  while (WiFi.status() != WL_CONNECTED)
  {
    Serial.print(".");
    delay(1000);
  }
  Serial.println("\nConnected!");

  // MQTT
  pubSubClient.setServer(MQTT_SERVER, MQTT_SERVER_PORT);
  pubSubClient.setCallback(callback);

  // LED Ring
  FastLED.addLeds<WS2812, LED_RING_DIN_PIN, GRB>(ledRing, TOTAL_LEDS);
}

// Loop
void loop()
{
  //delay(10); // this speeds up the simulation

  // Local Variables
  static bool     direction = 1; // 0: Count Down (Anti-Clockwise), 1: Count Up (Clockwise)
  static uint32_t lastTime  = 0; // Animation Step Time Keeper
  static int16_t  index     = 0; // LED Index
  static bool     state     = 0; // LED State
  static uint8_t  level     = 0; // LED Level
         uint16_t interval  = map(ledSpeed, LED_SPEED_MIN, LED_SPEED_MAX, MAX_INTERVAL, MIN_INTERVAL);

  // MQTT
  while (!pubSubClient.connected())
  {
    Serial.println("Connecting to MQTT Server: \"" + String(MQTT_SERVER) + "\" as \"" + String(MQTT_ID) + "\"");
    if (pubSubClient.connect(MQTT_ID))
    {
      Serial.println("Successfully Connected to MQTT Server!");

      // Subscribe to MQTT Topic: Mode
      if (pubSubClient.subscribe(MQTT_TOPIC_MODE))
      {
        Serial.println("Successfully Subscribed to MQTT Topic: \"" + String(MQTT_TOPIC_MODE) + "\"");
      }
      else
      {
        Serial.println("Error Subscribing to MQTT Topic: \"" + String(MQTT_TOPIC_MODE) + "\"");
      }

      // Subscribe to MQTT Topic: Speed
      if (pubSubClient.subscribe(MQTT_TOPIC_SPEED))
      {
        Serial.println("Successfully Subscribed to MQTT Topic: \"" + String(MQTT_TOPIC_SPEED) + "\"");
      }
      else
      {
        Serial.println("Error Subscribing to MQTT Topic: \"" + String(MQTT_TOPIC_SPEED) + "\"");
      }

      // Subscribe to MQTT Topic: Range Start
      if (pubSubClient.subscribe(MQTT_TOPIC_RANGE_START))
      {
        Serial.println("Successfully Subscribed to MQTT Topic: \"" + String(MQTT_TOPIC_RANGE_START) + "\"");
      }
      else
      {
        Serial.println("Error Subscribing to MQTT Topic: \"" + String(MQTT_TOPIC_RANGE_START) + "\"");
      }

      // Subscribe to MQTT Topic: Range End
      if (pubSubClient.subscribe(MQTT_TOPIC_RANGE_END))
      {
        Serial.println("Successfully Subscribed to MQTT Topic: \"" + String(MQTT_TOPIC_RANGE_END) + "\"");
      }
      else
      {
        Serial.println("Error Subscribing to MQTT Topic: \"" + String(MQTT_TOPIC_RANGE_END) + "\"");
      }

      // Subscribe to MQTT Topic: Color
      if (pubSubClient.subscribe(MQTT_TOPIC_COLOR))
      {
        Serial.println("Successfully Subscribed to MQTT Topic: \"" + String(MQTT_TOPIC_COLOR) + "\"");
      }
      else
      {
        Serial.println("Error Subscribing to MQTT Topic: \"" + String(MQTT_TOPIC_COLOR) + "\"");
      }
    }
    else
    {
      Serial.println("Error Connecting to MQTT Server! (" + String(pubSubClient.state()) + ")");
    }
  }

  pubSubClient.loop();

  // LED Ring
  // Run Once, if A Parameter has Changed.
  if (lastLedMode != ledMode)
  {
    if (ledRangeStart < ledRangeEnd)
    {
      Serial.println("Direction: Clockwise (Up Count)");
      direction = 1;
    }
    else if (ledRangeStart > ledRangeEnd)
    {
      Serial.println("Direction: Anti-Clockwise (Down Count)");
      direction = 0;
    }
    else
    {
      Serial.println("Direction: None");
    }

    lastTime = 0;
    index    = 0;
    state    = 0;
    level    = 0;

    FastLED.clear();
  }

  // LED Modes
  if (ledMode == LED_MODE_OFF)
  {
    // Off

    if (lastLedMode != ledMode)
    {
      // FastLED.clear();
      FastLED.show();
    }
  }
  else if ((ledMode == LED_MODE_STATIC) || (ledMode == LED_MODE_STATIC_RANDOM_COLOR))
  {
    // Static or Static Random Color

    if (lastLedMode != ledMode)
    {
      if (ledMode == LED_MODE_STATIC_RANDOM_COLOR)
      {
        ledColorR = random(256);
        ledColorG = random(256);
        ledColorB = random(256);
      }

      if (direction)
      {
        // Count Up
        for (index = (ledRangeStart - 1); index < ledRangeEnd; index++)
        {
          ledRing[index] = CRGB(ledColorR, ledColorG, ledColorB);
          delay(1); // Delay to Avoid Simulation Bugs
        }
      }
      else
      {
        // Count Down
        for (index = (ledRangeStart - 1); index >= (ledRangeEnd - 1); index--)
        {
          ledRing[index] = CRGB(ledColorR, ledColorG, ledColorB);
          delay(1); // Delay to Avoid Simulation Bugs
        }
      }

      FastLED.show();
    }
  }
  else if ((ledMode == LED_MODE_FLASH) || (ledMode == LED_MODE_FLASH_RANDOM_COLOR))
  {
    // Flash or Flash Random Color

    if (millis() - lastTime >= interval)
    {
      state = !state;

      if (state)
      {
        if (ledMode == LED_MODE_FLASH_RANDOM_COLOR)
        {
          ledColorR = random(256);
          ledColorG = random(256);
          ledColorB = random(256);
        }

        if (direction)
        {
          // Count Up
          for (index = (ledRangeStart - 1); index < ledRangeEnd; index++)
          {
            ledRing[index] = CRGB(ledColorR, ledColorG, ledColorB);
            delay(1); // Delay to Avoid Simulation Bugs
          }
        }
        else
        {
          // Count Down
          for (index = (ledRangeStart - 1); index >= (ledRangeEnd - 1); index--)
          {
            ledRing[index] = CRGB(ledColorR, ledColorG, ledColorB);
            delay(1); // Delay to Avoid Simulation Bugs
          }
        }
      }
      else
      {
        FastLED.clear();
      }

      FastLED.show();

      lastTime = millis();
    }
  }
  else if ((ledMode == LED_MODE_FADE) || (ledMode == LED_MODE_FADE_RANDOM_COLOR))
  {
    // Fade or Fade Random Color

    if (lastLedMode != ledMode)
    {
      state = 1;
    }

    if (millis() - lastTime >= interval)
    {
      if (state)
      {
        level++; // Fade In
      }
      else
      {
        level--; // Fade Out
      }

      if (direction)
      {
        // Count Up
        for (index = (ledRangeStart - 1); index < ledRangeEnd; index++)
        {
          ledRing[index] = CRGB(ledColorR * level/255, ledColorG * level/255, ledColorB * level/255);
          delay(1); // Delay to Avoid Simulation Bugs
        }
      }
      else
      {
        // Count Down
        for (index = (ledRangeStart - 1); index >= (ledRangeEnd - 1); index--)
        {
          ledRing[index] = CRGB(ledColorR * level/255, ledColorG * level/255, ledColorB * level/255);
          delay(1); // Delay to Avoid Simulation Bugs
        }
      }

      // If Upper or Lower Limit has been Reached, Invert Counter / Fade Direction
      if (level >= 255)
      {
        state = 0; // Count Down (Fade Out) from the Next Iteration
      }
      else if (level <= 0)
      {
        // Set the Next Random Color for the Next Fade Cycle (only if the LED Mode is set to Fade Random Color)
        if (ledMode == LED_MODE_FADE_RANDOM_COLOR)
        {
          ledColorR = random(256);
          ledColorG = random(256);
          ledColorB = random(256);
        }

        state = 1; // Count Up (Fade In) from the Next Iteration
      }

      FastLED.show();

      lastTime = millis();
    }
  }
  else if ((ledMode == LED_MODE_ROTATE) || (ledMode == LED_MODE_ROTATE_RANDOM_COLOR))
  {
    // Rotate or Rotate Random Color

    if (lastLedMode != ledMode)
    {
      index = (ledRangeStart - 1);
    }

    if (millis() - lastTime >= interval)
    {
      // Clear All and Only Set the Pixel Corresponding to the Current Index.
      FastLED.clear();
      ledRing[index] = CRGB(ledColorR, ledColorG, ledColorB);
      delay(1); // Delay to Avoid Simulation Bugs

      // Set the Index for Next Iteration.
      if (direction)
      {
        // Count Up
        index++;

        // If Range End has been Crossed, Reset the Index to the Starting Position and Set the Next Random Color for the Next Rotation (only if the LED Mode is set to Rotate Random Color)
        if (index > (ledRangeEnd - 1))
        {
          if (ledMode == LED_MODE_ROTATE_RANDOM_COLOR)
          {
            ledColorR = random(256);
            ledColorG = random(256);
            ledColorB = random(256);
          }

          index = (ledRangeStart - 1);
        }
      }
      else
      {
        // Count Down
        index--;

        // If Range End has been Crossed, Reset the Index to the Starting Position and Set the Next Random Color for the Next Rotation (only if the LED Mode is set to Rotate Random Color)
        if (index < (ledRangeEnd - 1))
        {
          if (ledMode == LED_MODE_ROTATE_RANDOM_COLOR)
          {
            ledColorR = random(256);
            ledColorG = random(256);
            ledColorB = random(256);
          }

          index = (ledRangeStart - 1);
        }
      }

      FastLED.show();

      lastTime = millis();
    }
  }
  else if ((ledMode == LED_MODE_FILL) || (ledMode == LED_MODE_FILL_RANDOM_COLOR))
  {
    // Fill or Fill Random Color

    if (lastLedMode != ledMode)
    {
      index = (ledRangeStart - 1);
    }

    if (millis() - lastTime >= interval)
    {
      // If the Current Index is the Starting Index, Clear All
      if (index == (ledRangeStart - 1))
      {
        FastLED.clear();
      }

      // Set the Pixel Corresponding to the Current Index.
      ledRing[index] = CRGB(ledColorR, ledColorG, ledColorB);
      delay(1); // Delay to Avoid Simulation Bugs

      // Set the Index for Next Iteration.
      if (direction)
      {
        // Count Up
        index++;

        // If Range End has been Crossed, Reset the Index to the Starting Position and Set the Next Random Color for the Next Fill Cycle (only if the LED Mode is set to Fill Random Color)
        if (index > (ledRangeEnd - 1))
        {
          if (ledMode == LED_MODE_FILL_RANDOM_COLOR)
          {
            ledColorR = random(256);
            ledColorG = random(256);
            ledColorB = random(256);
          }

          index = (ledRangeStart - 1);
        }
      }
      else
      {
        // Count Down
        index--;

        // If Range End has been Crossed, Reset the Index to the Starting Position and Set the Next Random Color for the Next Fill Cycle (only if the LED Mode is set to Fill Random Color)
        if (index < (ledRangeEnd - 1))
        {
          if (ledMode == LED_MODE_FILL_RANDOM_COLOR)
          {
            ledColorR = random(256);
            ledColorG = random(256);
            ledColorB = random(256);
          }

          index = (ledRangeStart - 1);
        }
      }

      FastLED.show();

      lastTime = millis();
    }
  }
  else if ((ledMode == LED_MODE_BOOMERANG) || (ledMode == LED_MODE_BOOMERANG_RANDOM_COLOR))
  {
    // Boomerang or Boomerang Random Color

    if (lastLedMode != ledMode)
    {
      index = (ledRangeStart - 1);
      state = direction;
    }

    if (millis() - lastTime >= interval)
    {
      // Clear All and Only Set the Pixel Corresponding to the Current Index.
      FastLED.clear();
      ledRing[index] = CRGB(ledColorR, ledColorG, ledColorB);
      delay(1); // Delay to Avoid Simulation Bugs

      // Set the Next Index.
      if (state)
      {
        index++;
      }
      else
      {
        index--;
      }

      if (direction)
      {
        // One Cycle is Down-to-Up-to-Down

        // First Half Cycle Complete (Down-to-Up) | If the Upper Range has been Crossed, Set the Index to One Index Lower than the Highest Index
        if (index > (ledRangeEnd - 1))
        {
          index = (ledRangeEnd - 2); // One Lower than the Highest (For Seamless Animation)
          state = 0;                 // Count Down from the Next Iteration
        }
        // Second Half Cycle Complete (Up-to-Down) -> Full Cycle Complete | If the Lower Range has been Crossed, Set the Index to One Index Higher than the Lowest Index and Set the Next Random Color for the Next Boomerang Cycle (only if the LED Mode is set to Boomerang Random Color)
        else if (index < (ledRangeStart - 1))
        {
          if (ledMode == LED_MODE_BOOMERANG_RANDOM_COLOR)
          {
            ledColorR = random(256);
            ledColorG = random(256);
            ledColorB = random(256);
          }

          index = ledRangeStart; // One Higher than the Lowest (For Seamless Animation)
          state = 1;             // Count Up from the Next Iteration
        }
      }
      else
      {
        // One Cycle is Up-to-Down-to-Up

        // First Half Cycle Complete (Up-to-Down) | If the Lower Range has been Crossed, Set the Index to One Index Higher than the Lowest Index
        if (index < (ledRangeEnd - 1))
        {
          index = ledRangeEnd; // One Higher than the Lowest (For Seamless Animation)
          state = 1;           // Count Up from the Next Iteration
        }
        // Second Half Cycle Complete (Down-to-Up) -> Full Cycle Complete | If the Upper Range has been Crossed, Set the Index to One Index Lower than the Highest Index and Set the Next Random Color for the Next Boomerang Cycle (only if the LED Mode is set to Boomerang Random Color)
        else if (index > (ledRangeStart - 1))
        {
          if (ledMode == LED_MODE_BOOMERANG_RANDOM_COLOR)
          {
            ledColorR = random(256);
            ledColorG = random(256);
            ledColorB = random(256);
          }

          index = (ledRangeStart - 2); // One Lower than the Highest (For Seamless Animation)
          state = 0;                   // Count Down from the Next Iteration
        }
      }

      FastLED.show();

      lastTime = millis();
    }
  }

  lastLedMode = ledMode;
}