#include <FastLED.h>                        //FastLed könyvtár verzió 3.2.1

#define NUM_STRIPS 6                        // kis LED szalagok száma
#define NUM_LEDS_PART_A 50                  // LED-ek száma a nagy szalagon
#define NUM_LEDS_PART_B 25                  // LED-ek száma a kis szalagokon
#define NUM_LEDS_PART_C 3                   // LED-ek száma a műszerfalon

CRGB ledsA[NUM_LEDS_PART_A];
CRGB ledsB[NUM_STRIPS][NUM_LEDS_PART_B];
CRGB ledsC[NUM_LEDS_PART_C];

//bemeneti csapok - JAVÍTVA: buttonPinTailLights PIN megváltoztatva A0-ra
const int buttonPinL = 2;                   // balra kanyarodás
const int buttonPinR = 3;                   // jobbra kanyarodás
const int buttonPinEng = 4;                 // motor beindítása
const int buttonPinKnightRider = 5;         // knight rider lámpák
const int buttonPinBrake = 6;               // féklámpák
const int buttonPinTailLights = A0;         // hátsó lámpák - JAVÍTVA: volt 4, most A0
const int buttonPinReverse = 7;             // tolatólámpa

int halfOfLeds = (NUM_LEDS_PART_A/2);
int buttonStateL = 0;
int buttonStateR = 0;
int engineOn = 0;
int maxBrtN = 0;
int KnightRiderState = 0;
int KnightRiderToOff = 0;
int Brake = 0;
int Reverse = 0;
int TailLights = 0;
int leftLeds = 0;
int rightLeds = 0;
int tailLeft = halfOfLeds-1;
int tailLeftSmall = 0;
int tailRight = halfOfLeds;
int tailRightSmall = 0;
int brakeToOffL = 0;
int brakeToOffR = 0;

int stateLT = 0;
int stateRT = 0;
uint8_t gBrtL = 0;
uint8_t gBrtR = 0;
int TailOn = 0;

// Stroboszkóp változók hozzáadva
unsigned long previousStrobeMillis = 0;
bool strobeState = false;                   // strobe aktuális állapota
int strobeCount = 0;                        // strobe ciklus számláló
const int strobeCycles = 3;                 // hány villanás egy ciklusban

unsigned long turnColor = 0xFFFF00;         // index színe
unsigned long dashTurnColor = 0x008000;     // műszerfal index visszajelzés színe
unsigned long dashHazardColor = 0xff6a00;   // műszerfal vészvillogó visszajelzés színe
unsigned long dashDayColor = 0xFFFFFF;      // műszerfal menetfény visszajelzés színe
unsigned long dashKnightRiderColor = 0xFF0000; // műszerfal knight rider visszajelzés színe
unsigned long dashTailColor = 0x0000FF;     // műszerfal hátsó lámpa színe
unsigned long dashBrakeStrobeColor = 0xFFA500; // műszerfal féklámpa strobe színe (narancs)

int showSignalBigStrip = 0;                 // megjeleníti az indexet a hátsó nagy LED szalagon is - 0 = nem | 1 = igen
int showTailBrakeReverseSmalStrip = 1;      // megjeleníti a hátsó menetfényt, a féklámpát és a tolatólámpát a hátsó index LED szalagokon is - 0 = nem | 1 = igen
int maxBrt = 254;                           // maximális fényerő első menetfény - 0-tól 254-ig
int maxBrtNight = 254;                      // maximális fényerő első menetfény, ha a hátsó LED szalag is világít - 0-tól 254-ig
int maxBrtBrake = 254;                      // maximális fényerő féklámpa - 0-tól 254-ig
int maxBrtReverse = 254;                    // maximális fényerő tolatólámpa - 0-tól 254-ig
int maxBrtTailLights = 180;                 // maximális fényerő hátsó LED szalag - 0-tól 254-ig
uint8_t gHue = 0;                           // knight rider effektus színe
int knightRiderRainbow = 0;                 // knight rider szivárvány effektus 0 = nem | 1 = igen
int knightRiderOvrDayL = 1;                 // knight rider felülírja a nappali menetfényt 0 = nem | 1 = igen
int knightRiderSpeed = 20;                  // knight rider effektus sebessége - a nagyobb szám gyorsabb
int knightRiderTail = 5;                    // knight rider effektus farok hossza - a nagyobb szám kisebb farok

// Stroboszkóp beállítások hozzáadva
int brakeStrobeEnabled = 1;                 // féklámpa strobe effekt engedélyezve - 0 = nem | 1 = igen
int brakeStrobeSpeed = 150;                 // strobe sebessége milliszekundumban (alapértelmezett: 150ms)

int delayTurnLedAnim = 20;                  // késleltetés minden egyes LED-nél a kanyarodási lámpa animációban
int delayTurnLedOff = 100;                  // késleltetés az animációtól a kikapcsolásig (kétszer használatos)
int delayLedToDayLight = 5;                 // késleltetés az animációtól a nappali menetfény bekapcsolásáig
int tailDelay = 20;                         // hátsó LED szalagok bekapcsolási idejének hossza miliszekundumban
int nrAnimAfterOff = 5;                     // a beírt szám -1 az indexek ismétlési száma

unsigned long currentMillis = 0; 
unsigned long previousMillis = 0;

int delayForHazard = 500;                   // késleltetés milliszekundumban a vészvillogó kombinációhoz
unsigned long currentMillisSC = 0; 
unsigned long previousMillisSC = 0;

// Függvények elődeklarációja
void btnPressL();
void btnPressR();
void TailAndBrakeAndReverse();
void updateBrakeStrobe(); // Új függvény a strobe kezeléséhez

void setup() { 
  Serial.begin(115200);
  pinMode(buttonPinL, INPUT);
  pinMode(buttonPinR, INPUT);
  pinMode(buttonPinEng, INPUT);
  pinMode(buttonPinKnightRider, INPUT);
  pinMode(buttonPinBrake, INPUT);
  pinMode(buttonPinReverse, INPUT);
  pinMode(buttonPinTailLights, INPUT);     // JAVÍTVA: most már A0 csap
        
  FastLED.addLeds<NEOPIXEL, 13>(ledsA, NUM_LEDS_PART_A);    // nagy LED szalag: hátsó indexlámpák, féklámpa, hátsó lámpák
  FastLED.addLeds<NEOPIXEL, 12>(ledsB[0], NUM_LEDS_PART_B); // LED szalag: hátsó bal oldali indexlámpák
  FastLED.addLeds<NEOPIXEL, 11>(ledsB[1], NUM_LEDS_PART_B); // LED szalag: hátsó jobb oldali indexlámpák
  FastLED.addLeds<NEOPIXEL, 10>(ledsB[2], NUM_LEDS_PART_B); // LED szalag: első bal oldali indexlámpák
  FastLED.addLeds<NEOPIXEL, 9>(ledsB[3], NUM_LEDS_PART_B);  // LED szalag: első jobb oldali indexlámpák
  FastLED.addLeds<NEOPIXEL, 8>(ledsC, NUM_LEDS_PART_C);     // LED szalag: műszerfal
  
  attachInterrupt(digitalPinToInterrupt(buttonPinL), btnPressL, RISING);  // interrupt használata
  attachInterrupt(digitalPinToInterrupt(buttonPinR), btnPressR, RISING);  // interrupt használata

  // Minden LED kikapcsolása indításkor
  fill_solid(ledsA, NUM_LEDS_PART_A, CRGB::Black);
  fill_solid(ledsB[0], NUM_LEDS_PART_B, CRGB::Black);
  fill_solid(ledsB[1], NUM_LEDS_PART_B, CRGB::Black);
  fill_solid(ledsB[2], NUM_LEDS_PART_B, CRGB::Black);
  fill_solid(ledsB[3], NUM_LEDS_PART_B, CRGB::Black);
  fill_solid(ledsC, NUM_LEDS_PART_C, CRGB::Black);
  
  FastLED.show();
}

void loop() {
  buttonStateL = digitalRead(buttonPinL); 
  buttonStateR = digitalRead(buttonPinR);
  engineOn = digitalRead(buttonPinEng);
  KnightRiderState = digitalRead(buttonPinKnightRider);

  currentMillisSC = millis();
  
  if(buttonStateL == HIGH){
    stateLT = 1;
    previousMillisSC = currentMillisSC;
  }else{
    if(currentMillisSC-previousMillisSC >= delayForHazard && stateLT >= nrAnimAfterOff && stateRT == LOW){
      stateLT = 0;  
    }
  }

  if(buttonStateR == HIGH){
    stateRT = 1;
    previousMillisSC = currentMillisSC;
  }else{
    if(currentMillisSC-previousMillisSC >= delayForHazard && stateRT >= nrAnimAfterOff && stateLT == LOW){
      stateRT = 0;  
    }
  }
  
  // Vészvillogó lámpák
  if(stateLT != 0 && stateRT != 0){
    
    leftLeds = NUM_LEDS_PART_B-1;
    rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B;

    for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) {
        if(showSignalBigStrip == 1){
          ledsA[leftLeds] = turnColor;
          ledsA[rightLeds] = turnColor;          
        }
      
        ledsB[0][dot] = turnColor;
        ledsB[1][dot] = turnColor;
        ledsB[2][dot] = turnColor; 
        ledsB[3][dot] = turnColor;

        ledsC[0] = dashHazardColor;
        ledsC[2] = dashHazardColor;
      
        FastLED.show();
        currentMillis = previousMillis = millis();
        while(previousMillis + delayTurnLedAnim >= currentMillis){
          TailAndBrakeAndReverse();
          FastLED.show();
          currentMillis = millis();
        }
        leftLeds--;
        rightLeds++;
    }
    
    currentMillis = previousMillis = millis();
    while(previousMillis + delayTurnLedOff >= currentMillis){
      TailAndBrakeAndReverse();
      FastLED.show();
      currentMillis = millis();
    }

    // JAVÍTVA: Ha engine on, akkor visszaállítjuk a menetfényt, ha engine off, akkor feketét
    if(showSignalBigStrip == 1){
      leftLeds = NUM_LEDS_PART_B-1;
      for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) {
          if(engineOn == HIGH) {
            // Motor be - visszaállítjuk a megfelelő színre
            if(TailLights == HIGH) {
              // Hátsó menetfény bekapcsolva - piros
              ledsA[leftLeds] = CHSV(0, 255, maxBrtTailLights);
            } else {
              // Hátsó menetfény kikapcsolva - fekete
              ledsA[leftLeds] = CRGB::Black;
            }
          } else {
            // Motor ki - fekete
            ledsA[leftLeds] = CRGB::Black;
          }
          leftLeds--;
      }      
      rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B;
      for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) {
          if(engineOn == HIGH) {
            // Motor be - visszaállítjuk a megfelelő színre
            if(TailLights == HIGH) {
              // Hátsó menetfény bekapcsolva - piros
              ledsA[rightLeds] = CHSV(0, 255, maxBrtTailLights);
            } else {
              // Hátsó menetfény kikapcsolva - fekete
              ledsA[rightLeds] = CRGB::Black;
            }
          } else {
            // Motor ki - fekete
            ledsA[rightLeds] = CRGB::Black;
          }
          rightLeds++;
      }
    }
    
    // JAVÍTVA: Elöl is visszaállítjuk a menetfényt ha engine on
    if(engineOn == HIGH) {
      // Motor be - visszaállítjuk a fehér menetfényt
      fill_solid(ledsB[0], NUM_LEDS_PART_B, CHSV(0, 0, gBrtL));
      fill_solid(ledsB[1], NUM_LEDS_PART_B, CHSV(0, 0, gBrtR));
      fill_solid(ledsB[2], NUM_LEDS_PART_B, CHSV(0, 0, gBrtL));
      fill_solid(ledsB[3], NUM_LEDS_PART_B, CHSV(0, 0, gBrtR));
    } else {
      // Motor ki - fekete
      fill_solid(ledsB[0], NUM_LEDS_PART_B, CRGB::Black);
      fill_solid(ledsB[1], NUM_LEDS_PART_B, CRGB::Black);
      fill_solid(ledsB[2], NUM_LEDS_PART_B, CRGB::Black);
      fill_solid(ledsB[3], NUM_LEDS_PART_B, CRGB::Black);
    }
    
    ledsC[0] = CRGB::Black;
    ledsC[2] = CRGB::Black;
    FastLED.show();
    
    currentMillis = previousMillis = millis();
    while(previousMillis + delayTurnLedOff >= currentMillis){
      TailAndBrakeAndReverse();
      FastLED.show();
      currentMillis = millis();
    }

    buttonStateL = digitalRead(buttonPinL); 
    buttonStateR = digitalRead(buttonPinR);
    stateLT++;
    stateRT++;
    
    if(buttonStateL != HIGH && buttonStateR != HIGH && stateLT >= nrAnimAfterOff && stateRT >= nrAnimAfterOff){
      if(buttonStateL == HIGH){
        stateLT = 1;
      }else{
        stateLT = 0;
        gBrtL = 0;
      }
      
      if(buttonStateR == HIGH){
        stateRT = 1;
      }else{
        stateRT = 0;
        gBrtR = 0;
      }
      
      if(buttonStateL != HIGH && buttonStateR != HIGH){
        currentMillis = previousMillis = millis();
        while(previousMillis + delayLedToDayLight >= currentMillis){
          TailAndBrakeAndReverse();
          FastLED.show();
          currentMillis = millis();
        }       
        
        leftLeds = NUM_LEDS_PART_B-1;
        rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B;
        
        if(showSignalBigStrip == 1){
          tailLeft = NUM_LEDS_PART_B;
          tailRight = NUM_LEDS_PART_A-NUM_LEDS_PART_B;
        }else{
          tailLeft = halfOfLeds-1;
          tailRight = halfOfLeds;
        }
      }
    }    

  // Bal oldali kanyarodási lámpák
  }else if(stateLT != 0){
    
    if(KnightRiderState == HIGH){
      fill_solid(ledsB[1], NUM_LEDS_PART_B, CRGB::Black);
      fill_solid(ledsB[3], NUM_LEDS_PART_B, CRGB::Black);
    }
    
    leftLeds = NUM_LEDS_PART_B-1;
    for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) {
        if(showSignalBigStrip == 1){
          ledsA[leftLeds] = turnColor;          
        }

        ledsB[0][dot] = turnColor;
        ledsB[2][dot] = turnColor;
        ledsC[0] = dashTurnColor;
        
        FastLED.show();
        currentMillis = previousMillis = millis();
        while(previousMillis + delayTurnLedAnim >= currentMillis){
          TailAndBrakeAndReverse();
          FastLED.show();
          currentMillis = millis();
        }
        leftLeds--;
    }
    
    currentMillis = previousMillis = millis();
    while(previousMillis + delayTurnLedOff >= currentMillis){
      TailAndBrakeAndReverse();
      FastLED.show();
      currentMillis = millis();
    }

    // JAVÍTVA: Index animáció utáni visszaállítás
    leftLeds = NUM_LEDS_PART_B-1;
    for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) {
        if(showSignalBigStrip == 1){
          if(engineOn == HIGH) {
            // Motor be - visszaállítjuk a megfelelő színre
            if(TailLights == HIGH) {
              // Hátsó menetfény bekapcsolva - piros
              ledsA[leftLeds] = CHSV(0, 255, maxBrtTailLights);
            } else {
              // Hátsó menetfény kikapcsolva - fekete
              ledsA[leftLeds] = CRGB::Black;
            }
          } else {
            // Motor ki - fekete
            ledsA[leftLeds] = CRGB::Black;
          }
        }
        
        // JAVÍTVA: Elöl bal oldal
        if(engineOn == HIGH) {
          // Motor be - visszaállítjuk a fehér menetfényt
          ledsB[0][dot] = CHSV(0, 0, gBrtL);  // Hátsó bal menetfény
          ledsB[2][dot] = CHSV(0, 0, gBrtL);  // Elöl bal menetfény
        } else {
          // Motor ki - fekete
          ledsB[0][dot] = CRGB::Black;
          ledsB[2][dot] = CRGB::Black;
        }
        
        ledsC[0] = CRGB::Black;
        leftLeds--;
    }

    FastLED.show();
    
    currentMillis = previousMillis = millis();
    while(previousMillis + delayTurnLedOff >= currentMillis){
      TailAndBrakeAndReverse();
      FastLED.show();
      currentMillis = millis();
    }

    stateLT++;
    if(stateLT >= nrAnimAfterOff && buttonStateL != HIGH){
      stateLT = 0;
      gBrtL = 0;
      currentMillis = previousMillis = millis();
      while(previousMillis + delayLedToDayLight >= currentMillis){
        TailAndBrakeAndReverse();
        FastLED.show();
        currentMillis = millis();
      }      
      leftLeds = NUM_LEDS_PART_B-1;
      if(showSignalBigStrip == 1){
        tailLeft = NUM_LEDS_PART_B;
        tailRight = NUM_LEDS_PART_A-NUM_LEDS_PART_B;
      }else{
        tailLeft = halfOfLeds-1;
        tailRight = halfOfLeds;
      }
    }

  // Jobb oldali kanyarodási lámpák
  }else if(stateRT != 0){
       
    if(KnightRiderState == HIGH){
        fill_solid(ledsB[0], NUM_LEDS_PART_B, CRGB::Black);
        fill_solid(ledsB[2], NUM_LEDS_PART_B, CRGB::Black);
    }
    
    rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B;
    for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) {
        if(showSignalBigStrip == 1){
          ledsA[rightLeds] = turnColor;          
        }

        ledsB[1][dot] = turnColor;
        ledsB[3][dot] = turnColor;
        ledsC[2] = dashTurnColor;
        
        FastLED.show();
        currentMillis = previousMillis = millis();
        while(previousMillis + delayTurnLedAnim >= currentMillis){
          TailAndBrakeAndReverse();
          FastLED.show();
          currentMillis = millis();
        }
        rightLeds++;
    }
    
    currentMillis = previousMillis = millis();
    while(previousMillis + delayTurnLedOff >= currentMillis){
      TailAndBrakeAndReverse();
      FastLED.show();
      currentMillis = millis();
    }
    
    // JAVÍTVA: Index animáció utáni visszaállítás
    rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B;
    for(int dot = 0; dot < NUM_LEDS_PART_B; dot++) {
        if(showSignalBigStrip == 1){
          if(engineOn == HIGH) {
            // Motor be - visszaállítjuk a megfelelő színre
            if(TailLights == HIGH) {
              // Hátsó menetfény bekapcsolva - piros
              ledsA[rightLeds] = CHSV(0, 255, maxBrtTailLights);
            } else {
              // Hátsó menetfény kikapcsolva - fekete
              ledsA[rightLeds] = CRGB::Black;
            }
          } else {
            // Motor ki - fekete
            ledsA[rightLeds] = CRGB::Black;
          }
        }
        
        // JAVÍTVA: Elöl jobb oldal
        if(engineOn == HIGH) {
          // Motor be - visszaállítjuk a fehér menetfényt
          ledsB[1][dot] = CHSV(0, 0, gBrtR);  // Hátsó jobb menetfény
          ledsB[3][dot] = CHSV(0, 0, gBrtR);  // Elöl jobb menetfény
        } else {
          // Motor ki - fekete
          ledsB[1][dot] = CRGB::Black;
          ledsB[3][dot] = CRGB::Black;
        }
        
        ledsC[2] = CRGB::Black;
        rightLeds++;
    }
    
    FastLED.show();
    currentMillis = previousMillis = millis();
    while(previousMillis + delayTurnLedOff >= currentMillis){
      TailAndBrakeAndReverse();
      FastLED.show();
      currentMillis = millis();
    }

    stateRT++;
    if(stateRT >= nrAnimAfterOff && buttonStateR != HIGH){
      stateRT = 0;
      gBrtR = 0;
      currentMillis = previousMillis = millis();
      while(previousMillis + delayLedToDayLight >= currentMillis){
        TailAndBrakeAndReverse();
        FastLED.show();
        currentMillis = millis();
      }
      rightLeds = NUM_LEDS_PART_A-NUM_LEDS_PART_B;
      if(showSignalBigStrip == 1){
        tailLeft = NUM_LEDS_PART_B;
        tailRight = NUM_LEDS_PART_A-NUM_LEDS_PART_B;
      }else{
        tailLeft = halfOfLeds-1;
        tailRight = halfOfLeds;          
      }
    }

  // Knight rider és nappali menetfények
  }else{
      if(knightRiderOvrDayL == 1 && KnightRiderState == HIGH && engineOn == HIGH){
        engineOn = LOW;
      }
      
      if(TailLights == HIGH && engineOn == HIGH){
        maxBrtN = maxBrtNight;
      }else{
        maxBrtN = maxBrt;
      }

      if(stateLT == 0 && engineOn == HIGH){
        if(gBrtL <= maxBrtN){
          EVERY_N_MILLISECONDS( 1 ) { gBrtL++; }
          fill_solid( ledsB[2], NUM_LEDS_PART_B, CHSV(0,0,gBrtL));
        }else if(gBrtL >= maxBrtN){
          EVERY_N_MILLISECONDS( 1 ) { gBrtL--; }
          fill_solid( ledsB[2], NUM_LEDS_PART_B, CHSV(0,0,gBrtL));
        }
      }else{
        if(gBrtL > 0){
          EVERY_N_MILLISECONDS( 1 ) { gBrtL--; }
          fill_solid( ledsB[2], NUM_LEDS_PART_B, CHSV(0,0,gBrtL));
        }
      }
      
      if(stateRT == 0 && engineOn == HIGH){
        if(gBrtR <= maxBrtN){
          EVERY_N_MILLISECONDS( 1 ) { gBrtR++; }
          fill_solid( ledsB[3], NUM_LEDS_PART_B, CHSV(0,0,gBrtR));
        }else if(gBrtR >= maxBrtN){
          EVERY_N_MILLISECONDS( 1 ) { gBrtR--; }
          fill_solid( ledsB[3], NUM_LEDS_PART_B, CHSV(0,0,gBrtR));
        }
      }else{
        if(gBrtR > 0){
          EVERY_N_MILLISECONDS( 1 ) { gBrtR--; }
          fill_solid( ledsB[3], NUM_LEDS_PART_B, CHSV(0,0,gBrtR));
        }
      }
        
      if(KnightRiderState == HIGH && engineOn == LOW){
        if(knightRiderRainbow == 1){
          EVERY_N_MILLISECONDS( 20 ) { gHue++; }
        }
        fadeToBlackBy( ledsB[0], NUM_LEDS_PART_B, knightRiderTail);
        fadeToBlackBy( ledsB[1], NUM_LEDS_PART_B, knightRiderTail);
        fadeToBlackBy( ledsB[2], NUM_LEDS_PART_B, knightRiderTail);
        fadeToBlackBy( ledsB[3], NUM_LEDS_PART_B, knightRiderTail);
        int pos = beatsin16( knightRiderSpeed, 0, NUM_LEDS_PART_B-1 );
        ledsB[0][pos] += CHSV( gHue, 255, 192);
        ledsB[1][pos] += CHSV( gHue, 255, 192);
        ledsB[2][pos] += CHSV( gHue, 255, 192);
        ledsB[3][pos] += CHSV( gHue, 255, 192);
        KnightRiderToOff = 1;
      }else{
        if(KnightRiderToOff == 1){
          fill_solid(ledsB[0], NUM_LEDS_PART_B, CRGB::Black);
          fill_solid(ledsB[1], NUM_LEDS_PART_B, CRGB::Black);
          fill_solid(ledsB[2], NUM_LEDS_PART_B, CRGB::Black);
          fill_solid(ledsB[3], NUM_LEDS_PART_B, CRGB::Black);
          if(showSignalBigStrip == 1){
            tailLeft = NUM_LEDS_PART_B;
            tailRight = NUM_LEDS_PART_A-NUM_LEDS_PART_B;
          }else{
            tailLeft = halfOfLeds-1;
            tailRight = halfOfLeds;          
          }
          KnightRiderToOff = 0;
        }
      }

    TailAndBrakeAndReverse();
    FastLED.show();
  }
}

// Új függvény: Stroboszkóp effekt kezelése fékezéskor
void updateBrakeStrobe() {
  static unsigned long lastStrobeTime = 0;
  unsigned long currentStrobeTime = millis();
  
  // Csak akkor fusson, ha fékezés van és strobe engedélyezve
  if (Brake == HIGH && brakeStrobeEnabled == 1) {
    if (currentStrobeTime - lastStrobeTime >= brakeStrobeSpeed) {
      strobeState = !strobeState;
      lastStrobeTime = currentStrobeTime;
      
      if (strobeState) {
        strobeCount++;
        if (strobeCount >= strobeCycles * 2) { // *2 mert be-kikapcsolás
          strobeCount = 0;
        }
      }
    }
  } else {
    // Ha nincs fékezés, állítsuk vissza
    strobeState = false;
    strobeCount = 0;
  }
}

// Féklámpák, hátsó lámpák és tolatólámpák kezelése - STROBE EFFEKT HOZZÁADVA
void TailAndBrakeAndReverse(){
  
  Brake = digitalRead(buttonPinBrake);
  TailLights = digitalRead(buttonPinTailLights);
  Reverse = digitalRead(buttonPinReverse);
  
  // Stroboszkóp effekt frissítése
  updateBrakeStrobe();
  
  // Statikus változó a tolatólámpa állapotának nyomon követéséhez
  static bool reverseWasOn = false;
    
  // Tolató lámpa - FEHÉR (csak amíg a gomb nyomva van)
  if(Reverse == HIGH){
    fill_solid(ledsA, NUM_LEDS_PART_A, CRGB::White);
    if(showTailBrakeReverseSmalStrip == 1){
       fill_solid(ledsB[0], NUM_LEDS_PART_B, CRGB::White);
       fill_solid(ledsB[1], NUM_LEDS_PART_B, CRGB::White);
    }
    // Műszerfal visszajelzés
    ledsC[1] = dashTailColor;
    
    // JAVÍTVA: Visszaállítjuk a tail animáció pozícióját, hogy kikapcsolás után újra működjön
    tailLeft = halfOfLeds-1;
    tailRight = halfOfLeds;
    
    reverseWasOn = true;
    return; // Ha tolatólámpa be van kapcsolva, ne jelenjen meg semmi más
  }
  
  // JAVÍTVA: Ha tolatólámpa nincs bekapcsolva, de előzőleg be volt, akkor kikapcsoljuk
  else if(reverseWasOn) {
    fill_solid(ledsA, NUM_LEDS_PART_A, CRGB::Black);
    if(showTailBrakeReverseSmalStrip == 1){
      fill_solid(ledsB[0], NUM_LEDS_PART_B, CRGB::Black);
      fill_solid(ledsB[1], NUM_LEDS_PART_B, CRGB::Black);
    }
    reverseWasOn = false;
  }

  // Féklámpa - AZ EGÉSZ 50 LED-ES SZALAG STROBOSZKÓP
  if(Brake == HIGH){
    // Stroboszkóp effekt alkalmazása AZ EGÉSZ NAGY SZALAGON (ledsA - 50 LED)
    if (brakeStrobeEnabled == 1) {
      if (strobeState) {
        // STROBE BE - AZ EGÉSZ 50 LED VILLOG
        fill_solid(ledsA, NUM_LEDS_PART_A, CHSV(0, 255, maxBrtBrake));
      } else {
        // STROBE KI - AZ EGÉSZ 50 LED KIKAPCSOL
        fill_solid(ledsA, NUM_LEDS_PART_A, CHSV(0, 0, 0));
      }
      
      // KIS SZALAGOK (ledsB) - NORMÁL FÉKLÁMPA (NEM VILLOG)
      if(showTailBrakeReverseSmalStrip == 1){
        fill_solid(ledsB[0], NUM_LEDS_PART_B, CHSV(0, 255, maxBrtBrake));
        fill_solid(ledsB[1], NUM_LEDS_PART_B, CHSV(0, 255, maxBrtBrake));
      }
      
    } 
    // NINCS STROBE - NORMÁL FÉKLÁMPA MINDENHOL
     } else {
      if(stateLT == 0 && stateRT == 0){
        fill_solid(ledsA, NUM_LEDS_PART_A, CHSV(0, 255, maxBrtBrake));
        if(showTailBrakeReverseSmalStrip == 1){
          fill_solid(ledsB[0], NUM_LEDS_PART_B, CHSV(0, 255, maxBrtBrake));
          fill_solid(ledsB[1], NUM_LEDS_PART_B, CHSV(0, 255, maxBrtBrake));   
        }
      }else if(stateLT != 0 && stateRT != 0){
        // Vészvillogó + féklámpa
        if(showSignalBigStrip == 1){
          for(int i = NUM_LEDS_PART_B; i < halfOfLeds; i++){
            ledsA[i] = CHSV(0, 255, maxBrtBrake);
          }      
          for(int i = halfOfLeds; i < NUM_LEDS_PART_A-NUM_LEDS_PART_B; i++){
            ledsA[i] = CHSV(0, 255, maxBrtBrake);
          }          
        } else {
          for(int i = 0; i < halfOfLeds; i++){
            ledsA[i] = CHSV(0, 255, maxBrtBrake);
          }      
          for(int i = halfOfLeds);