#include <EEPROM.h>
#include <LiquidCrystal.h>
#include <Wire.h>
#include <Keypad.h>
#include <ezButton.h>
#include <Adafruit_NeoPixel.h>

unsigned long now;    // global current m i l l i s ( ) value for all processes

void okDelay(unsigned long theDelay) {    // use this instead of delay() - mostly for setup or short pulses.
  delay(theDelay);
}

enum escreen {  // list of different LCD display screens
  DUMBBITCH = 101, READPRESET, WRITEOUT, RUN, SAVED, PROGRAMMODE, SAVEMODE, SPLASH, NOSCREEN
};

const char *screenTag[] = {
  "DUMBBITCH", "READPRESET", "WRITEOUT", "RUN", "SAVED", "PROGRAMMODE", "SAVEMODE", "SPLASH", "NO_SCREEN"
};

ezButton ezBankButton(A6), ezProgButton(A7), ezSaveButton(A9), ezDownButton(A11);

LiquidCrystal lcd(A5, A4, A3, A2, A1, A0);

// setup of neopixels
# define ELEDS 16
# define EPIN  12
# define PLEDS 16
# define PPIN  13
Adafruit_NeoPixel eLED(ELEDS, EPIN, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pLED(PLEDS, PPIN, NEO_GRB + NEO_KHZ800);

#define rHot LOW
#define rGnd HIGH

void setupRelays();
void switchRelay(int, int);

const byte rows = 1;
const byte cols = 16;

char keys[rows][cols] = {
  { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p' },  // max 16 columns and max 10 rows
};

const int numberOfPedals = 16;  // your total number of effects/pedals
const int bankSize = numberOfPedals * numberOfPedals;   // bank variable to skip ahead by a full bank
const int numberOfBanks = 9;  // up to 14 banks @ 16 pedals; 27 banks @ 12 pedals, 62 banks @ 8 pedals - be sure to adjust LCD displays to accommodate double digit bank readout
const int numberOfEfBks = 2;  // no more than 2 effect banks - for use ONLY when you have HALF the number of footswitches compared with the number of effects
const int numberOfPhotos = 2;  // photoFET variable to mute signal during switching
const int effectVariable = 8;  // effect variable for the effect banks to pull proper keys

byte colPins[cols] = { 4, 5, 6, 7, 8, 9, 10, 11 };   // buttons or momentary switches
byte rowPins[rows] = { 2 };                          // just 1 row is needed

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, rows, cols);

const int OneRelayPin[numberOfPedals] = { 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37 };   // pin 1 on relay - reset/default has pin 1 at 0v - RED LED
const int TenRelayPin[numberOfPedals] = { 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53 };   // pin 10 on relay - reset/default has pin 10 at 5v - BLUE LED
const int progLED = A8;     // shows if we're in program mode - GREEN LED
const int saveLED = A10;    // shows if we're in save mode - YELLOW LED (dull red, turns yellow when combined with program's GREEN LED)
const int photoPin[numberOfPhotos] = { A12, A13 };

byte midiChannel = 0;

int currentBank = 1;  //Starting Preset Bank Number
int effectBank = 1;  //Starting Effect Bank Number
enum estate {READ = 0, WRITE, ERROR, SAVE};
const char *modeTag[] = {"READ", "WRITE", "ERROR", "SAVE"};

byte realMode = READ;
const byte NOKEY = 99;

void midiProg(byte status, int data) {
  Serial.write(status);
  Serial.write(data);
}

// These reset things. Named obvioulsy.
void resetAllRelays() {
  for (int ii = 0; ii < numberOfPedals; ii++) {
    digitalWrite(OneRelayPin[ii], rGnd);
    digitalWrite(TenRelayPin[ii], rGnd);
  }
}
void progLampsOff() {
  for (int ii = 0; ii < numberOfPedals; ii++) {
    setPresetLED(ii, HIGH);
  }
}
void allLampsOff() {
  for (int ii = 0; ii < numberOfPedals; ii++) {
    setPresetLED(ii, HIGH);
    setEffectLED(ii, HIGH);
  }
}

// save your effect/loop selections to a preset
void memory(int theAddr, int theLED) {    // theLED throws a compiler error as unused, but it's technically for the LED functions called (getEffectLED and setPresetLED) below - non-fatal, leave as-is. 
  for (int ii = 0; ii < numberOfPedals; ii++) {
    EEPROM.write((theAddr) + ii, getEffectLED(ii));
    setPresetLED(ii, HIGH);
  }
  for (int ii = 0; ii < numberOfPedals; ii++) {
    setEffectLED(ii, HIGH);
  }
}

// select your effects/loops for saving
void writeOut(int relay) {
  progLampsOff();
  setEffectLED(relay, getEffectLED(relay) ? LOW : HIGH);
}

// default mode - USE THE SWITCH!
void readPreset(int theAddr, int theLED) {
  Serial.print("WTF readPreset ");
  Serial.print(theAddr); Serial.print(" theAddr      ");
  Serial.print(theLED); Serial.print(" theLED ");
  Serial.println("");
  for (int ii = 0; ii < numberOfPhotos; ii++) {
    digitalWrite(photoPin[ii], LOW); //turn ON all photofets
  }
  okDelay(1);
  for (int ii = 0; ii < numberOfPedals; ii++) {
    int kPreset = EEPROM.read((theAddr) + ii);
    switchRelay(ii, kPreset ? HIGH : LOW);
  }
  okDelay(6);
  for (int ii = 0; ii < numberOfPhotos; ii++) {
    digitalWrite(photoPin[ii], HIGH); //turn OFF all photofets
  }
  resetAllRelays();
  for (int ii = 0; ii < numberOfPedals; ii++) {
    int kPreset = EEPROM.read((theAddr) + ii);
    setEffectLED(ii, kPreset);
    setPresetLED(ii, HIGH);
  }
  setPresetLED(theLED, LOW);
}

void loop() {

  now = millis();   // with zero delays, now is now is now for eveyone

  ezBankButton.loop();
  ezProgButton.loop();
  ezSaveButton.loop();
  ezDownButton.loop();

  char key = keypad.getKey();
  if (!key) {
    key = NOKEY;
  } else {
    key -= 'a';
    if (effectBank == 2) {    // effectBank 1 is effects 1 through 8, effectBank 2 is 9 through 16
      key += effectVariable;
    }
  }
  bool doBank = ezBankButton.isPressed();
  bool doProg = ezProgButton.isPressed();
  bool doSave = ezSaveButton.isPressed();
  bool doDown = ezDownButton.isPressed();

  bool anyInput = doBank || doProg || doSave || doDown || key != NOKEY;

  serviceLCD(anyInput);   // manage transient screens. time or user activity moves us along

  thoseOtherLEDs();   // light up the red/green/yellow tell-tale LED accordian to mode

  runAckBlinker();

  if (anyInput) killAckBlinker();

  if (realMode == READ) {     // bank buttons for presets in read mode
    if (doBank) {
      currentBank++;
      if (currentBank > numberOfBanks) currentBank = 1;
      Serial.print("bank became "); Serial.println(currentBank);
      allLampsOff();
      paintLCD(RUN, 0, 102);
    }
    if (doDown) {
      currentBank--;
      if (currentBank < 1) currentBank = numberOfBanks;
      Serial.print("bank became "); Serial.println(currentBank);
      allLampsOff();
      paintLCD(RUN, 0, 102);
    }
  }
  if (realMode == WRITE) {     // bank buttons for effects in write mode
    if (doBank) {
      effectBank = 2;
      Serial.print("bank became "); Serial.println(effectBank);
      paintLCD(WRITEOUT, 0, 103);
    }
    if (doDown) {
      effectBank = 1;
      Serial.print("bank became "); Serial.println(effectBank);
      paintLCD(WRITEOUT, 0, 103);
    }
  }

  switch (realMode) {
    case WRITE:
      if (doProg) {
        realMode = READ;
        allLampsOff();
        paintLCD(RUN, 0, 103);
      }
      if (doSave) {
        realMode = SAVE;
        alreadyStored();
        paintLCD(SAVEMODE);
      }
      if (key != NOKEY) {
        writeOut(key); // relay
        paintLCD(WRITEOUT, key);
        alreadyStored();
      }
      break;

    case SAVE:
      effectBank = 1;
      if (doProg) {
        realMode = READ;
        alreadyStored();
        paintLCD(RUN, 0, 103);
      }
      if (doSave) {
        Serial.println("I am already in save mode waiting for you to pick a slot get off my back");
      }
      if (key != NOKEY) {
        memory(currentBank * bankSize + numberOfPedals * key, key);  // theAddr, theLED
        paintLCD(SAVED, key);
        blinkAnAck(key);
        realMode = READ;
        paintLCD(RUN, 0, 101);
      }
      break;

    case READ:
      if (doProg) {
        realMode = WRITE;
        allLampsOff();
        alreadyStored();
        paintLCD(PROGRAMMODE);
      }
      if (doSave) {
        paintLCD(DUMBBITCH);
        paintLCD(RUN, 0, 104);
      }
      if (key != NOKEY) {
        readPreset(currentBank * bankSize + numberOfPedals * key, key);  // theAddr, relay
        paintLCD(READPRESET, key); 
      }
      break;

    default:
      Serial.print(realMode);
      Serial.println(" error");
  }
}
void thoseOtherLEDs()
{
  switch (realMode) {
    case READ :
      digitalWrite(progLED, LOW);
      digitalWrite(saveLED, LOW);
      break;

    case WRITE :
      digitalWrite(progLED, HIGH);
      digitalWrite(saveLED, LOW);
      break;

    case SAVE :
      digitalWrite(progLED, HIGH);
      digitalWrite(saveLED, HIGH);
      break;

    default :
      Serial.println("error 405.");
  }
}

void spillMode()
{
  Serial.println("spillMode broken just now, write it");
}

void setupRelays() {  // engages relays on and off at start-up
  for (int ii = 0; ii < numberOfPedals; ii++) {
    pinMode(OneRelayPin[ii], OUTPUT);
    pinMode(TenRelayPin[ii], OUTPUT);
    digitalWrite(OneRelayPin[ii], LOW);
    okDelay(20);
    digitalWrite(TenRelayPin[ii], LOW);
    digitalWrite(OneRelayPin[ii], HIGH);
    okDelay(20);
    digitalWrite(TenRelayPin[ii], HIGH);
    okDelay(20);
  }
}

void switchRelay(int relayNumber, int onOff) {   // engages relays on and off in read mode
  if (onOff) {
    digitalWrite(OneRelayPin[relayNumber], rGnd);
    digitalWrite(TenRelayPin[relayNumber], rHot);
  } else {
    digitalWrite(TenRelayPin[relayNumber], rGnd);
    digitalWrite(OneRelayPin[relayNumber], rHot);
  }
}

void alreadyStored() {   // this tells us which preset has something stored in it already during program and save mode
  int theBank = currentBank;
  for (int thePreset = 0; thePreset < numberOfPedals; thePreset++) {
    bool anyEffect = false;
    for (int theEffect = 0; theEffect < numberOfPedals; theEffect++) {
      unsigned char fxON = EEPROM.read(theBank * bankSize + thePreset * numberOfPedals + theEffect);
      if (!fxON) {
        anyEffect = true;
        break;
      }
    }
    if (anyEffect) {
      setPresetLED(thePreset, LOW);
    } else {
    }
  }
}

void setupVLEDs() {   // shows the rainbow and sets the neopixels on startup
  eLED.begin();
  pLED.begin();
  eLED.show();
  pLED.show();
  eLED.setBrightness(200);
  pLED.setBrightness(200);
//  rainbow(0);
}

void rainbow(int wait) {    // the rainbow function. duh. 
  for (long firstPixelHue = 0; firstPixelHue < 5 * 65536; firstPixelHue += 256) {
    for (long ii = 0; ii < eLED.numPixels(); ii++) {
      long pixelHue = firstPixelHue + (ii * 65536L / eLED.numPixels());
      eLED.setPixelColor(ii, eLED.gamma32(eLED.ColorHSV(pixelHue)));
    }
    eLED.show();
    okDelay(wait);
    for (long ii = 0; ii < pLED.numPixels(); ii++) {
      long pixelHue = firstPixelHue + (ii * 65536L / pLED.numPixels());
      pLED.setPixelColor(ii, pLED.gamma32(pLED.ColorHSV(pixelHue)));
    }
    pLED.show();
    okDelay(wait);
  }
}

char kStoreEffectLED[numberOfPedals];

// set colors for neopixels here
const unsigned long neoClear = 0x000000;   // Clear
const unsigned long neoCyan = 0x008080;   // Cyan
const unsigned long neoMagenta = 0x800080;   // Magenta
const unsigned long neoYellow = 0xffff00;   // Yellow
const unsigned long neoGreen = 0x00ff00;   // Green
const unsigned long neoOrange = 0xff9900;   // Orange Sherbert

void setEffectLED(int theLED, int theValue) {    // these are the effect LEDs in read mode
  eLED.setPixelColor(theLED, theValue ? 1 : neoYellow);
  eLED.show();
  kStoreEffectLED[theLED] = theValue;
}

int getEffectLED(int theLED) {   // this allows the neopixels to work in program and save modes
  return kStoreEffectLED[theLED] ? 1 : 0;
}

void setPresetLED(int theLED, int theValue) {    // these are the program LEDs in read mode
  pLED.setPixelColor(theLED, theValue ? 1 : neoGreen);  // kDIM, kGREEN
  pLED.show();
}

// delay-less interruptable blinker
static bool blinkingAnAck = false;
static int blinkCounter;
static int blinkingLED;


const byte blinkPeriod = 75;   // how long each flash stays on
const byte blinkNTimes = 17;   // how many times it blinks - has to be odd to leave the theLED off

void blinkAnAck(int theLED) {
  Serial.print("blink an ack on "); Serial.println(theLED);
  blinkingAnAck = true;
  blinkCounter = blinkNTimes;
  blinkingLED = theLED;
}

void runAckBlinker() {
  if (!blinkingAnAck) return;
  static unsigned long lastBlink;
  unsigned long now = millis();     //use global now when it is available
  if (now - lastBlink > blinkPeriod) {
    Serial.print(blinkCounter);
    Serial.println("   toggle ");
    pLED.setPixelColor(blinkingLED, blinkCounter & 0x1 ? 1 : neoOrange);  // Sherbert
    pLED.show();
    blinkCounter--;
    lastBlink = now;
  }
  if (!blinkCounter) killAckBlinker();
}

void killAckBlinker() {
  if (blinkingAnAck) {
    Serial.println(" the cows are home!");
    eLED.clear();
    blinkingAnAck = false;
  }
}

void beginLCD() {
  lcd.begin(16, 2);

  // custom LCD characters - used only during write/program mode
  byte effChosenLCD[8] = { 0b11111, 0b10101, 0b11111, 0b10101, 0b11111, 0b11111, 0b11011, 0b11111 };
  byte effLeftUsedLCD[8] = { 0b11111, 0b11110, 0b11100, 0b11000, 0b10000, 0b10000, 0b10000, 0b10000 };
  byte effRightUsedLCD[8] = { 0b11111, 0b01111, 0b00111, 0b00011, 0b00001, 0b00001, 0b00001, 0b00001 };
  byte effLeftLCD[8] = { 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000 };
  byte effRightLCD[8] = { 0b00001, 0b00001, 0b00001, 0b00001, 0b00001, 0b00001, 0b00001, 0b00001 };
  lcd.createChar(0, effChosenLCD); 
  lcd.createChar(1, effLeftUsedLCD); 
  lcd.createChar(2, effRightUsedLCD); 
  lcd.createChar(3, effLeftLCD); 
  lcd.createChar(4, effRightLCD);   
}

unsigned long lcdDwellTime;         // timer for transient screen messages
const unsigned long DWELL = 2500;   // holds off a pending escreen for that long - long so we can see it

// get around to displaying this after the transient message blocked it from being
byte pendedScreenName = NOSCREEN;
byte pendedArgument;
byte pendedExtra;

void serviceLCD(bool userInput) {
  if ((lcdDwellTime && now - lcdDwellTime > DWELL) || userInput) {
    Serial.println("dwell expired or user input");
    lcd.clear();
    lcdDwellTime = 0;   // means LCD is free for all
    if (pendedScreenName != NOSCREEN)
      paintLCD(pendedScreenName, pendedArgument, pendedExtra);
    pendedScreenName = NOSCREEN;    // because we out of this world of pain
  }
}

int paintLCD(byte screenName) {   // throws compiler error - non-fatal, can leave as-is
  paintLCD(screenName, 97, 98);
}

int paintLCD(byte screenName, byte argument) {   // throws compiler error - non-fatal, can leave as-is
  paintLCD(screenName, argument, 99);
}

int paintLCD(byte screenName, byte argument, byte extra) {   // throws compiler error - non-fatal, can leave as-is
  Serial.print("                                            painting ");
  Serial.print(screenTag[screenName - DUMBBITCH]);
  Serial.print(" argument "); Serial.print(argument);
  Serial.print("    extra "); Serial.print(extra);
  Serial.println("   ");
  if (lcdDwellTime) {
    Serial.println("stashing the pended screen call for later");
    pendedScreenName = screenName;
    pendedArgument = argument;
    pendedExtra = extra;
    return;
  }

  switch (screenName) {
    case DUMBBITCH:
      lcdDwellTime = now;    // transient message. time or user activity moves to the pended screen
      dumbBitchLCD();
      break;

    case READPRESET:
      readPresetLCD(argument);
      break;

    case WRITEOUT:
      writeOutLCD(argument);
      break;

    case RUN:
      runLCD(extra);
      break;

    case SAVED:
      lcdDwellTime = now;
      savedLCD(argument);
      break;

    case PROGRAMMODE:
      programModeLCD();
      break;

    case SAVEMODE:
      saveModeLCD();
      break;

    case SPLASH:
      lcdDwellTime = now;
      splashLCD();
      break;

    default:
      Serial.print(screenName);
      Serial.println(" error unknown screen name/number");
  }
  return 0;		// normally ignored but available
}

void dumbBitchLCD() {
  lcd.setCursor(0, 0);
  lcd.print("Nope...         ");
  lcd.setCursor(0, 1);
  lcd.print("Dumb Bitch!     ");
}

void readPresetLCD(byte theLED) {
  lcd.setCursor(0, 0);
  lcd.print("             B-");
  lcd.print(currentBank);
  lcd.setCursor(0, 1);
  lcd.print("Preset ");
  lcd.print(theLED + 1);
  lcd.print("        ");
}

void runLCD(byte wtf) {
  Serial.print(wtf); Serial.println(" paint run mode LCD");
  lcd.setCursor(0, 0);
  lcd.print("             B-");
  lcd.print(currentBank);
  lcd.setCursor(0, 1);
  lcd.print("Press Any Preset");
}
/*
void writeOutLCD(byte theRelay) {
  lcd.setCursor(0, 0);
  lcd.print("FX Bank ");
  lcd.print(effectBank);
  lcd.print("    B-");
  lcd.print(currentBank);
  lcd.setCursor(0, 1);
  lcd.print("Pedal: ");
  lcd.print(theRelay + 1);
  lcd.print("       ");
}
*/
void writeOutLCD(byte theRelay) {
  lcd.setCursor(0, 0);
  if (effectBank == 1) {
    lcd.write((byte)1);lcd.print(" FX 1 ");lcd.write((byte)2);lcd.write((byte)3);lcd.print(" FX 2 ");lcd.write((byte)4);
  } else if (effectBank == 2) {
    lcd.write((byte)3);lcd.print(" FX 1 ");lcd.write((byte)4);lcd.write((byte)1);lcd.print(" FX 2 ");lcd.write((byte)2);
  }
  for (int ii = 0; ii < numberOfPedals; ii++) {
    if (getEffectLED(ii) == LOW) {
      lcd.setCursor(ii, 1);lcd.write((byte)0); 
    } else { 
      lcd.setCursor(ii, 1); lcd.print(" ");
    }
  }
}

void savedLCD(byte theLED) {
  lcd.setCursor(0, 0);
  lcd.print("Program saved to");
  lcd.setCursor(0, 1);
  lcd.print("Bank ");
  lcd.print(currentBank);
  lcd.print(" Preset ");
  lcd.print(theLED + 1);
  lcd.print(" ");
}

void programModeLCD() {
  lcd.setCursor(0, 0);
  lcd.print("Program Mode B-");
  lcd.print(currentBank);
  lcd.setCursor(0, 1);
  lcd.print("Select Pedals   ");
}

void saveModeLCD() {
  lcd.setCursor(0, 0);
  lcd.print("Save Mode       ");
  lcd.setCursor(0, 1);
  lcd.print("Select Preset   ");
}

void splashLCD() {
  lcd.setCursor(0, 0);
  lcd.print("You Gorgeous Fat");
  lcd.setCursor(0, 1);
  lcd.print("Sausage Bitch!  ");
}

//   what happens on start up
void setup() {
  Serial.begin(1000000); /* not for midi communication - pin 1 TX */
  Serial.println("first things first.\n");

  beginLCD();
  paintLCD(SPLASH);

  pinMode(progLED, OUTPUT);
  pinMode(saveLED, OUTPUT);
  for (int ii = 0; ii < numberOfPhotos; ii++) {
    pinMode(photoPin[ii], OUTPUT);
    digitalWrite(photoPin[ii], LOW);
  }

  setupVLEDs(); // see if they're working - wow, rainbow!
  setupRelays();  // pins and initial state

  digitalWrite(progLED, LOW);
  digitalWrite(saveLED, LOW);

  okDelay(10);
  digitalWrite(progLED, HIGH);
  digitalWrite(saveLED, HIGH);
  okDelay(10);

  ezBankButton.setDebounceTime(10);
  ezProgButton.setDebounceTime(10);
  ezSaveButton.setDebounceTime(10);
  ezDownButton.setDebounceTime(10);

  for (int ii = 0; ii < numberOfPhotos; ii++) {
    digitalWrite(photoPin[ii], HIGH);
  }

  eLED.clear();
  pLED.clear();
  paintLCD(RUN, 0, 111);
}