// ================= НАСТРОЙКА ПИНОВ =================
// --- Светофор Ч (Тип 1) ---
const int PIN_CH_R = 2;
const int PIN_CH_Y = 3;
const int PIN_CH_G = 4;
const int PIN_BTN_CH = 11;

// --- Светофор Н (Тип 2) ---
const int PIN_N_Y = 5;
const int PIN_BTN_N = 12;

// --- Светофор ПН (Тип 3) ---
const int PIN_PN_W = 6;
const int PIN_PN_G = 7;
const int PIN_BTN_PN = 13;

// --- Светофор В (Тип 4) ---
const int PIN_V_W = 8;
const int PIN_V_Y1 = 9;
const int PIN_V_Y2 = 10;
const int PIN_BTN_V = 14;

// ================= ПЕРЕМЕННЫЕ СОСТОЯНИЯ =================
// Для Ч: 0=Выкл, 1=Красный, 2=Желтый, 3=Зеленый
int stateCH = 0; 

// Для Н: false=Выкл, true=Вкл
bool stateN = false;

// Для ПН: false=Выкл, true=Вкл
bool statePN = false;

// Для В: 0=Выкл, 1=Желтый1, 2=Желтый1+Желтый2, 3=Белый
int stateV = 0;

// Переменные для защиты от дребезга кнопок
bool lastBtnCH = true;
bool lastBtnN = true;
bool lastBtnPN = true;
bool lastBtnV = true;

unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50;

void setup() {
  // Инициализация светодиодов
    pinMode(PIN_CH_R, OUTPUT);
      pinMode(PIN_CH_Y, OUTPUT);
        pinMode(PIN_CH_G, OUTPUT);
          
            pinMode(PIN_N_Y, OUTPUT);
              
                pinMode(PIN_PN_W, OUTPUT);
                  pinMode(PIN_PN_G, OUTPUT);
                    
                      pinMode(PIN_V_W, OUTPUT);
                        pinMode(PIN_V_Y1, OUTPUT);
                          pinMode(PIN_V_Y2, OUTPUT);

                            // Инициализация кнопок (INPUT_PULLUP)
                              pinMode(PIN_BTN_CH, INPUT_PULLUP);
                                pinMode(PIN_BTN_N, INPUT_PULLUP);
                                  pinMode(PIN_BTN_PN, INPUT_PULLUP);
                                    pinMode(PIN_BTN_V, INPUT_PULLUP);

                                      // Выключаем все лампы при старте
                                        clearAll();
                                          
                                            Serial.begin(9600);
                                              Serial.println("Система готова. Нажимайте кнопки.");
                                              }

                                              void loop() {
                                                unsigned long currentMillis = millis();

                                                  // --- ОБРАБОТКА КНОПКИ СВЕТОФОРА Ч ---
                                                    bool readingCH = digitalRead(PIN_BTN_CH) == LOW;
                                                      if (lastBtnCH != readingCH) {
                                                          lastDebounceTime = currentMillis;
                                                            }
                                                              if ((currentMillis - lastDebounceTime) > debounceDelay) {
                                                                  if (readingCH && !lastBtnCH) {
                                                                        handleCH();
                                                                              Serial.println("Нажата кнопка Ч");
                                                                                  }
                                                                                    }
                                                                                      lastBtnCH = readingCH;

                                                                                        // --- ОБРАБОТКА КНОПКИ СВЕТОФОРА Н ---
                                                                                          bool readingN = digitalRead(PIN_BTN_N) == LOW;
                                                                                            if (lastBtnN != readingN) lastDebounceTime = currentMillis;
                                                                                              if ((currentMillis - lastDebounceTime) > debounceDelay) {
                                                                                                  if (readingN && !lastBtnN) {
                                                                                                        handleN();
                                                                                                              Serial.println("Нажата кнопка Н");
                                                                                                                  }
                                                                                                                    }
                                                                                                                      lastBtnN = readingN;

                                                                                                                        // --- ОБРАБОТКА КНОПКИ СВЕТОФОРА ПН ---
                                                                                                                          bool readingPN = digitalRead(PIN_BTN_PN) == LOW;
                                                                                                                            if (lastBtnPN != readingPN) lastDebounceTime = currentMillis;
                                                                                                                              if ((currentMillis - lastDebounceTime) > debounceDelay) {
                                                                                                                                  if (readingPN && !lastBtnPN) {
                                                                                                                                        handlePN();
                                                                                                                                              Serial.println("Нажата кнопка ПН");
                                                                                                                                                  }
                                                                                                                                                    }
                                                                                                                                                      lastBtnPN = readingPN;

                                                                                                                                                        // --- ОБРАБОТКА КНОПКИ СВЕТОФОРА В ---
                                                                                                                                                          bool readingV = digitalRead(PIN_BTN_V) == LOW;
                                                                                                                                                            if (lastBtnV != readingV) lastDebounceTime = currentMillis;
                                                                                                                                                              if ((currentMillis - lastDebounceTime) > debounceDelay) {
                                                                                                                                                                  if (readingV && !lastBtnV) {
                                                                                                                                                                        handleV();
                                                                                                                                                                              Serial.println("Нажата кнопка В");
                                                                                                                                                                                  }
                                                                                                                                                                                    }
                                                                                                                                                                                      lastBtnV = readingV;
                                                                                                                                                                                      }

                                                                                                                                                                                      // ================= ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ =================

                                                                                                                                                                                      void clearAll() {
                                                                                                                                                                                        digitalWrite(PIN_CH_R, LOW); digitalWrite(PIN_CH_Y, LOW); digitalWrite(PIN_CH_G, LOW);
                                                                                                                                                                                          digitalWrite(PIN_N_Y, LOW);
                                                                                                                                                                                            digitalWrite(PIN_PN_W, LOW); digitalWrite(PIN_PN_G, LOW);
                                                                                                                                                                                              digitalWrite(PIN_V_W, LOW); digitalWrite(PIN_V_Y1, LOW); digitalWrite(PIN_V_Y2, LOW);
                                                                                                                                                                                              }

                                                                                                                                                                                              // Логика для "Ч": Циклическое переключение (Выкл -> Красный -> Желтый -> Зеленый -> Выкл)
                                                                                                                                                                                              void handleCH() {
                                                                                                                                                                                                stateCH = (stateCH + 1) % 4;
                                                                                                                                                                                                  clearAll();
                                                                                                                                                                                                    
                                                                                                                                                                                                      if (stateCH == 1) digitalWrite(PIN_CH_R, HIGH);
                                                                                                                                                                                                        else if (stateCH == 2) digitalWrite(PIN_CH_Y, HIGH);
                                                                                                                                                                                                          else if (stateCH == 3) digitalWrite(PIN_CH_G, HIGH);
                                                                                                                                                                                                            
                                                                                                                                                                                                              Serial.print("Режим Ч: ");
                                                                                                                                                                                                                if (stateCH == 0) Serial.println("ВЫКЛ");
                                                                                                                                                                                                                  else if (stateCH == 1) Serial.println("КРАСНЫЙ");
                                                                                                                                                                                                                    else if (stateCH == 2) Serial.println("ЖЕЛТЫЙ");
                                                                                                                                                                                                                      else if (stateCH == 3) Serial.println("ЗЕЛЕНЫЙ");
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                      // Логика для "Н": Просто вкл/выкл
                                                                                                                                                                                                                      void handleN() {
                                                                                                                                                                                                                        stateN = !stateN;
                                                                                                                                                                                                                          digitalWrite(PIN_N_Y, stateN ? HIGH : LOW);
                                                                                                                                                                                                                            Serial.print("Режим Н: ");
                                                                                                                                                                                                                              Serial.println(stateN ? "ВКЛ" : "ВЫКЛ");
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                              // Логика для "ПН": Вкл/Выкл пара (Белый + Зеленый)
                                                                                                                                                                                                                              void handlePN() {
                                                                                                                                                                                                                                statePN = !statePN;
                                                                                                                                                                                                                                  digitalWrite(PIN_PN_W, statePN ? HIGH : LOW);
                                                                                                                                                                                                                                    digitalWrite(PIN_PN_G, statePN ? HIGH : LOW);
                                                                                                                                                                                                                                      Serial.print("Режим ПН: ");
                                                                                                                                                                                                                                        Serial.println(statePN ? "ВКЛ (W+G)" : "ВЫКЛ");
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        // Логика для "В": 
                                                                                                                                                                                                                                        // 1-е нажатие: Желтый 1
                                                                                                                                                                                                                                        // 2-е нажатие: Желтый 1 + Желтый 2
                                                                                                                                                                                                                                        // 3-е нажатие: Белый
                                                                                                                                                                                                                                        // 4-е нажатие: Выкл
                                                                                                                                                                                                                                        void handleV() {
                                                                                                                                                                                                                                          stateV = (stateV + 1) % 4; // 0, 1, 2, 3, 0...
                                                                                                                                                                                                                                            clearAll();
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                if (stateV == 1) {
                                                                                                                                                                                                                                                    // Только Желтый 1
                                                                                                                                                                                                                                                        digitalWrite(PIN_V_Y1, HIGH);
                                                                                                                                                                                                                                                            Serial.println("Режим В: ТОЛЬКО ЖЕЛТЫЙ 1");
                                                                                                                                                                                                                                                              } 
                                                                                                                                                                                                                                                                else if (stateV == 2) {
                                                                                                                                                                                                                                                                    // Оба желтых
                                                                                                                                                                                                                                                                        digitalWrite(PIN_V_Y1, HIGH);
                                                                                                                                                                                                                                                                            digitalWrite(PIN_V_Y2, HIGH);
                                                                                                                                                                                                                                                                                Serial.println("Режим В: ОБА ЖЕЛТЫХ");
                                                                                                                                                                                                                                                                                  } 
                                                                                                                                                                                                                                                                                    else if (stateV == 3) {
                                                                                                                                                                                                                                                                                        // Только Белый
                                                                                                                                                                                                                                                                                            digitalWrite(PIN_V_W, HIGH);
                                                                                                                                                                                                                                                                                                Serial.println("Режим В: ТОЛЬКО БЕЛЫЙ");
                                                                                                                                                                                                                                                                                                  } 
                                                                                                                                                                                                                                                                                                    else {
                                                                                                                                                                                                                                                                                                        // stateV == 0: Выкл
                                                                                                                                                                                                                                                                                                            Serial.println("Режим В: ВЫКЛ");
                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                              }