#include <Adafruit_NeoPixel.h>
#include <map>
// the pin that the input button is on
#define INPUT_BUTTON_PIN_NEXT 2
// the first pin that the matrix LED strips are on.  Will use the pins sequentially following this one for the matrix
#define FIRST_PIN 22
// the pin that the debug LED strip is on.  The debug LED strip is fixed to 8 LEDs.
#define DEBUG_PIN 13
// the number of strips in the LED matrix
#define NUMSTRIPS 10
// the number of LEDs in each strip
#define NUMPIXELS 64
// how many milliseconds each frame should last.  Could be longer than this if the processor can't keep up with the framerate.
#define MSPERFRAME 10


#define MAX_CONNECTORS_PER_NODE 8

// define the strips
Adafruit_NeoPixel *pixels[NUMSTRIPS];
Adafruit_NeoPixel *debugStrip;
// What mode the display is in, and the default value
volatile uint8_t displayMode = 0;
// the time the last loop finished.  Used for timing the framerate.
int lastLoop;

// common persistant variables
int persistantVar0;

void setup() {

  // initialize the debug strip
  debugStrip = new Adafruit_NeoPixel(8, DEBUG_PIN, NEO_GRB + NEO_KHZ800);
  debugStrip->begin();
  showDebugFill(debugStrip->Color(0, 0, 255));

  // set the input pin to be an input with a pullup resistor
  pinMode(INPUT_BUTTON_PIN_NEXT, INPUT_PULLUP);

  // set the button interrupt
  attachInterrupt(digitalPinToInterrupt(INPUT_BUTTON_PIN_NEXT), incrementMode, FALLING);
  
  // initialize the full display matrix
  for(int i = 0; i < NUMSTRIPS; i++) {
    pixels[i] = new Adafruit_NeoPixel(NUMPIXELS, FIRST_PIN+i, NEO_GRB + NEO_KHZ800);
    pixels[i]->begin();
  }

  // set the time for the start of the first loop
  lastLoop=millis();
}

void loop() {

  // clear the display
  clearFullMatrix();

  displayModeSelector: switch(displayMode) {
    case 0:
      debug_mode_UVMap();
      break;
    case 1:
      debug_mode_DebugDot(0x000000FF);
      break;
    case 2:
      mode_SolidColor(0x0000FFFF);
      break;
    default:
      displayMode = 0;
      // reevaluate to the first case if the display mode was invalid
      goto displayModeSelector;

  }

  // update the strips
  updateFullMatrix();


  // output debug value
  uint32_t debugColor;
  if(millis()-lastLoop > MSPERFRAME) {
    debugColor = debugStrip->Color(255, 0, 0);
  }
  else {
    debugColor = debugStrip->Color(0, 255, 0);
  }
  showDebugValue(displayMode, debugColor);

  // wait for next frame
  while(millis()-lastLoop < MSPERFRAME) {
    //do nothing while waiting for the next frame
  }
  lastLoop = millis();
}


void incrementMode() {
  displayMode++;
}

struct Connector {
  enum class ConnectorType {
    Unknown,
    Value,
    Color,
    PixelMapGrayscale,
    PixelMapColor
  } type = ConnectorType::Unknown;

  void *source;
  void *destination;
};

class Node {
  enum class NodeType {
    Unknown,
    DebugUVMap,
    DebugDot,
    Color,
    SolidColor
  } type = NodeType::Unknown;

  const map

  Connector connectorsIn[MAX_CONNECTORS_PER_NODE];
  Connector connectorsOut[MAX_CONNECTORS_PER_NODE];

  void setupNode(NodeType inType) {
    switch(inType) {
      
    }
  }

  // returns true if successful, false if not
  bool linkConnector(Connector & connectorIn, bool isOutput, int connectorNumber) {
    if(isOutput) {
      connectorsOut[connectorNumber] = connectorIn;
      connectorIn.source = this;
    }
    else {
      connectorsIn[connectorNumber] = connectorIn;
      connectorIn.destination = this;
    }
  }
};

void setPixelAtPosition(int strip, int pixel, uint8_t r, uint8_t g, uint8_t b) {
  pixels[strip]->setPixelColor(pixel, r, g, b);
}

void setPixelAtPosition(int strip, int pixel, uint32_t c) {
  pixels[strip]->setPixelColor(pixel, c);
}

void clearFullMatrix() {
  for(auto strip : pixels) {
    strip->clear();
  }
}

void updateFullMatrix() {
  for(auto strip : pixels) {
    strip->show();
  }
}

void showDebugValue(uint8_t value, uint32_t c)  {
  for(uint8_t i = 0; i < 8; i++) {
    debugStrip->setPixelColor(i, (value >> i & 0b00000001)*c);
  }
  debugStrip->show();
}

void showDebugFill(uint32_t c) {
  debugStrip->fill(c);
  debugStrip->show();
}



// Display a UV map for testing
void debug_mode_UVMap() {
  for(int i = 0; i < NUMSTRIPS; i++) {
    for(int j = 0; j < NUMPIXELS; j++) {
      setPixelAtPosition(i, j, 0, i*255/NUMSTRIPS, j*255/NUMPIXELS);
    }
  }
}

// for debug, displays a single dot on the screen at the current value of persistantVar0
void debug_mode_DebugDot(uint32_t c) {
  setPixelAtPosition(persistantVar0/NUMPIXELS%NUMSTRIPS, persistantVar0%NUMPIXELS, c);
  persistantVar0++;
}

void mode_SolidColor(uint32_t c) {
  for(auto strip : pixels) {
    strip->fill(c);
  }
}