#include <Keypad.h>

const uint8_t ROWS = 4;
const uint8_t COLS = 4;
char keys[ROWS][COLS] = {
  { '1', '2', '3', 'A' },
  { '4', '5', '6', 'B' },
  { '7', '8', '9', 'C' },
  { '*', '0', '#', 'D' }
};

uint8_t colPins[COLS] = { 5, 4, 3, 2 }; // Piny połączone do kolumny to C1, C2, C3, C4
uint8_t rowPins[ROWS] = { 9, 8, 7, 6 }; // Piny połączone do wiersza to R1, R2, R3, R4

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

const char semaphore1Code = '1';
const char semaphore2Code = '2';
const char semaphore3Code = '3';
const char semaphore4Code = '4';
//przypisanie kolejnych przyciskow do sygnałow semafora

const char sygnalS1 = '5';
const char sygnalS2 = '6';
const char sygnalS3 = '7';
const char sygnalS4 = '9';
const char sygnalS5 = '8';


int selectedsem = 67; //brak wybranego semafora kod 67
// Piny dla świateł czerwonych, żółtych i zielonych dla każdego semafora
const int redLights[] = {22, 23, 28, 29};
const int yellowLights[] = {24, 25, 30, 31};
const int greenLights[] = {26, 27, 32, 33};



// 5-28/ 6-90/ 7-66/ 8-82/ 9-74/ 0-22/ 100+-25/ 200+-13/ --7/ +-21/ eq=9/ <-68/ >-64/ play-67/ ch--69/ ch-70/ ch+-71

// Aktualny stan świateł dla każdego semafora
int semaphoreStates[] = {0, 0, 0, 0}; // 0 - czerwone, 2 - zielone, 1 - żółte

unsigned long previousMillis[] = {0, 0, 0, 0}; // Poprzedni czas dla każdego semafora
boolean blinkStateGreen[] = {false, false, false, false}; // Stan migania zielone dla każdego semafora
boolean blinkStateYellow[] = {false, false, false, false}; // Stan migania zolte dla każdego semafora
boolean blinkStateRed[] = {false, false, false, false}; // Stan migania czerwone dla każdego semafora

const long interval = 500; // Interwał miganie diod (ms)
// Dodane zmienne dla licznika migania
int blinkCount[] = {0, 0, 0, 0}; // Licznik migania dla każdego semafora
const int maxBlinkCount = 100; // Maksymalna liczba migania


void setup()
{
  Serial.begin(9600); // Inicjalizacja terminala
   for (int i = 0; i < 4; i++) {
    pinMode(redLights[i], OUTPUT);
    pinMode(yellowLights[i], OUTPUT);
    pinMode(greenLights[i], OUTPUT);
    // Włącz początkowo czerwone światła dla każdego semafora
    digitalWrite(redLights[i], HIGH);
  }
}

void loop()
{
  
  char key = keypad.getKey();

  if (key != NO_KEY) {
    // na potrzeby symulatora delay wylaczony
    // delay(700);
    // Sprawdź, który przycisk został naciśnięty na pilocie IR

  Serial.println(key); // Wyświetl otrzymane kody w terminalu
//zmiana kodu na dwa etapy pierwszy to odczyt semafora, drugi to wydanie komendy

  if (selectedsem == 67) {  
    switch (key) {
    case semaphore1Code: // wybrano semafor 1
      Serial.println("Wynbrano sem 1");
     selectedsem = 0;
      break;
    case semaphore2Code: // wybrano semafor 2
      Serial.println("Wybrano sem 2");
      selectedsem = 1;
      break;
    case semaphore3Code: // wybrano semafor 3 
      Serial.println("Wybrano sem 3");
      selectedsem = 2;
      break;
    case semaphore4Code: // wybrano semafor 4
      Serial.println("Wybrano sem 4");
      selectedsem = 3;
      break;
      default:
      Serial.println("wybieraj semafor dalej");
      selectedsem = 67; 
      break;
    }
  } else {
    switch (key) {
      case sygnalS1:
      Serial.println("wybrano sygnal s1");
      changeLights(selectedsem,0);
      selectedsem = 67;
      break;
       case sygnalS2:
      Serial.println("wybrano sygnal s2");
      changeLights(selectedsem,1);
      selectedsem = 67;
      break;
      case sygnalS3:
      Serial.println("wybrano sygnal s3");
      changeLights(selectedsem,2);
      selectedsem = 67;
      break;
      case sygnalS4:
      Serial.println("wybrano sygnal s4");
      changeLights(selectedsem,3);
      selectedsem = 67;
      break;
      case sygnalS5:
      Serial.println("wybrano sygnal s5");
      changeLights(selectedsem,4);
      selectedsem = 67;
      break;
    case semaphore1Code: // wybrano semafor 1
      Serial.println("Wynbrano sem 1");
     selectedsem = 0;
      break;
    case semaphore2Code: // wybrano semafor 2
      Serial.println("Wybrano sem 2");
      selectedsem = 1;
      break;
    case semaphore3Code: // wybrano semafor 3
      Serial.println("Wybrano sem 3");
      selectedsem = 2;
      break;
    case semaphore4Code: // wybrano semafor 4
      Serial.println("Wybrano sem 4");
      selectedsem = 3;
      break;
      default:
      Serial.println("Powrot do wyboru semafora");
      selectedsem = 67; 
      break;   
      }
    
    }


  }

 unsigned long currentMillis = millis();

// Obsługa migania diod dla każdego semafora
  for (int i = 0; i < 4; i++) {
    if (blinkStateGreen[i] && currentMillis - previousMillis[i] >= interval) {
    previousMillis[i] = currentMillis;
    blinkGreenLights(i);
    }
      if (blinkStateYellow[i] && blinkStateRed[i] && currentMillis - previousMillis[i] >= interval) {
    previousMillis[i] = currentMillis;
    blinkYellowLights(i);
    blinkRedLights(i);
    }
    if (blinkStateYellow[i] && currentMillis - previousMillis[i] >= interval) {
    previousMillis[i] = currentMillis;
    blinkYellowLights(i);
    }

  }
}

void changeLights(int semaphore, int semaphoresate)
{

  
  // Wyłącz wszystkie światła dla danego semafora
  digitalWrite(redLights[semaphore], LOW);
  digitalWrite(yellowLights[semaphore], LOW);
  digitalWrite(greenLights[semaphore], LOW);

  // Przełącz stan świateł dla danego semafora
  //semaphoreStates[semaphore] = (semaphoreStates[semaphore] + 1) % 5;

//zamiast linijki u gory ralizuje wybrany stan
  semaphoreStates[semaphore] = semaphoresate;
  
      // Wyłącz migotanie, jeśli stan zmieniono na inny niż migotanie
  if (semaphoreStates[semaphore] != 2) {
    blinkStateGreen[semaphore] = false;
    blinkStateRed[semaphore] = false;
    blinkStateYellow[semaphore] = false;
    blinkCount[semaphore] = 0;
  }

 // if (semaphoreStates[semaphore] != 4) {
 //   blinkStateRed[semaphore] = false;
 //   blinkStateYellow[semaphore] = false;
 //   blinkCount[semaphore] = 0;
 // }

  // Włącz odpowiednie światła dla danego semafora na podstawie stanu
  switch (semaphoreStates[semaphore]) {
    case 0: // Sygnal S1 - tylko czerwone światło
      Serial.println("Realizuje S1");
      digitalWrite(redLights[semaphore], HIGH);
      break;
    case 1: // Sygnal S2 - tylko zielone światło
      Serial.println("Realizuje S2");
      digitalWrite(greenLights[semaphore], HIGH);
      break;
    case 2: // Sygnal S3 - tylko zielone miga
      Serial.println("Realizuje S3");
      blinkStateGreen[semaphore] = true;
      break;
    case 3: //Sygnal S4 nie istnieje dla 3 komorowych wiec gasze cały semafor
      Serial.println("Realizuje S4");
      digitalWrite(greenLights[semaphore], LOW);
      digitalWrite(redLights[semaphore], LOW);
      digitalWrite(yellowLights[semaphore], LOW);
      break;
    case 4: //Sygnal S5 - tylko stale żółte
      Serial.println("Realizuje S5");
      digitalWrite(yellowLights[semaphore], HIGH);
      break;
    default:
      break;
  }
}

void blinkGreenLights(int semaphore)
{
  digitalWrite(greenLights[semaphore], !digitalRead(greenLights[semaphore]));
  blinkCount[semaphore]++;

  if (blinkCount[semaphore] >= maxBlinkCount * 2) {
    digitalWrite(redLights[semaphore], HIGH); // Po 10 cyklach wyłącz migotanie i zrób czerwone
    digitalWrite(greenLights[semaphore], LOW);
    digitalWrite(yellowLights[semaphore], LOW);
    blinkStateGreen[semaphore] = false;
    blinkCount[semaphore] = 0;
  }
}

void blinkYellowLights(int semaphore)
{
  digitalWrite(yellowLights[semaphore], !digitalRead(yellowLights[semaphore]));
  blinkCount[semaphore]++;

  if (blinkCount[semaphore] >= maxBlinkCount * 2) {
    digitalWrite(greenLights[semaphore], HIGH); // Po 10 cyklach wyłącz migotanie i zrób czerwone
    digitalWrite(redLights[semaphore], LOW);
    digitalWrite(yellowLights[semaphore], LOW);
    blinkStateYellow[semaphore] = false;
    blinkCount[semaphore] = 0;
  }
}

void blinkRedLights(int semaphore)
{
  digitalWrite(redLights[semaphore], !digitalRead(redLights[semaphore]));
  blinkCount[semaphore]++;

  if (blinkCount[semaphore] >= maxBlinkCount * 2) {
    digitalWrite(redLights[semaphore], HIGH); // Po 10 cyklach wyłącz migotanie i zrób czerwone
    blinkStateYellow[semaphore] = false;
    blinkCount[semaphore] = 0;
  }
}