#include <SPI.h>

//#include <MsTimer2.h>

int dataPin = 11;
int clockPin = 13;
int latchPin = 10;
#define latchPort PORTB
byte latchBit = (1<<2);

#define COLS 32
#define ROWS 8

#define NUM_MATRIXES (COLS/8)*(ROWS/8)

#define STEPS 8
const int STEPCOUNT = 255/STEPS;

#define __max_row ROWS-1
#define __max_led COLS-1

//byte current_display[ROWS][COLS][3] = {255,255,255};
byte brightness_red[COLS][ROWS]; 
byte brightness_green[COLS][ROWS];
byte brightness_blue[COLS][ROWS]; 

int redVal;
int greenVal;
int blueVal;

int had_msg = 0;


void setup() {
  redVal = 0;
  greenVal = 0;
  blueVal = 0;

  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV2);
  
  Serial.begin(57600);
  //Serial.buffer((ROWS*COLS) + 2);
  
  //MsTimer2::set(12, display); // 500ms period
  //MsTimer2::start();
}




void loop()
{
  /*color_morph(&redVal,   1); // transition to red
  color_morph(&greenVal, 1); // transition to yellow
  color_morph(&redVal,   0); // transition to green
  color_morph(&blueVal,  1); // transition to aqua
  color_morph(&redVal,   1); // transition to white
  color_morph(&greenVal, 0); // transition to violet
  color_morph(&redVal,   0); // transition to blue
  color_morph(&blueVal,  0); // transition to black (all off)*/
  /*for (int i = 0; i < 8; i++)
    if (Serial.available())
    {
      checkMessages();
      delayMicroseconds(300);
    }*/
  display();
  //display();
}

void serialEvent(){
  checkMessages();
}

void checkMessages(){
  /* Data takes form:
   *
   * +---------+----+----+----+----+----+----+----+----+----+-----+----+----+---------+---------+---------+
   * | 2 (STX) | D1 | D2 | D3 | D4 | D5 | D6 | D7 | D8 | D9 | D10 | C1 | C2 | 13 (CR) | 10 (LF) | 3 (ETX) |
   * +---------+----+----+----+----+----+----+----+----+----+-----+----+----+---------+---------+---------+
   *
  */
  
  char c = Serial.read();               // get the first character
  
  while (c != 2){c = Serial.read();}    // if its not STX, keep going till it is
                                        // (though this is bad!)
  
  
  if (c == 2){                          // now that we have STX
    int val = Serial.read();
    while (val == -1){val = Serial.read();}
    int message = val;
    
    if (message == 0)
    {
      val = Serial.read();
      while (val == -1){val = Serial.read();}
      int row = val;
      //delayMicroseconds(00); // let the message time to arrive
      int col = 0;
      while (true) {                   // loop through all new date till we get ETX
        //byte val = Serial.read();
        //scratch += c; 
        //int row = 0;
        //while (true) {  
          val = Serial.read();
          while (val == -1){val = Serial.read();}
          //if ((val!=0)&&(val<=200)) {
          //  brightness_red[col][row] = map(val, 0, 255, 0, 3000);
          //} else {
            brightness_red[col][row] = val/STEPCOUNT;
          //}
          
          val = Serial.read();
          while (val == -1){val = Serial.read();}
          //if ((val!=0)&&(val<=200)) {
          //  brightness_green[col][row] = map(val, 1, 255, 16, 4000);
          //} else {
            brightness_green[col][row] = val/STEPCOUNT;
          //}
          
          val = Serial.read();
          while (val == -1){val = Serial.read();}
          //if ((val!=0)&&(val<=200)) {
          //  brightness_blue[col][row] = map(val, 0, 255, 0, 3500);
          //} else {
            brightness_blue[col][row] = val/STEPCOUNT;
          //}
          
          //lc.setRow(matrix, row, val);
        //  row++;
        //  if (row>=ROWS) { break; }
        //}
        col++;
        if (col>=COLS) { break; }
      }
      //Serial.print("Got a message for matrix");
      //Serial.println(matrix);
      //prepare();
      //had_msg = 1;
    }
  }
  if (Serial.available() > 0)
    checkMessages();
}

void color_morph(int* value, int get_brighter) {
  for (int c = 0; c < 255; c++)
  {
    if (get_brighter)
      (*value)++;
    else
      (*value)--;

    fill_color();

    for (int count = 0; count < 5; count++) {
      display();
    }
  }
}

void set_led_red(byte row, byte led, byte red) {
  if( (row > __max_row) || (led > __max_led) ) { 
    return; 
  }
  brightness_red[led][row] = red;
}

void set_led_green(byte row, byte led, byte green) {
  if( (row > __max_row) || (led > __max_led) ) { 
    return; 
  }
  brightness_green[led][row] = green;
}

void set_led_blue(byte row, byte led, byte blue) {
  if( (row > __max_row) || (led > __max_led) ) { 
    return; 
  }
  brightness_blue[led][row] = blue;
}

void set_led_rgb(byte row, byte led, byte red, byte green, byte blue) {
  set_led_red(row,led,red);
  set_led_green(row,led,green);
  set_led_blue(row,led,blue);
}

void set_matrix_rgb(byte red, byte green, byte blue) {
  byte ctr1;
  byte ctr2;
  for(ctr2 = 0; ctr2 <= __max_row; ctr2++) {
    for(ctr1 = 0; ctr1 <= __max_led; ctr1++) {
      set_led_rgb(ctr2,ctr1,red,green,blue);
    }
  }
}

void fill_color() {
  set_matrix_rgb(redVal, greenVal, blueVal);
}

void regShift() {
  
}

int i2;
int st;
int r;

#define latchDown() {latchPort &= ~latchBit;}
#define latchUp() {latchPort |= latchBit;}

byte blue_sequence[ROWS][STEPS] = {255};
byte red_sequence[ROWS][STEPS] = {255};
byte green_sequence[ROWS][STEPS] = {255};

void prepare() {
  for (int stnum = 0; stnum < STEPS; stnum++) {
    for (int rownum = 0; rownum < ROWS; rownum++) {
      byte blueVal = 0;
      byte redVal = 0;
      byte greenVal = 0;
      
      for (i2 = 0; i2<8; i2++) {
        if (brightness_blue[i2][rownum] <= stnum)
          blueVal |= (1<<i2);
        if (brightness_green[i2][rownum] <= stnum)
          greenVal |= (1<<i2);
        if (brightness_red[i2][rownum] <= stnum)
          redVal |= (1<<i2);
      }
      blue_sequence[rownum][stnum] = blueVal;
      green_sequence[rownum][stnum] = greenVal;
      red_sequence[rownum][stnum] = redVal;
    }
  }
  had_msg = 0;
}

void display() {
  had_msg = 0;
  int mat=0;
  int offset = 0;
  for (st = 0; st < STEPS; st++) {
    for (r = 0; r<ROWS; r++) {
      
      byte blueVals[NUM_MATRIXES] = {0};
      byte redVals[NUM_MATRIXES] = {0};
      byte greenVals[NUM_MATRIXES] = {0};
      
      
      // Since Red has a different voltage than green and blue, we display it separately
      for (mat=0; mat<NUM_MATRIXES; mat++)
      {
        offset=mat*8;
        for (i2 = 0; i2<8; i2++) {
          if (brightness_red[i2+offset][r] <= st)
            redVals[mat] |= (1<<(7-i2));
        }
      }
      
      latchDown();
      for (mat=NUM_MATRIXES-1; mat>=0; mat--)
      {
        SPI.transfer(255);
        SPI.transfer(redVals[mat]);
        SPI.transfer(255);
        SPI.transfer(1<<(7-r));
      }
      latchUp();
      delayMicroseconds(20);
      
      for (mat=0; mat<NUM_MATRIXES; mat++)
      {
        offset=mat*8;
        for (i2 = 0; i2<8; i2++) {
          if (brightness_blue[i2+offset][r] <= st)
            blueVals[mat] |= (1<<(7-i2));
          if (brightness_green[i2+offset][r] <= st)
            greenVals[mat] |= (1<<i2);
        }
      }
      
      latchDown();
      for (mat=NUM_MATRIXES-1; mat>=0; mat--)
      {
        SPI.transfer(blueVals[mat]);
        SPI.transfer(255);
        SPI.transfer(greenVals[mat]);
        SPI.transfer(1<<(7-r));
      }
      latchUp();
      delayMicroseconds(40);
    }
  }
}