byte l1R = 3;
byte l1G = 5;
byte l1B = 6;
byte l2R = 9;
byte l2G = 10;
byte l2B = 11;

byte red = 0;
byte green = 0;
byte blue = 0;

byte rndCol = 0;
int intDalay = 1000;
byte refNum = 0;

/* RGB színek a program memóriában.
   RGB colors in program memory.
   0 --> fehér (white),
   1 --> vörös (red),
   2 --> zöld (green),
   3 --> kék (blue)
   4 --> sárga (yellow),
   5 --> világoskék (cyan),
   6 --> bíbor (magenta),
   7 --> narancssárga (orage),
   8 --> fekete (black), LED off.
*/

const PROGMEM byte setRed[] = {
  0xFF, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00
};
const PROGMEM byte setGreen[] = {
  0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0x7F, 0x00
};
const PROGMEM byte setBlue[] = {
  0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0x00
};

void setup() {

  Serial.begin(115200);

  // 1. Szín
  pinMode(l1R, OUTPUT);
  pinMode(l1G, OUTPUT);
  pinMode(l1B, OUTPUT);
  // 2. Szín
  pinMode(l2R, OUTPUT);
  pinMode(l2G, OUTPUT);
  pinMode(l2B, OUTPUT);


  // Közös katódok vezérlése, pld. Futófény
  pinMode(2, OUTPUT); // 1
  pinMode(4, OUTPUT); // 2
  pinMode(7, OUTPUT); // 3
  pinMode(8, OUTPUT); // 4
  pinMode(12, OUTPUT); // 5
  pinMode(13, OUTPUT); // 6

  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
  pinMode(A3, INPUT);
  pinMode(A4, INPUT);
  pinMode(A5, INPUT);
  // Serial.println(pow(2, 3));

  /*
    byte c;
    rndCol = 1;
    for (c = 0; c <= 5; c++) {
      //
      aktiveNum (rndCol);
      if (digitalRead(A0) == LOW) {
        refNum = rndCol * 2 - 1;
      }
      rndCol = rndCol * 2;
      delay(2000);
    }
  */

  led1Color(0, 0, 0, 0);
  led2Color(0, 0, 0, 0);

  aktiveNum (63);
  delay(2000);


  bool cfgNum;
  rndCol = 1;
  aktiveNum (rndCol);
  delay(2000);
  refNum = 0;
  if (digitalRead(A0) == HIGH) {
    refNum = 2;
  }
  rndCol = rndCol * 2;
  aktiveNum (rndCol);
  delay(2000);
  if (digitalRead(A1) == HIGH)  {
    refNum = 4;
  }
  rndCol = rndCol * 2;
  aktiveNum (rndCol);
  delay(2000);
  if (digitalRead(A2) == HIGH) {
    refNum = 8;
  }
  rndCol = rndCol * 2;
  aktiveNum (rndCol);
  delay(2000);
  if (digitalRead(A3) == HIGH)  {
    refNum = 16;
  }
  rndCol = rndCol * 2;
  aktiveNum (rndCol);
  delay(2000);
  if (digitalRead(A4) == HIGH) {
    refNum = 32;
  }
  rndCol = rndCol * 2;
  aktiveNum (rndCol);
  delay(2000);
  if (digitalRead(A5) == HIGH) {
    refNum = 64;
  }
  rndCol = rndCol * 2;
  aktiveNum (rndCol);
  delay(2000);

  if (refNum == 0) {
    led1Color(255, 0, 0, 100);
    led2Color(255, 0, 0, 100);
led_error:
    aktiveNum (63);
    delay(333);
    aktiveNum (0);
    delay(333);
    goto led_error;
  } else {
    refNum = refNum - 1;;
  }
  Serial.println("----------");
  Serial.println(refNum);
  Serial.println("----------");

  aktiveNum (refNum);



  led1Color(255, 0, 0, 100);
  led2Color(255, 0, 0, 100);
  delay(intDalay);
  led1Color(0, 255, 0, 100);
  led2Color(0, 255, 0, 100);
  delay(intDalay);
  led1Color(0, 0, 255, 100);
  led2Color(0, 0, 255, 100);
  delay(intDalay);
  led1Color(0, 0, 0, 0);
  led2Color(0, 0, 0, 0);
  delay(intDalay);

}

// Színteszt
void  loop() {
  int c = 0;

  /*
    // Teszt rutin
    for (c = 0; c <= 7; c++) {
    red = pgm_read_byte_near(setRed + c);
    green = pgm_read_byte_near(setGreen + c);
    blue = pgm_read_byte_near(setBlue + c);

    led1Color(red, green, blue);
    led2Color(255 - red, 255 - green, 255 - blue);

    delay(intDalay / 3);
    aktiveNum (random(1, 6));
    delay(intDalay / 3);
    aktiveNum (5);
    }
  */

  /*
    // Véletlenszerű színek.
    c = (random(0, 9));
    red = pgm_read_byte_near(setRed + c);
    green = pgm_read_byte_near(setGreen + c);
    blue = pgm_read_byte_near(setBlue + c);
    led1Color(red, green, blue, 100);

    c = (random(0, 9));
    red = pgm_read_byte_near(setRed + c);
    green = pgm_read_byte_near(setGreen + c);
    blue = pgm_read_byte_near(setBlue + c);
    led2Color(red, green, blue, 100);

    delay(intDalay / 1);
    aktiveNum (random(0, 64));
    delay(intDalay / 1);
    aktiveNum (63);
  */

  // 1 véletlen szín moduláció fel-le az összes kimentre.
  aktiveNum (refNum);
ismet:
  c = random(0, 8);
  red = pgm_read_byte_near(setRed + c);
  green = pgm_read_byte_near(setGreen + c);
  blue = pgm_read_byte_near(setBlue + c);

  led1Color(red, green, blue, 100);

  c = 0;
  for (c = 1; c <= 100; c++) {
    //   led1Color(red, green, blue, 100);
    led2Color(red, green, blue, c);
    delay(intDalay / 1);
  }

  for (c = 100; c >= 1; c--) {
    //  led1Color(red, green, blue, 100);
    led2Color(red, green, blue, c);
    delay(intDalay / 1);
  }

  delay(intDalay);
  goto ismet;

}



/*
  void  loop() {

  // random(0, 256)
  // led1Color(random(0, 256), random(0, 256),random(0, 256));
  // led2Color(random(0, 256), random(0, 256), random(0, 256));
  // delay(1000);
  // led1Color(random(0, 256), random(0, 256), random(0, 256));

  // pgm_read_byte_near(numset + xkar)

  /*
    rndCol = random(0, 7);
    red = pgm_read_byte_near(setRed + rndCol);
    green = pgm_read_byte_near(setGreen + rndCol);
    blue = pgm_read_byte_near(setBlue + rndCol);


  // led2Color(red, green, blue);

  // delay(intDalay);

  byte c = 0;

  for (c = 0; c <= 8; c++) {
    red = pgm_read_byte_near(setRed + c);
    green = pgm_read_byte_near(setGreen + c);
    blue = pgm_read_byte_near(setBlue + c);

    led2Color(red, green, blue);
    delay(intDalay);
  }
  led1Color(0, 0, 0);
  led2Color(0, 0, 0);

  red = 0;
  green = 0;
  blue = 0;

  /*
    for (c = 0; c <= 255; c++) {
      green = c;
      red = 255 - c;
      led2Color(red, green, blue);
      delay(intDalay / 50);
    }
    for (c = 0; c <= 255; c++) {
      green = 255 - c;
      red = c;
      led2Color(red, green, blue);
      delay(intDalay / 50);
    }
*/

/*
  led1Color(255, 0, 0); // Red Color
  led2Color(255, 255, 255); // Wihte
  delay(1000);
  led1Color(0,  255, 0); // Green Color
  led2Color(255, 0, 0); // Red
  delay(1000);
  led1Color(0, 0, 255); // Blue Color
  led2Color(0, 255, 0); // Green
  delay(1000);
  led1Color(255, 255, 255); // White Color
  led2Color(0, 0, 255); // Blue
  delay(1000);
  led1Color(170, 0, 255); // Purple Color
  led2Color(255, 255, 0); // Yellow
  delay(1000);
  led1Color(127, 127,  127); // Light Blue
  led2Color(255, 0, 255); // Magenta
  delay(1000);
   led2Color(0, 255, 255); // Cyan
  delay(1000);

  }
*/

void led1Color(byte redValue, byte greenValue,  byte blueValue, byte brightnessPercent) {
  // 1. RGB LED színbeállítás. brightness
  // Közös katódos RGB LED!
  float percent;
  if ((brightnessPercent > 0) && (brightnessPercent < 101)) {
    percent = 100 / brightnessPercent;
    analogWrite(l1R, (255 - redValue) * percent);
    analogWrite(l1G, (255 - greenValue) *percent);
    analogWrite(l1B, (255 - blueValue) * percent);
  } else {
    // LED Off
    analogWrite(l1R, 255);
    analogWrite(l1G, 255);
    analogWrite(l1B, 255);
  }
}

void led2Color(byte redValue, byte greenValue,  byte blueValue, byte brightnessPercent) {
  // 2. RGB LED színbeállítás.
  // Közös katódos RGB LED!
  float percent;
  if ((brightnessPercent > 0) && (brightnessPercent < 101)) {
    percent = 100 / brightnessPercent;
    analogWrite(l2R, (255 - redValue) * percent);
    analogWrite(l2G, (255 - greenValue) * percent);
    analogWrite(l2B, (255 - blueValue) * percent);
  } else {
    // LED Off
    analogWrite(l2R, 255);
    analogWrite(l2G, 255);
    analogWrite(l2B, 255);
  }
}

void aktiveNum (byte aktNum) {
  // 0-63
  // 13,12.8,7,4,2
  digitalWrite(2, bitRead(aktNum, 0));
  digitalWrite(4, bitRead(aktNum, 1));
  digitalWrite(7, bitRead(aktNum, 2));
  digitalWrite(8, bitRead(aktNum, 3));
  digitalWrite(12, bitRead(aktNum, 4));
  digitalWrite(13, bitRead(aktNum, 5));
}