enum {
  Ok = 0,
  Warning = 1,
  Error = 2,
};

void initialise() {
  ...other initialisation...

  // Ok -> A short green flash every 1 sec
  LedMgr_addPattern(Ok,      "G        ", ...some other details);
  // Warning -> A double yellow flash every 1 sec
  LedMgr_addPattern(Warning, "YY YY    ", ...some other details);
  // Error -> A short red double flash, twice
  LedMgr_addPattern(Error,   "R R    R R        ", ...some other details);

  ...other initialisation...
}

void checkStatus() {
  int errorCount = getErrorCount();
  if (errorCount < 3) {
    LedMgr_activate(Ok); // We good, one for each hand
  } else if (errorCount < 14) {
    LedMgr_activate(Warning); // Getting hard to juggle
  } else {
    LedMgr_activate(Error); // ZOMG!!!
  }
}

// LED Pattern Demo - Part 2
// Building an isolated module "concept"

/**********************************************
 * START of LED Management Module
 **********************************************/

enum {
  // The maximum number of patterns that can be registered (to avoid memory
  // management)
  MAX_PATTERNS = 5,
  // Set prescale to 64
  PRESCALE_VALUE = (1 << CS10) | (1 << CS11),
  // Preload timer value to give 8Hz rollover:
  //  - 64 prescaler -> 16000000 Hz / 64 / 8Hz = 31250
  TIMER_PRELOAD_VALUE = 31250,
};

/**
 * The function signature called by the Led Manager to drive the "led" to a
 * state.
 *
 * @param color The color that the LED should be set to
 * @param arg   The user provided value when the pattern was registered
 */
typedef int (*LedManager_UpdateFunc)(char color, void *arg);

// An internal type to store the pattern information
typedef struct {
  // The external "value" that correspondes to this pattern. Storing this allows
  // the "outside" caller to determine what the values provided to
  // LedMgr_activate() are
  long value;
  // A pointer to a string (hopefully immutable / in flash) that represents this
  // pattern
  char *pattern;
  // The driver function to call to update the LED module
  LedManager_UpdateFunc handler;
  // The argument to be handed back to the driver function
  void *arg;
} pattern_bucket;

// Our internal store of the available patterns
static pattern_bucket patterns[MAX_PATTERNS] = {0};
// The active pattern (NB: Not necessarily set)
static pattern_bucket *current_pattern = NULL;

/*
 * This ISR is responsible for driving the LED change. Possibly a little risky
 * in an ISR, but should be ok for this sketch.
 */
ISR(TIMER1_OVF_vect) // interrupt service routine for overflow
{
  // Reset value to make sure this happens again in 125ms
  TCNT1 = TIMER_PRELOAD_VALUE;

  static int counter = 0;
  if (current_pattern != NULL) {
    int len = strlen(current_pattern->pattern);
    char val = current_pattern->pattern[counter % len];
    current_pattern->handler(val, current_pattern->arg);
  }
  counter++;
}

/*
 * Activate the pattern registered with the provided value.
 *
 * If the value does not match any registered pattern, disable the active
 * pattern
 */
void LedMgr_activate(long value) {
  for (int i = 0; i < MAX_PATTERNS; i++) {
    if (patterns[i].value == value) {
      current_pattern = &patterns[i];
      return;
    }
  }
  current_pattern = NULL; // no patterns match, disable current pattern
}

/*
 * Adds a new pattern
 *
 * @param value   An external value to use as the "key" for activating this
 *                pattern
 * @param pattern The pattern, as a string, in an encoding understood by the
 *                provided UpdateFunc
 * @param handler A function that can respond to each character in the pattern
 *                and drive the "LED" correctly
 * @param arg     An external parameter to pass through to the handler
 *
 * @retval 0  if successful
 * @retval -1 if unable to add the pattern
 */
int LedMgr_addPattern(long value, char const *const pattern,
                      LedManager_UpdateFunc handler, void *arg) {
  for (int i = 0; i < MAX_PATTERNS; i++) {
    pattern_bucket *p = &patterns[i];
    // If the current bucket is empty, use it
    if (p->pattern == NULL) {
      p->value = value;
      p->pattern = pattern;
      p->handler = handler;
      p->arg = arg;
      return 0;
    }
    // If this bucket is already used AND the value is the same, overwrite it
    if (p->value == value) {
      p->pattern = pattern;
      p->handler = handler;
      p->arg = arg;
      return 0;
    }
  }
  // Not enough buckets left
  return -1;
}

/**********************************************
 * END of LED Management Module
 **********************************************/

/**********************************************
 * START of Application
 **********************************************/

enum State {
  FOUR_TO_THE_FLOOR,
  SWUNG_BEAT,
  THREE_FOUR,
};

/**
 * Drive the provided pin to the provided pattern element
 *
 * @param color  the pattern element
 * @param arg    an int representing the pin
 */
int onOffDrive(char color, void *arg) {
  int pin = (int)arg;
  // Notice that we support many chars for "OFF"
  if (color == ' ' || color == '-' || color == '_') {
    digitalWrite(pin, LOW);
  } else {
    digitalWrite(pin, HIGH);
  }
}

void setup() {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);

  // Register the patterns against the states..........along with some details
  //                                               --> see here how the LED_BUILTIN
  //                                                   is supplied so that the LedMgr
  //                                                   can pass it back to the
  //                                                   onOffDrive function
  LedMgr_addPattern(FOUR_TO_THE_FLOOR, "X__",          onOffDrive, LED_BUILTIN);
  LedMgr_addPattern(SWUNG_BEAT,        "XXX   X   X ", onOffDrive, LED_BUILTIN);
  LedMgr_addPattern(THREE_FOUR,        "X---",         onOffDrive, LED_BUILTIN);

  // Setup Timer1 to create an 8Hz ISR trigger (if CPU Freq is 16 MHz)
  noInterrupts(); // disable all interrupts
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1 = TIMER_PRELOAD_VALUE; // preload timer
  TCCR1B |= PRESCALE_VALUE;
  TIMSK1 |= (1 << TOIE1); // enable timer overflow interrupt ISR
  interrupts();           // enable all interrupts
}

void loop() {
  delay(9000); // change every 9 secs

  static long nextBeat = 0;
  switch (nextBeat) {
  case 0:
    LedMgr_activate(FOUR_TO_THE_FLOOR);
    Serial.println("four to the floor");
    nextBeat = 1;
    break;
  case 1:
    LedMgr_activate(SWUNG_BEAT);
    Serial.println("feel the swing");
    nextBeat = 2;
    break;
  default:
    LedMgr_activate(THREE_FOUR);
    Serial.println("3/4 beat");
    nextBeat = 0;
    break;
  }
}