rack_assistant_helpers.h

// SPDX-License-Identifier: GPL-3.0-or-later

#pragma once

#include "esphome/components/light/addressable_light.h"
#include "esphome/core/color.h"
#include "esphome/core/hal.h"

#include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <string>
#include <vector>

#ifndef RACK_UNIT_COUNT
#define RACK_UNIT_COUNT 15
#endif

namespace rack_fx {

struct Segment {
  int start;
  int width;
};

struct RgbwChannels {
  float red;
  float green;
  float blue;
  float white;
};

constexpr int RACK_MODE_MANUAL = 0;
constexpr int RACK_MODE_ZONE_STATIC = 1;
constexpr int RACK_MODE_ZONE_BREATHING_SELECTED = 2;
constexpr int RACK_MODE_ZONE_BREATHING_BLUE = 3;
constexpr int RACK_MODE_ZONE_BREATHING_ORANGE = 4;
constexpr int RACK_MODE_ZONE_BREATHING_RED = 5;
constexpr int RACK_MODE_CALIBRATION_BLOCK = 6;
constexpr int RACK_MODE_DOOR_OPEN = 7;
constexpr int RACK_MODE_RESTORE_TRANSITION = 8;
constexpr int RACK_MODE_U_ALERTS = 9;
constexpr int RACK_MODE_ZONE_BREATHING_WHITE = 10;
constexpr int RACK_MODE_INTERNET_DOWN = 11;
constexpr int RACK_MODE_CENTER_BURST_ERROR = 12;
constexpr int RACK_MODE_CENTER_BURST_SUCCESS = 13;
constexpr int RACK_MODE_U_SCAN_RED = 14;
constexpr int RACK_MODE_U_SCAN_SELECTED = 15;

constexpr int BREATHING_CURVE_SMOOTH = 0;
constexpr int BREATHING_CURVE_DYNAMIC = 1;
constexpr int BREATHING_CURVE_NATURAL = 2;

constexpr int ALERT_NONE = 0;
constexpr int ALERT_SELECTED_STATIC = 1;
constexpr int ALERT_SELECTED_BREATHING = 2;
constexpr int ALERT_UNIFI_BREATHING = 3;
constexpr int ALERT_ORANGE_BREATHING = 4;
constexpr int ALERT_RED_BREATHING = 5;
constexpr int ALERT_WHITE_BREATHING = 6;
constexpr int ALERT_RED_BLINK = 7;
constexpr int ALERT_WHITE_BLINK = 8;
constexpr int ALERT_UNIFI_BLINK = 9;
constexpr int ALERT_ORANGE_BLINK = 10;
constexpr int ALERT_CUSTOM_STATIC = 11;
constexpr int ALERT_CUSTOM_BREATHING = 12;
constexpr int ALERT_CUSTOM_BLINK = 13;
constexpr int ALERT_WHITE_STATIC = 14;
constexpr int ALERT_SELECTED_BLINK = 15;

struct UAlertSlot {
  bool active = false;
  int first_u = 1;
  int last_u = 1;
  int mode = ALERT_NONE;
  uint32_t start_ms = 0;
  float red = 0.0f;
  float green = 0.0f;
  float blue = 0.0f;
  float white = 0.0f;
};

inline float clamp01(float value) {
  if (value < 0.0f) {
    return 0.0f;
  }
  if (value > 1.0f) {
    return 1.0f;
  }
  return value;
}

inline uint32_t breathing_cycle_ms(float seconds) {
  auto cycle = uint32_t(seconds * 1000.0f);
  return cycle < 1000 ? 1000 : cycle;
}

inline void clamp_brightness_range(float &minimum, float &maximum) {
  minimum = clamp01(minimum);
  if (maximum < minimum + 0.02f) {
    maximum = minimum + 0.02f;
  }
  maximum = clamp01(maximum);
}

inline float smootherstep(float value) {
  return value * value * value * (value * (value * 6.0f - 15.0f) + 10.0f);
}

inline float ease_in_out_sine(float value) {
  value = clamp01(value);
  return 0.5f - 0.5f * cosf(value * 3.14159265f);
}

inline int breathing_curve_mode(const std::string &option) {
  if (option == "Dynamic") {
    return BREATHING_CURVE_DYNAMIC;
  }
  if (option == "Natural") {
    return BREATHING_CURVE_NATURAL;
  }
  return BREATHING_CURVE_SMOOTH;
}

inline float breathing_curve(uint32_t start_ms, uint32_t cycle_ms, int curve_mode) {
  const float phase = ((millis() - start_ms) % cycle_ms) / float(cycle_ms);

  float eased;
  if (curve_mode == BREATHING_CURVE_NATURAL) {
    constexpr float inhale_time = 0.40f;
    constexpr float exhale_time = 1.0f - inhale_time;

    if (phase < inhale_time) {
      eased = ease_in_out_sine(phase / inhale_time);
    } else {
      const float exhale = (phase - inhale_time) / exhale_time;
      eased = 1.0f - powf(clamp01(exhale), 1.15f);
    }
  } else if (curve_mode == BREATHING_CURVE_DYNAMIC) {
    constexpr float bottom_hold = 0.015f;
    constexpr float inhale_time = 0.39f;
    constexpr float exhale_time = 1.0f - bottom_hold - inhale_time;

    if (phase < bottom_hold) {
      eased = 0.0f;
    } else if (phase < bottom_hold + inhale_time) {
      const float inhale = (phase - bottom_hold) / inhale_time;
      eased = ease_in_out_sine(inhale);
    } else {
      const float exhale = (phase - bottom_hold - inhale_time) / exhale_time;
      eased = 1.0f - powf(clamp01(exhale), 1.35f);
    }
  } else {
    const float wave = 0.5f - 0.5f * cosf(phase * 6.2831853f);
    eased = wave;
  }

  return clamp01(eased);
}

inline float breathing_level(uint32_t start_ms, uint32_t cycle_ms, float minimum, float maximum, int curve_mode) {
  const float eased = breathing_curve(start_ms, cycle_ms, curve_mode);
  return minimum + (maximum - minimum) * eased;
}

inline float transition_progress(uint32_t start_ms, float duration_ms) {
  const float progress = clamp01((millis() - start_ms) / duration_ms);
  return smootherstep(progress);
}

inline uint8_t scaled_channel(float value) {
  return uint8_t(roundf(clamp01(value) * 255.0f));
}

inline uint8_t dithered_channel(float value, int index, uint8_t salt);

inline void clamp_segment(int &start, int &width, int total) {
  if (width <= 0 || total <= 0) {
    width = 0;
    return;
  }
  if (start < 0) {
    start = 0;
  }
  if (start >= total) {
    start = total - 1;
  }
  if (start + width > total) {
    width = total - start;
  }
}

inline int clamp_int(int value, int minimum, int maximum) {
  if (value < minimum) {
    return minimum;
  }
  if (value > maximum) {
    return maximum;
  }
  return value;
}

inline float clamp_channel(float value) {
  if (value < 0.0f) {
    return 0.0f;
  }
  if (value > 255.0f) {
    return 255.0f;
  }
  return value;
}

inline void separate_rgbw_unit(float &red, float &green, float &blue, float &white) {
  red = clamp01(red);
  green = clamp01(green);
  blue = clamp01(blue);
  white = clamp01(white);

  if (red > 0.0f || green > 0.0f || blue > 0.0f) {
    white = 0.0f;
  } else {
    red = 0.0f;
    green = 0.0f;
    blue = 0.0f;
  }
}

inline void separate_rgbw_channels(float &red, float &green, float &blue, float &white) {
  red = clamp_channel(red);
  green = clamp_channel(green);
  blue = clamp_channel(blue);
  white = clamp_channel(white);

  if (red > 0.0f || green > 0.0f || blue > 0.0f) {
    white = 0.0f;
  } else {
    red = 0.0f;
    green = 0.0f;
    blue = 0.0f;
  }
}

inline RgbwChannels separated_rgbw_unit(float red, float green, float blue, float white) {
  separate_rgbw_unit(red, green, blue, white);
  return RgbwChannels{red, green, blue, white};
}

inline RgbwChannels separated_rgbw_channels(float red, float green, float blue, float white) {
  separate_rgbw_channels(red, green, blue, white);
  return RgbwChannels{red, green, blue, white};
}

inline bool rack_mode_is_zone_breathing(int mode) {
  return mode == RACK_MODE_ZONE_BREATHING_SELECTED ||
         mode == RACK_MODE_ZONE_BREATHING_BLUE ||
         mode == RACK_MODE_ZONE_BREATHING_ORANGE ||
         mode == RACK_MODE_ZONE_BREATHING_RED ||
         mode == RACK_MODE_ZONE_BREATHING_WHITE ||
         mode == RACK_MODE_INTERNET_DOWN;
}

inline RgbwChannels rack_mode_breathing_channels(
  int mode,
  const esphome::Color &selected_color,
  float level
) {
  switch (mode) {
    case RACK_MODE_ZONE_BREATHING_WHITE:
      return RgbwChannels{0.0f, 0.0f, 0.0f, level * 255.0f};
    case RACK_MODE_ZONE_BREATHING_BLUE:
      return RgbwChannels{0.0f, level * 111.0f, level * 255.0f, 0.0f};
    case RACK_MODE_ZONE_BREATHING_ORANGE:
      return RgbwChannels{level * 255.0f, level * 82.0f, 0.0f, 0.0f};
    case RACK_MODE_INTERNET_DOWN:
    case RACK_MODE_ZONE_BREATHING_RED:
      return RgbwChannels{level * 255.0f, 0.0f, 0.0f, 0.0f};
    case RACK_MODE_ZONE_BREATHING_SELECTED:
    default:
      return RgbwChannels{
        selected_color.r * level,
        selected_color.g * level,
        selected_color.b * level,
        0.0f
      };
  }
}

inline std::string normalize_name(std::string value) {
  for (char &ch : value) {
    if (ch == ' ' || ch == '-') {
      ch = '_';
    } else {
      ch = char(std::tolower(static_cast<unsigned char>(ch)));
    }
  }
  return value;
}

inline bool contains(const std::string &text, const char *needle) {
  return text.find(needle) != std::string::npos;
}

inline bool is_clear_alert_option(const std::string &effect) {
  const std::string name = normalize_name(effect);
  return name == "no_alert" || name == "none" || name == "off";
}

inline std::string canonical_alert_option(const std::string &effect) {
  if (is_clear_alert_option(effect)) {
    return "No alert";
  }

  const std::string name = normalize_name(effect);
  const bool selected = contains(name, "selected");
  const bool red = contains(name, "red");
  const bool orange = contains(name, "orange");
  const bool white = contains(name, "white");
  const bool blue = contains(name, "blue");

  if (selected) {
    return "Selected color blink";
  }
  if (white) {
    return "White blink";
  }
  if (orange) {
    return "Orange blink";
  }
  if (red) {
    return "Red blink";
  }
  if (blue) {
    return "Blue blink";
  }

  return "Red blink";
}

inline std::string canonical_mode_name(const std::string &effect) {
  if (effect == "Manual / no effect" || effect == "None") {
    return "Manual";
  }
  if (effect == "Selected color breathing") {
    return "Selected color breathing";
  }
  if (effect == "Blue breathing" || effect == "Blue breathing") {
    return "Blue breathing";
  }
  if (effect == "U alert") {
    return "U alerts";
  }
  if (effect == "Selected color U scan") {
    return "Selected color U scan";
  }
  if (effect == "Rainbow") {
    return "Rainbow";
  }
  if (effect == "Success" || effect == "Success") {
    return "Success";
  }
  if (effect == "Error") {
    return "Error";
  }
  return effect;
}

inline bool is_manual_mode_option(const std::string &effect) {
  return canonical_mode_name(effect) == "Manual";
}

inline bool is_alert_layer_mode_option(const std::string &effect) {
  return canonical_mode_name(effect) == "U alerts";
}

inline bool is_mode_select_effect(const std::string &effect) {
  const std::string name = canonical_mode_name(effect);
  return name == "White breathing" ||
         name == "Selected color breathing" ||
         name == "Blue breathing" ||
         name == "Orange breathing" ||
         name == "Red breathing" ||
         name == "Internet down" ||
         name == "Red U scan" ||
         name == "Selected color U scan" ||
         name == "White wipe" ||
         name == "Red wipe" ||
         name == "White scan" ||
         name == "Rainbow" ||
         name == "Error" ||
         name == "Success";
}

inline int internal_mode_for_select_option(const std::string &effect) {
  const std::string name = canonical_mode_name(effect);
  if (name == "White breathing") {
    return RACK_MODE_ZONE_BREATHING_WHITE;
  }
  if (name == "Selected color breathing") {
    return RACK_MODE_ZONE_BREATHING_SELECTED;
  }
  if (name == "Blue breathing") {
    return RACK_MODE_ZONE_BREATHING_BLUE;
  }
  if (name == "Orange breathing") {
    return RACK_MODE_ZONE_BREATHING_ORANGE;
  }
  if (name == "Red breathing") {
    return RACK_MODE_ZONE_BREATHING_RED;
  }
  if (name == "Internet down") {
    return RACK_MODE_INTERNET_DOWN;
  }
  if (name == "Error") {
    return RACK_MODE_CENTER_BURST_ERROR;
  }
  if (name == "Success") {
    return RACK_MODE_CENTER_BURST_SUCCESS;
  }
  if (name == "Red U scan") {
    return RACK_MODE_U_SCAN_RED;
  }
  if (name == "Selected color U scan") {
    return RACK_MODE_U_SCAN_SELECTED;
  }
  return RACK_MODE_MANUAL;
}

inline std::string select_option_for_internal_mode(int mode) {
  switch (mode) {
    case RACK_MODE_U_ALERTS:
      return "U alerts";
    case RACK_MODE_ZONE_BREATHING_WHITE:
      return "White breathing";
    case RACK_MODE_ZONE_BREATHING_SELECTED:
      return "Selected color breathing";
    case RACK_MODE_ZONE_BREATHING_BLUE:
      return "Blue breathing";
    case RACK_MODE_ZONE_BREATHING_ORANGE:
      return "Orange breathing";
    case RACK_MODE_ZONE_BREATHING_RED:
      return "Red breathing";
    case RACK_MODE_INTERNET_DOWN:
      return "Internet down";
    case RACK_MODE_CENTER_BURST_ERROR:
      return "Error";
    case RACK_MODE_CENTER_BURST_SUCCESS:
      return "Success";
    case RACK_MODE_U_SCAN_RED:
      return "Red U scan";
    case RACK_MODE_U_SCAN_SELECTED:
      return "Selected color U scan";
    default:
      return "";
  }
}

inline int alert_mode_from_name(const std::string &effect, bool custom_color) {
  if (is_clear_alert_option(effect)) {
    return ALERT_NONE;
  }

  const std::string name = normalize_name(effect);
  const bool blink = contains(name, "blink");
  const bool fixed = contains(name, "static");
  const bool selected = contains(name, "selected");
  const bool red = contains(name, "red");
  const bool orange = contains(name, "orange");
  const bool white = contains(name, "white");
  const bool blue = contains(name, "blue");

  if (custom_color) {
    if (blink) {
      return ALERT_CUSTOM_BLINK;
    }
    if (fixed) {
      return ALERT_CUSTOM_STATIC;
    }
    return ALERT_CUSTOM_BREATHING;
  }

  if (selected) {
    return ALERT_SELECTED_BLINK;
  }
  if (white) {
    return ALERT_WHITE_BLINK;
  }
  if (blue) {
    return ALERT_UNIFI_BLINK;
  }
  if (orange) {
    return ALERT_ORANGE_BLINK;
  }
  if (red) {
    return ALERT_RED_BLINK;
  }

  return ALERT_RED_BLINK;
}

inline Segment rack_u_segment(int u, int side_start, int side_len, bool reversed_side) {
  u = clamp_int(u, 1, RACK_UNIT_COUNT);
  const int start_offset = int(roundf((u - 1) * side_len / float(RACK_UNIT_COUNT)));
  const int end_offset = int(roundf(u * side_len / float(RACK_UNIT_COUNT)));
  const int width = std::max(1, end_offset - start_offset);

  if (!reversed_side) {
    return Segment{side_start + start_offset, width};
  }

  const int side_end = side_start + side_len - 1;
  return Segment{side_end - (end_offset - 1), width};
}

inline bool is_in_segment(int index, int start, int width) {
  return width > 0 && index >= start && index < start + width;
}

inline bool is_in_visible_rack(
  int index,
  int bottom_start,
  int bottom_len,
  int left_start,
  int side_len,
  int top_start,
  int top_len,
  int right_start
) {
  return is_in_segment(index, bottom_start, bottom_len) ||
         is_in_segment(index, left_start, side_len) ||
         is_in_segment(index, top_start, top_len) ||
         is_in_segment(index, right_start, side_len);
}

inline std::string canonical_zone_option(const std::string &option) {
  if (option == "Laterales" || option == "Side rails") {
    return "Side rails";
  }
  if (option == "Arriba" || option == "Top only") {
    return "Top only";
  }
  if (option == "Abajo" || option == "Bottom only") {
    return "Bottom only";
  }
  return "Whole rack";
}

inline bool is_in_u_range(int index, int first_u, int last_u, int left_start, int side_len, int right_start) {
  first_u = clamp_int(first_u, 1, RACK_UNIT_COUNT);
  last_u = clamp_int(last_u, 1, RACK_UNIT_COUNT);
  if (first_u > last_u) {
    std::swap(first_u, last_u);
  }

  for (int u = first_u; u <= last_u; u++) {
    const Segment left = rack_u_segment(u, left_start, side_len, false);
    const Segment right = rack_u_segment(u, right_start, side_len, true);
    if (is_in_segment(index, left.start, left.width) || is_in_segment(index, right.start, right.width)) {
      return true;
    }
  }

  return false;
}

inline bool is_in_zone(
  int index,
  const std::string &zone_mode,
  int first_u,
  int last_u,
  int bottom_start,
  int bottom_len,
  int left_start,
  int side_len,
  int top_start,
  int top_len,
  int right_start
) {
  if (zone_mode == "Whole rack") {
    return is_in_visible_rack(index, bottom_start, bottom_len, left_start, side_len, top_start, top_len, right_start);
  }

  if (zone_mode == "Side rails") {
    return is_in_segment(index, left_start, side_len) || is_in_segment(index, right_start, side_len);
  }

  if (zone_mode == "Top only") {
    return is_in_segment(index, top_start, top_len);
  }

  if (zone_mode == "Bottom only") {
    return is_in_segment(index, bottom_start, bottom_len);
  }

  if (zone_mode == "Selected U") {
    last_u = first_u;
  }

  return is_in_u_range(index, first_u, last_u, left_start, side_len, right_start);
}

inline void set_u_zone(std::string &zone_mode, int &first_u, int &last_u, int requested_first_u, int requested_last_u) {
  first_u = clamp_int(requested_first_u, 1, RACK_UNIT_COUNT);
  last_u = clamp_int(requested_last_u, 1, RACK_UNIT_COUNT);

  if (first_u > last_u) {
    std::swap(first_u, last_u);
  }

  if (first_u == 1 && last_u == RACK_UNIT_COUNT) {
    zone_mode = "Whole rack";
  } else if (first_u == last_u) {
    zone_mode = "Selected U";
  } else {
    zone_mode = "U range";
  }
}

template<size_t N>
inline bool has_active_alerts(const std::array<bool, N> &active, const std::array<int, N> &modes) {
  for (size_t i = 0; i < N; i++) {
    if (active[i] && modes[i] != ALERT_NONE) {
      return true;
    }
  }
  return false;
}

template<size_t N>
inline void set_alert_slot(
  std::array<bool, N> &active,
  std::array<int, N> &first_u,
  std::array<int, N> &last_u,
  std::array<int, N> &modes,
  std::array<uint32_t, N> &starts,
  std::array<float, N> &reds,
  std::array<float, N> &greens,
  std::array<float, N> &blues,
  std::array<float, N> &whites,
  int requested_slot,
  int requested_first_u,
  int requested_last_u,
  int mode,
  float red,
  float green,
  float blue,
  float white
) {
  if (N == 0) {
    return;
  }

  const int slot_index = clamp_int(requested_slot, 0, int(N) - 1);
  first_u[slot_index] = clamp_int(requested_first_u, 1, RACK_UNIT_COUNT);
  last_u[slot_index] = clamp_int(requested_last_u, 1, RACK_UNIT_COUNT);
  if (first_u[slot_index] > last_u[slot_index]) {
    std::swap(first_u[slot_index], last_u[slot_index]);
  }
  modes[slot_index] = mode;
  active[slot_index] = mode != ALERT_NONE;
  starts[slot_index] = millis();
  separate_rgbw_channels(red, green, blue, white);
  reds[slot_index] = red;
  greens[slot_index] = green;
  blues[slot_index] = blue;
  whites[slot_index] = white;
}

template<size_t N>
inline void set_alert_slot_preset(
  std::array<bool, N> &active,
  std::array<int, N> &first_u,
  std::array<int, N> &last_u,
  std::array<int, N> &modes,
  std::array<uint32_t, N> &starts,
  std::array<float, N> &reds,
  std::array<float, N> &greens,
  std::array<float, N> &blues,
  std::array<float, N> &whites,
  int requested_slot,
  int requested_first_u,
  int requested_last_u,
  const std::string &effect
) {
  set_alert_slot(
    active,
    first_u,
    last_u,
    modes,
    starts,
    reds,
    greens,
    blues,
    whites,
    requested_slot,
    requested_first_u,
    requested_last_u,
    alert_mode_from_name(effect, false),
    0.0f,
    0.0f,
    0.0f,
    0.0f
  );
}

template<size_t N>
inline void set_alert_slot_custom(
  std::array<bool, N> &active,
  std::array<int, N> &first_u,
  std::array<int, N> &last_u,
  std::array<int, N> &modes,
  std::array<uint32_t, N> &starts,
  std::array<float, N> &reds,
  std::array<float, N> &greens,
  std::array<float, N> &blues,
  std::array<float, N> &whites,
  int requested_slot,
  int requested_first_u,
  int requested_last_u,
  const std::string &effect,
  float red,
  float green,
  float blue,
  float white
) {
  set_alert_slot(
    active,
    first_u,
    last_u,
    modes,
    starts,
    reds,
    greens,
    blues,
    whites,
    requested_slot,
    requested_first_u,
    requested_last_u,
    alert_mode_from_name(effect, true),
    red,
    green,
    blue,
    white
  );
}

template<size_t N>
inline void clear_alert_slot(
  std::array<bool, N> &active,
  std::array<int, N> &modes,
  int requested_slot
) {
  if (N == 0) {
    return;
  }
  const int slot_index = clamp_int(requested_slot, 0, int(N) - 1);
  active[slot_index] = false;
  modes[slot_index] = ALERT_NONE;
}

template<size_t N>
inline void clear_all_alert_slots(std::array<bool, N> &active, std::array<int, N> &modes) {
  for (size_t i = 0; i < N; i++) {
    active[i] = false;
    modes[i] = ALERT_NONE;
  }
}

inline bool uses_firmware_brightness(const std::string &effect_name) {
  const std::string name = canonical_mode_name(effect_name);
  return name == "White breathing" ||
         name == "Selected color breathing" ||
         name == "Blue breathing" ||
         name == "Orange breathing" ||
         name == "Red breathing" ||
         name == "Internet down" ||
         name == "Error" ||
         name == "Success" ||
         name == "Rack internal" ||
         name == "Red U scan" ||
         name == "Selected color U scan";
}

inline bool alert_mode_is_breathing(int mode) {
  return mode == ALERT_SELECTED_BREATHING ||
         mode == ALERT_UNIFI_BREATHING ||
         mode == ALERT_ORANGE_BREATHING ||
         mode == ALERT_RED_BREATHING ||
         mode == ALERT_WHITE_BREATHING ||
         mode == ALERT_CUSTOM_BREATHING;
}

inline bool alert_mode_is_blink(int mode) {
  return mode == ALERT_RED_BLINK ||
         mode == ALERT_WHITE_BLINK ||
         mode == ALERT_UNIFI_BLINK ||
         mode == ALERT_ORANGE_BLINK ||
         mode == ALERT_SELECTED_BLINK ||
         mode == ALERT_CUSTOM_BLINK;
}

inline float soft_blink_level(uint32_t start_ms, uint32_t cycle_ms, float maximum) {
  if (cycle_ms < 250) {
    cycle_ms = 250;
  }

  const float phase = ((millis() - start_ms) % cycle_ms) / float(cycle_ms);
  float level = 0.0f;
  if (phase < 0.14f) {
    level = smootherstep(phase / 0.14f);
  } else if (phase < 0.54f) {
    level = 1.0f;
  } else if (phase < 0.72f) {
    level = 1.0f - smootherstep((phase - 0.54f) / 0.18f);
  }
  return clamp01(maximum) * level;
}

inline int ping_pong_u(uint32_t step_index, int total_u = RACK_UNIT_COUNT) {
  if (total_u <= 1) {
    return 1;
  }

  const uint32_t period = uint32_t(total_u * 2 - 2);
  const uint32_t position = step_index % period;
  if (position < uint32_t(total_u)) {
    return int(position) + 1;
  }
  return int(period - position) + 1;
}

inline float scan_step_fade(uint32_t elapsed_ms, uint32_t step_ms) {
  if (step_ms < 1) {
    return 1.0f;
  }

  const float phase = (elapsed_ms % step_ms) / float(step_ms);
  if (phase < 0.5f) {
    return smootherstep(phase * 2.0f);
  }
  return 1.0f - smootherstep((phase - 0.5f) * 2.0f);
}

inline esphome::Color rgbw_color(float red, float green, float blue, float white) {
  const RgbwChannels channels = separated_rgbw_unit(red, green, blue, white);
  return esphome::Color(
    scaled_channel(channels.red),
    scaled_channel(channels.green),
    scaled_channel(channels.blue),
    scaled_channel(channels.white)
  );
}

inline uint8_t blend_channel(uint8_t source, uint8_t target, float progress) {
  return uint8_t(roundf(source + (int(target) - int(source)) * progress));
}

inline esphome::Color blend_color(const esphome::Color &source, const esphome::Color &target, float progress) {
  progress = clamp01(progress);
  return esphome::Color(
    blend_channel(source.r, target.r, progress),
    blend_channel(source.g, target.g, progress),
    blend_channel(source.b, target.b, progress),
    blend_channel(source.w, target.w, progress)
  );
}

inline void capture_pixels(esphome::light::AddressableLight &it, std::vector<esphome::Color> &pixels) {
  pixels.clear();
  pixels.reserve(it.size());
  for (int i = 0; i < it.size(); i++) {
    pixels.push_back(it[i].get());
  }
}

inline void render_transition(
  esphome::light::AddressableLight &it,
  const std::vector<esphome::Color> &start,
  const esphome::Color &target,
  float progress
) {
  if (start.size() != size_t(it.size())) {
    for (int i = 0; i < it.size(); i++) {
      it[i] = target;
    }
    return;
  }

  for (int i = 0; i < it.size(); i++) {
    it[i] = blend_color(start[i], target, progress);
  }
}

inline esphome::Color dithered_rgbw_color_unchecked(float red, float green, float blue, float white, int index) {
  return esphome::Color(
    dithered_channel(red, index, 17),
    dithered_channel(green, index, 79),
    dithered_channel(blue, index, 131),
    dithered_channel(white, index, 211)
  );
}

inline esphome::Color dithered_rgbw_color(float red, float green, float blue, float white, int index) {
  const RgbwChannels channels = separated_rgbw_channels(red, green, blue, white);
  return dithered_rgbw_color_unchecked(channels.red, channels.green, channels.blue, channels.white, index);
}

inline esphome::Color alert_slot_color(
  const UAlertSlot &slot,
  int pixel_index,
  const esphome::Color &selected_color,
  float min_brightness,
  float max_brightness,
  uint32_t breathing_cycle,
  int curve_mode,
  uint32_t blink_cycle,
  float fade_ms
) {
  clamp_brightness_range(min_brightness, max_brightness);

  float level = max_brightness;
  if (alert_mode_is_breathing(slot.mode)) {
    level = breathing_level(slot.start_ms, breathing_cycle, min_brightness, max_brightness, curve_mode);
  } else if (alert_mode_is_blink(slot.mode)) {
    level = soft_blink_level(slot.start_ms, blink_cycle, max_brightness);
  }

  if (fade_ms > 0.0f) {
    level *= transition_progress(slot.start_ms, fade_ms);
  }

  float red = 0.0f;
  float green = 0.0f;
  float blue = 0.0f;
  float white = 0.0f;

  switch (slot.mode) {
    case ALERT_SELECTED_STATIC:
    case ALERT_SELECTED_BREATHING:
    case ALERT_SELECTED_BLINK:
      red = selected_color.r * level;
      green = selected_color.g * level;
      blue = selected_color.b * level;
      white = 0.0f;
      break;
    case ALERT_UNIFI_BREATHING:
    case ALERT_UNIFI_BLINK:
      green = level * 111.0f;
      blue = level * 255.0f;
      break;
    case ALERT_ORANGE_BREATHING:
    case ALERT_ORANGE_BLINK:
      red = level * 255.0f;
      green = level * 82.0f;
      break;
    case ALERT_RED_BREATHING:
    case ALERT_RED_BLINK:
      red = level * 255.0f;
      break;
    case ALERT_WHITE_BREATHING:
    case ALERT_WHITE_BLINK:
    case ALERT_WHITE_STATIC:
      white = level * 255.0f;
      break;
    case ALERT_CUSTOM_STATIC:
    case ALERT_CUSTOM_BREATHING:
    case ALERT_CUSTOM_BLINK:
      red = slot.red * level;
      green = slot.green * level;
      blue = slot.blue * level;
      white = slot.white * level;
      break;
    default:
      break;
  }

  return dithered_rgbw_color(red, green, blue, white, pixel_index);
}

template<size_t N>
inline esphome::Color alert_target_for_pixel(
  int pixel_index,
  const std::array<bool, N> &active,
  const std::array<int, N> &first_u,
  const std::array<int, N> &last_u,
  const std::array<int, N> &modes,
  const std::array<uint32_t, N> &starts,
  const std::array<float, N> &reds,
  const std::array<float, N> &greens,
  const std::array<float, N> &blues,
  const std::array<float, N> &whites,
  const esphome::Color &selected_color,
  float min_brightness,
  float max_brightness,
  uint32_t breathing_cycle,
  int curve_mode,
  uint32_t blink_cycle,
  float fade_ms,
  int left_start,
  int side_len,
  int right_start
) {
  esphome::Color target(0, 0, 0, 0);

  for (size_t slot_index = 0; slot_index < N; slot_index++) {
    if (
      active[slot_index] &&
      modes[slot_index] != ALERT_NONE &&
      is_in_u_range(pixel_index, first_u[slot_index], last_u[slot_index], left_start, side_len, right_start)
    ) {
      UAlertSlot slot;
      slot.active = active[slot_index];
      slot.first_u = first_u[slot_index];
      slot.last_u = last_u[slot_index];
      slot.mode = modes[slot_index];
      slot.start_ms = starts[slot_index];
      slot.red = reds[slot_index];
      slot.green = greens[slot_index];
      slot.blue = blues[slot_index];
      slot.white = whites[slot_index];
      target = alert_slot_color(
        slot,
        pixel_index,
        selected_color,
        min_brightness,
        max_brightness,
        breathing_cycle,
        curve_mode,
        blink_cycle,
        fade_ms
      );
    }
  }

  return target;
}

template<size_t N>
inline bool has_alert_for_pixel(
  int pixel_index,
  const std::array<bool, N> &active,
  const std::array<int, N> &first_u,
  const std::array<int, N> &last_u,
  const std::array<int, N> &modes,
  int left_start,
  int side_len,
  int right_start
) {
  for (size_t slot_index = 0; slot_index < N; slot_index++) {
    if (
      active[slot_index] &&
      modes[slot_index] != ALERT_NONE &&
      is_in_u_range(pixel_index, first_u[slot_index], last_u[slot_index], left_start, side_len, right_start)
    ) {
      return true;
    }
  }

  return false;
}

inline bool is_dark(const esphome::Color &color) {
  return color.r == 0 && color.g == 0 && color.b == 0 && color.w == 0;
}

template<size_t N>
inline void render_transition_to_door_open_alerts(
  esphome::light::AddressableLight &it,
  const std::vector<esphome::Color> &start,
  const std::array<bool, N> &active,
  const std::array<int, N> &first_u,
  const std::array<int, N> &last_u,
  const std::array<int, N> &modes,
  const std::array<uint32_t, N> &starts,
  const std::array<float, N> &reds,
  const std::array<float, N> &greens,
  const std::array<float, N> &blues,
  const std::array<float, N> &whites,
  const esphome::Color &selected_color,
  float min_brightness,
  float max_brightness,
  uint32_t breathing_cycle,
  int curve_mode,
  uint32_t blink_cycle,
  float alert_fade_ms,
  const esphome::Color &background,
  float transition,
  int left_start,
  int side_len,
  int right_start
) {
  transition = clamp01(transition);
  for (int i = 0; i < it.size(); i++) {
    esphome::Color target = background;
    if (has_alert_for_pixel(i, active, first_u, last_u, modes, left_start, side_len, right_start)) {
      const esphome::Color alert = alert_target_for_pixel(
        i,
        active,
        first_u,
        last_u,
        modes,
        starts,
        reds,
        greens,
        blues,
        whites,
        selected_color,
        min_brightness,
        max_brightness,
        breathing_cycle,
        curve_mode,
        blink_cycle,
        alert_fade_ms,
        left_start,
        side_len,
        right_start
      );
      target = is_dark(alert) ? background : alert;
    }

    it[i] = start.size() == size_t(it.size()) ? blend_color(start[i], target, transition) : target;
  }
}

template<size_t N>
inline void render_alert_slots(
  esphome::light::AddressableLight &it,
  const std::array<bool, N> &active,
  const std::array<int, N> &first_u,
  const std::array<int, N> &last_u,
  const std::array<int, N> &modes,
  const std::array<uint32_t, N> &starts,
  const std::array<float, N> &reds,
  const std::array<float, N> &greens,
  const std::array<float, N> &blues,
  const std::array<float, N> &whites,
  const esphome::Color &selected_color,
  float min_brightness,
  float max_brightness,
  uint32_t breathing_cycle,
  int curve_mode,
  uint32_t blink_cycle,
  float fade_ms,
  int left_start,
  int side_len,
  int right_start
) {
  for (int i = 0; i < it.size(); i++) {
    it[i] = alert_target_for_pixel(
      i,
      active,
      first_u,
      last_u,
      modes,
      starts,
      reds,
      greens,
      blues,
      whites,
      selected_color,
      min_brightness,
      max_brightness,
      breathing_cycle,
      curve_mode,
      blink_cycle,
      fade_ms,
      left_start,
      side_len,
      right_start
    );
  }
}

template<size_t N>
inline void render_transition_to_alert_slots(
  esphome::light::AddressableLight &it,
  const std::vector<esphome::Color> &start,
  const std::array<bool, N> &active,
  const std::array<int, N> &first_u,
  const std::array<int, N> &last_u,
  const std::array<int, N> &modes,
  const std::array<uint32_t, N> &starts,
  const std::array<float, N> &reds,
  const std::array<float, N> &greens,
  const std::array<float, N> &blues,
  const std::array<float, N> &whites,
  const esphome::Color &selected_color,
  float min_brightness,
  float max_brightness,
  uint32_t breathing_cycle,
  int curve_mode,
  uint32_t blink_cycle,
  float alert_fade_ms,
  float transition,
  int left_start,
  int side_len,
  int right_start
) {
  transition = clamp01(transition);
  for (int i = 0; i < it.size(); i++) {
    const esphome::Color target = alert_target_for_pixel(
      i,
      active,
      first_u,
      last_u,
      modes,
      starts,
      reds,
      greens,
      blues,
      whites,
      selected_color,
      min_brightness,
      max_brightness,
      breathing_cycle,
      curve_mode,
      blink_cycle,
      alert_fade_ms,
      left_start,
      side_len,
      right_start
    );
    it[i] = start.size() == size_t(it.size()) ? blend_color(start[i], target, transition) : target;
  }
}

inline void render_zone_dithered_rgbw(
  esphome::light::AddressableLight &it,
  const std::string &zone_mode,
  int first_u,
  int last_u,
  int bottom_start,
  int bottom_len,
  int left_start,
  int side_len,
  int top_start,
  int top_len,
  int right_start,
  float red,
  float green,
  float blue,
  float white
) {
  const RgbwChannels channels = separated_rgbw_channels(red, green, blue, white);
  for (int i = 0; i < it.size(); i++) {
    if (is_in_zone(i, zone_mode, first_u, last_u, bottom_start, bottom_len, left_start, side_len, top_start, top_len, right_start)) {
      it[i] = dithered_rgbw_color_unchecked(channels.red, channels.green, channels.blue, channels.white, i);
    } else {
      it[i] = esphome::Color(0, 0, 0, 0);
    }
  }
}

inline void render_u_dithered_rgbw(
  esphome::light::AddressableLight &it,
  int u,
  int left_start,
  int side_len,
  int right_start,
  float red,
  float green,
  float blue,
  float white
) {
  const std::string zone_mode = "Selected U";
  render_zone_dithered_rgbw(
    it,
    zone_mode,
    u,
    u,
    0,
    0,
    left_start,
    side_len,
    0,
    0,
    right_start,
    red,
    green,
    blue,
    white
  );
}

inline void set_u_dithered_rgbw(
  esphome::light::AddressableLight &it,
  int u,
  int left_start,
  int side_len,
  int right_start,
  float red,
  float green,
  float blue,
  float white
) {
  const Segment left = rack_u_segment(u, left_start, side_len, false);
  const Segment right = rack_u_segment(u, right_start, side_len, true);
  const RgbwChannels channels = separated_rgbw_channels(red, green, blue, white);

  for (int i = left.start; i < left.start + left.width && i < it.size(); i++) {
    it[i] = dithered_rgbw_color_unchecked(channels.red, channels.green, channels.blue, channels.white, i);
  }
  for (int i = right.start; i < right.start + right.width && i < it.size(); i++) {
    it[i] = dithered_rgbw_color_unchecked(channels.red, channels.green, channels.blue, channels.white, i);
  }
}

inline void render_center_burst_rgbw(
  esphome::light::AddressableLight &it,
  uint32_t elapsed_ms,
  float max_brightness,
  int left_start,
  int side_len,
  int right_start,
  float red,
  float green,
  float blue,
  float white
) {
  const int center_u = (RACK_UNIT_COUNT + 1) / 2;
  const int max_distance = std::max(center_u - 1, RACK_UNIT_COUNT - center_u);
  constexpr uint32_t step_ms = 85;
  constexpr uint32_t fade_in_ms = 220;
  constexpr uint32_t hold_ms = 260;
  constexpr uint32_t fade_out_ms = 650;
  constexpr uint32_t pause_ms = 260;
  const uint32_t expand_ms = uint32_t(max_distance) * step_ms + fade_in_ms;
  const uint32_t fade_out_start_ms = expand_ms + hold_ms;
  const uint32_t cycle_ms = fade_out_start_ms + fade_out_ms + pause_ms;
  const uint32_t t = elapsed_ms % cycle_ms;
  max_brightness = clamp01(max_brightness);

  const RgbwChannels channels = separated_rgbw_channels(red, green, blue, white);
  for (int i = 0; i < it.size(); i++) {
    it[i] = esphome::Color(0, 0, 0, 0);
  }

  for (int u = 1; u <= RACK_UNIT_COUNT; u++) {
    const uint32_t delay_ms = uint32_t(std::abs(u - center_u)) * step_ms;
    float level = 0.0f;
    if (t >= delay_ms && t < delay_ms + fade_in_ms) {
      level = smootherstep((t - delay_ms) / float(fade_in_ms));
    } else if (t >= delay_ms + fade_in_ms && t < fade_out_start_ms) {
      level = 1.0f;
    } else if (t >= fade_out_start_ms && t < fade_out_start_ms + fade_out_ms) {
      level = 1.0f - smootherstep((t - fade_out_start_ms) / float(fade_out_ms));
    }

    if (level > 0.0f) {
      const float output = level * max_brightness;
      set_u_dithered_rgbw(
        it,
        u,
        left_start,
        side_len,
        right_start,
        channels.red * output,
        channels.green * output,
        channels.blue * output,
        channels.white * output
      );
    }
  }
}

inline esphome::Color center_burst_target_for_pixel(
  int pixel_index,
  uint32_t elapsed_ms,
  float max_brightness,
  int left_start,
  int side_len,
  int right_start,
  float red,
  float green,
  float blue,
  float white
) {
  const int center_u = (RACK_UNIT_COUNT + 1) / 2;
  const int max_distance = std::max(center_u - 1, RACK_UNIT_COUNT - center_u);
  constexpr uint32_t step_ms = 85;
  constexpr uint32_t fade_in_ms = 220;
  constexpr uint32_t hold_ms = 260;
  constexpr uint32_t fade_out_ms = 650;
  constexpr uint32_t pause_ms = 260;
  const uint32_t expand_ms = uint32_t(max_distance) * step_ms + fade_in_ms;
  const uint32_t fade_out_start_ms = expand_ms + hold_ms;
  const uint32_t cycle_ms = fade_out_start_ms + fade_out_ms + pause_ms;
  const uint32_t t = elapsed_ms % cycle_ms;
  const RgbwChannels channels = separated_rgbw_channels(red, green, blue, white);
  max_brightness = clamp01(max_brightness);

  for (int u = 1; u <= RACK_UNIT_COUNT; u++) {
    if (!is_in_u_range(pixel_index, u, u, left_start, side_len, right_start)) {
      continue;
    }

    const uint32_t delay_ms = uint32_t(std::abs(u - center_u)) * step_ms;
    float level = 0.0f;
    if (t >= delay_ms && t < delay_ms + fade_in_ms) {
      level = smootherstep((t - delay_ms) / float(fade_in_ms));
    } else if (t >= delay_ms + fade_in_ms && t < fade_out_start_ms) {
      level = 1.0f;
    } else if (t >= fade_out_start_ms && t < fade_out_start_ms + fade_out_ms) {
      level = 1.0f - smootherstep((t - fade_out_start_ms) / float(fade_out_ms));
    }

    const float output = level * max_brightness;
    return dithered_rgbw_color_unchecked(
      channels.red * output,
      channels.green * output,
      channels.blue * output,
      channels.white * output,
      pixel_index
    );
  }

  return esphome::Color(0, 0, 0, 0);
}

inline void render_transition_to_center_burst_rgbw(
  esphome::light::AddressableLight &it,
  const std::vector<esphome::Color> &start,
  uint32_t elapsed_ms,
  float max_brightness,
  int left_start,
  int side_len,
  int right_start,
  float red,
  float green,
  float blue,
  float white,
  float transition
) {
  transition = clamp01(transition);
  for (int i = 0; i < it.size(); i++) {
    const esphome::Color target = center_burst_target_for_pixel(
      i,
      elapsed_ms,
      max_brightness,
      left_start,
      side_len,
      right_start,
      red,
      green,
      blue,
      white
    );
    it[i] = start.size() == size_t(it.size()) ? blend_color(start[i], target, transition) : target;
  }
}

inline void render_transition_to_zone(
  esphome::light::AddressableLight &it,
  const std::vector<esphome::Color> &start,
  const std::string &zone_mode,
  int first_u,
  int last_u,
  int bottom_start,
  int bottom_len,
  int left_start,
  int side_len,
  int top_start,
  int top_len,
  int right_start,
  const esphome::Color &target,
  float progress
) {
  if (start.size() != size_t(it.size())) {
    for (int i = 0; i < it.size(); i++) {
      const bool active = is_in_zone(i, zone_mode, first_u, last_u, bottom_start, bottom_len, left_start, side_len, top_start, top_len, right_start);
      it[i] = active ? target : esphome::Color(0, 0, 0, 0);
    }
    return;
  }

  progress = clamp01(progress);
  for (int i = 0; i < it.size(); i++) {
    const bool active = is_in_zone(i, zone_mode, first_u, last_u, bottom_start, bottom_len, left_start, side_len, top_start, top_len, right_start);
    it[i] = blend_color(start[i], active ? target : esphome::Color(0, 0, 0, 0), progress);
  }
}

inline void render_transition_to_zone_dithered_rgbw(
  esphome::light::AddressableLight &it,
  const std::vector<esphome::Color> &start,
  const std::string &zone_mode,
  int first_u,
  int last_u,
  int bottom_start,
  int bottom_len,
  int left_start,
  int side_len,
  int top_start,
  int top_len,
  int right_start,
  float red,
  float green,
  float blue,
  float white,
  float progress
) {
  progress = clamp01(progress);
  const RgbwChannels channels = separated_rgbw_channels(red, green, blue, white);
  for (int i = 0; i < it.size(); i++) {
    const bool active = is_in_zone(i, zone_mode, first_u, last_u, bottom_start, bottom_len, left_start, side_len, top_start, top_len, right_start);
    const esphome::Color target = active
      ? dithered_rgbw_color_unchecked(channels.red, channels.green, channels.blue, channels.white, i)
      : esphome::Color(0, 0, 0, 0);
    it[i] = start.size() == size_t(it.size()) ? blend_color(start[i], target, progress) : target;
  }
}

inline uint8_t dithered_channel(float value, int index, uint8_t salt) {
  if (value <= 0.0f) {
    return 0;
  }
  if (value >= 255.0f) {
    return 255;
  }

  const float base_float = floorf(value);
  const auto base = uint8_t(base_float);
  const auto fraction = uint8_t((value - base_float) * 255.0f);
  const auto threshold = uint8_t((uint32_t(index) * 73u + uint32_t(index >> 2) * 151u + salt) & 0xFFu);

  if (base < 255 && fraction > threshold) {
    return uint8_t(base + 1);
  }
  return base;
}

inline void set_dithered_rgbw(esphome::light::AddressableLight &it, float red, float green, float blue, float white) {
  const RgbwChannels channels = separated_rgbw_channels(red, green, blue, white);
  for (int i = 0; i < it.size(); i++) {
    it[i] = dithered_rgbw_color_unchecked(channels.red, channels.green, channels.blue, channels.white, i);
  }
}

}  // namespace rack_fx