//trying in _2 to add key combination stuff
unsigned long queue[100][4]; //{a,b,time played,double code} keyed is a boolean, signals that it neets turning off
int numInQueue = 0;
int currQueue;
int valid = 0;
int ready = 1;
unsigned long resetTime;
int currKeying;  //indicates that a key is currently down, so another won't be put down.
int incoming;
int incoming2; // note
int incoming3; //velocity
int aDown;
int bDown;
int keyDown;
unsigned long interval, interval2;
unsigned long wait = 50;
unsigned long time;
unsigned long now;
unsigned long lastKeyed;
unsigned long played;
unsigned long prevPlayed;
int ledPin = 13;
int a;
int b;
int b1 = 22;int b2 = 23;int b3 = 24;int b4 = 25;int b5 = 26;int b6 = 27;int b7 = 28;int b8 = 29;
int a1 = 30;int a2 = 31;int a3 = 32;int a4 = 33;int a5 = 34;int a6 = 35;int a7 = 36;int a8 = 37;
int a9 = 38;int a10 = 39;int a11 = 40;int a12 = 41;int a13 = 42;int a14 = 43;int a15 = 44;
int a16 = 45;int a17 = 46;int a18 = 47;
int Shift = 48;
int extra = 49;
int cntrl = 51;
int opt = 50;
int cmd = 53;
int shiftOn;
int cmdOn;
int optOn;
int extraOn;
int cntrlOn;
int unKeyA, unKeyB;
void setup(){
  Serial.begin(9600);
  Serial1.begin(31250);
  Serial.println("shit my ass");
  pinMode(ledPin, OUTPUT);
  pinMode(a1, OUTPUT);pinMode(a2, OUTPUT);pinMode(a3, OUTPUT);pinMode(a4, OUTPUT);pinMode(a5, OUTPUT);
  pinMode(a6, OUTPUT);pinMode(a7, OUTPUT);pinMode(a8, OUTPUT);pinMode(a9, OUTPUT);pinMode(a10, OUTPUT);
  pinMode(a11, OUTPUT);pinMode(a12, OUTPUT);pinMode(a13, OUTPUT);pinMode(a14, OUTPUT);pinMode(a15, OUTPUT);
  pinMode(a16, OUTPUT);pinMode(a17, OUTPUT);pinMode(a18, OUTPUT);pinMode(b1, OUTPUT);pinMode(b2, OUTPUT);
  pinMode(b3, OUTPUT);pinMode(b4, OUTPUT);pinMode(b5, OUTPUT);pinMode(b6, OUTPUT);pinMode(b7, OUTPUT);
  pinMode(b8, OUTPUT);
  pinMode(Shift, OUTPUT);
  pinMode(extra, OUTPUT);
  pinMode(opt, OUTPUT);
  pinMode(cntrl, OUTPUT);
  pinMode(cmd, OUTPUT);
  
}

void loop(){
  //Serial.println(numInQueue);
  now = millis();
   if(Serial1.available() > 2){//////////////checks MIDI and decides if it's interesting
     incoming = Serial1.read();
     if(incoming > 143 && incoming < 150){
     if(Serial1.available() > 0){
     incoming2 = Serial1.read();
     if(Serial1.available() > 0){
     incoming3 = Serial1.read();
     if(incoming3 > 0){
       Serial.print(incoming, HEX); Serial.print(" "); Serial.println(incoming2);
      decode(); /////////////////////////////once a valid note is decoded addToQueue is called
     }}}}}
    

//  THIS PART checks queue[][] for any keys waiting to be keyed and sends them to get keyed
if(numInQueue > 0){
  if(numInQueue > 1){
  interval = queue[1][2] - queue[0][2];
  if(interval < wait){
    doubleDecode();
   Serial.println("activate double key bullshit");
  }
  }
if(ready == 1){
  if(now - queue[0][2] > wait){
key();
}}}


//  THIS PART CHECKS IF ANY NEED TO TURNED OFF
if(currKeying == 1){
unKey();
}


if(ready == 0 && currKeying == 0){ //pauses between keystrokes
  if(round((now - lastKeyed)/2) >  wait){
    ready = 1;
  }
}





prevPlayed = played;
}//void loop



void addToQueue(int a, int b){ //queue //triggered from decode
      played = now;
       numInQueue += 1;
       currQueue = numInQueue - 1;
       queue[currQueue][0] = a;
       queue[currQueue][1] = b;
       queue[currQueue][2] = now;  //time MIDI note recieved
       
//      Serial.println(played - prevPlayed);
}

void queueDoubleCode(int a){  //adds double code to queue in spot [3]
  queue[currQueue][3] = a;
}

void key(){
  if(numInQueue > 0){ 
    
  digitalWrite(queue[0][0],HIGH);
  digitalWrite(queue[0][1],HIGH);

  //delay(100);
  unKeyA = queue[0][0];
  unKeyB = queue[0][1];
  lastKeyed = now;
//  Serial.println("keyed");
  ready = 0;
  currKeying = 1;
            //shift array values
    numInQueue -= 1;
  for(int i = 0; i < numInQueue + 1; i++){
    for(int j = 0; j < 4; j ++){
      queue[i][j] = queue[i + 1][j];
    
  }
  }
  }

} 

void unKey(){   //turns off keys
  if((millis() - lastKeyed) > wait){   //time keyed
  digitalWrite(unKeyA, LOW);
  digitalWrite(unKeyB, LOW);
  unKeyA = 0;
  unKeyB = 0;
  //Serial.print("unkeyed");Serial.print(" "); Serial.println(numInQueue);
  
  currKeying = 0;
  

  if(shiftOn == 1){
    shiftOn = 0;
  digitalWrite(Shift,LOW);
  }
  if(cmdOn == 1){
    cmdOn = 0;
    digitalWrite(cmd, LOW);
  }  
  if(optOn == 1){
  optOn = 0;
  digitalWrite(opt, LOW);
  }
  if(cntrlOn == 1){
  cntrlOn = 0;
  digitalWrite(cntrl, LOW);
  }
    }
}

void decode(){
       if(incoming == 0x95){           //LOW E STRING
      switch(incoming2){
       case 40:                 //space
        addToQueue(a11,b6); break;  
        case 41:                 //1
         addToQueue(a1,b1); break; 
        case 42:                 //2
        addToQueue(a2,b1); break;   
        case 43:                 //3
        addToQueue(a3,b1); break;   
        case 45:                 //a
        addToQueue(a1,b5); break;   
        case 46:                 //b
        addToQueue(a4,b8); break;   
        case 47:                 //c
        addToQueue(a3,b7); break;   
        case 48:                 //d
        addToQueue(a3,b5); break;   
        case 49:                 //return
        addToQueue(a13,b7); break;  
        case 44:                 //shift
        if(shiftOn == 0){
        
        digitalWrite(Shift, HIGH);  
        shiftOn = 1;
        }else{
          digitalWrite(Shift,LOW);
          shiftOn = 0;
        }
        break;
      }
       

   }else{ 
    
       if(incoming == 0x94){           //A STRING
       switch(incoming2){
   case 45:                 //delete
     addToQueue(a13,b4);
      break;
   case 49:                 //command
   digitalWrite(cmd, HIGH);
   cmdOn = 1;  break;
   case 46:                 //4 
     addToQueue(a4,b1); break;
   case 47:                 //5
     addToQueue(a4,b2); break;
   case 48:                 //6
     addToQueue(a5,b2); break;
   case 50:                 //e
     addToQueue(a3,b3); break;
   case 51:                 //f
     addToQueue(a4,b5); break;
   case 52:                 //g
     addToQueue(a4,b6); break;
   case 53:                 //h
     addToQueue(a5,b6); break;
   case 54:                 //?
     digitalWrite(Shift, HIGH);
     shiftOn = 1;
     delay(20);
     digitalWrite(a14, HIGH);
     digitalWrite(b8, HIGH);
     delay(50);
     digitalWrite(a14, LOW);
     digitalWrite(b8, LOW);
     break;
 
   }}else{

       if(incoming == 0x93){           //D STRING
       switch(incoming2){
   case 50:                 //tab.
     addToQueue(a1,b4); break;      
   case 51:                 //7
     addToQueue(a5,b1); break;
   case 52:                 //8
     addToQueue(a6,b1); break;
   case 53:                 //9
     addToQueue(a7,b1); break;
   case 55:                 // i
     addToQueue(a6,b3); break;
   case 56:                 //j
     addToQueue(a5,b5); break;
   case 57:                 //k
     addToQueue(a6,b5); break;
   case 58:                 //l
     addToQueue(a7,b5); break; 
   case 54:                 //option
     optOn = 1;
     digitalWrite(opt, HIGH); break;
   }
   }else{
     
       if(incoming == 0x92){           //G STRING
       switch(incoming2){
    case 57:                 //0
     addToQueue(a14,b1); break; 
    case 60:                 //m
     addToQueue(a5,b7); break;
    case 61:                 //n
     addToQueue(a5,b8); break;
    case 62:                 //o
     addToQueue(a7,b3); break;
    case 63:                 // p
     addToQueue(a14,b3); break;
    case 59:                 //control
     cntrlOn = 1;
     digitalWrite(cntrl, HIGH); break;
   }
   }else{
   
   
   if(incoming == 0x91){           //B STRING
   switch(incoming2){
   case 59:                 //, 
     addToQueue(a6,b7);//
     addToQueue(a11,b6); break;
      case 61:                 //sent from my sparkly gold flying v guitar.

     break;
    case 62:
         addToQueue(100,100); // dummy to advance numInQueue in addToQueue
    queueDoubleCode(1); break;
    case 64:                 //q
     addToQueue(a1,b3); break;
    case 65:                 //r
     addToQueue(a4,b3); break;
    case 66:                 //s
     addToQueue(a2,b5); break;
    case 67:                 // t
     addToQueue(a4,b4); break;
    case 68:                 // th
     addToQueue(a4,b4); 
     addToQueue(a5,b6); break;
    case 69:                 // the
     addToQueue(a4,b4); 
     addToQueue(a5,b6); 
     addToQueue(a3,b3); break;
   case 71:                 //up arrow
     addToQueue(a8,b6); break;
   }
   }else{


   
   if(incoming == 0x90){             //HIGH E STRING
   switch(incoming2){
   case 64:                 //.
     addToQueue(a7,b7); 
     addToQueue(a11,b6); break;
     case 65:                 //yes
     addToQueue(a5,b4); //y 
     addToQueue(a3,b3); //e
     addToQueue(a2,b5); //s
     break;
      case 66:                 //no
     addToQueue(a5,b8); //n
     addToQueue(a7,b3); //o
     break;
     case 67:
     addToQueue(100,100); // dummy to advance numInQueue in addToQueue
     queueDoubleCode(1);
     break;
   case 69:                 //u
    addToQueue(a5,b3); break;
   case 70:                 //v
    addToQueue(a4,b7); break;
   case 71:                 //w
    addToQueue(a2,b3); break; 
   case 72:                 //x
    addToQueue(a2,b7); break;
   case 73:                 //y
    addToQueue(a5,b4); break;
   case 74:                 //z
    addToQueue(a1,b7); break;
   case 75:                 //left arrow
     addToQueue(a8,b8); break;
   case 76:                 //down arrow
     addToQueue(a11,b8); break;
   case 77:                 //right arrow
     addToQueue(a10,b8); break;
   }//switch
 } //high e
 }//else
 }//else
 }//else
 }//else
 }//else 
}

void doubleDecode(){  //checks to see if the double var has a value, and checks to see what to do.

 if(queue[0][3] == 1){
   if(queue[0][3] == 1){
     
          Serial.println("YES");
     addToQueue(a2,b5); //s
     addToQueue(a3,b3); //e
     addToQueue(a5,b8); //n
     addToQueue(a4,b4); //t
     addToQueue(a11,b6); //space
     addToQueue(a4,b5); //f
     addToQueue(a4,b3); //r
     addToQueue(a7,b3); //o
     addToQueue(a5,b7); //m
     addToQueue(a11,b6); //space
     addToQueue(a5,b7); //m
     addToQueue(a5,b4); //y
     addToQueue(a11,b6); //space
     addToQueue(a2,b5); //s
     addToQueue(a14,b3); //p
     addToQueue(a1,b5); //a
     addToQueue(a4,b3); //r
     addToQueue(a6,b5); //k
     addToQueue(a7,b5); //l
     addToQueue(a5,b4); //y
     addToQueue(a11,b6); //space
     addToQueue(a4,b6); //g
     addToQueue(a7,b3); //o
     addToQueue(a7,b5); //l
     addToQueue(a3,b5); //d
     addToQueue(a11,b6); //space
     addToQueue(a4,b5); //f
     addToQueue(a7,b5); //l
     addToQueue(a5,b4); //y
     addToQueue(a6,b3); //i
     addToQueue(a5,b8); //n
     addToQueue(a4,b6); //g
     addToQueue(a11,b6); //space
     addToQueue(a4,b7); //v
     addToQueue(a11,b6); //space
     addToQueue(a4,b6); //g
     addToQueue(a5,b3); //u
     addToQueue(a6,b3); //i
     addToQueue(a4,b4); //t
     addToQueue(a1,b5); //a
     addToQueue(a4,b3); //r
     addToQueue(a7,b7); //.
         
             numInQueue -= 1;
  for(int i = 0; i < numInQueue + 1; i++){
    for(int j = 0; j < 5; j ++){
      queue[i][j] = queue[i + 1][j];
    }
  }
          numInQueue -= 1;
  for(int i = 0; i < numInQueue + 1; i++){
    for(int j = 0; j < 5; j ++){
      queue[i][j] = queue[i + 1][j];
    }
  }}
 }
}