#include <FastLED.h>

// Konstansok
#define NUM_STRIPS 4
#define NUM_LEDS_PART_A 50
#define NUM_LEDS_PART_B 10
#define NUM_LEDS_PART_C 3

// Pin definíciók
const int PIN_BUTTON_LEFT = 2;
const int PIN_BUTTON_RIGHT = 3;
const int PIN_BUTTON_ENGINE = 4;
const int PIN_BUTTON_KNIGHT_RIDER = 5;
const int PIN_BUTTON_BRAKE = 6;
const int PIN_BUTTON_TAIL_LIGHTS = 7;

// LED szalagok
CRGB ledsA[NUM_LEDS_PART_A];
CRGB ledsB[NUM_STRIPS][NUM_LEDS_PART_B];
CRGB ledsC[NUM_LEDS_PART_C];

// Színek
const CRGB COLOR_TURN = CRGB(0xff, 0x6a, 0x00);
const CRGB COLOR_DASH_TURN = CRGB(0x00, 0x80, 0x00);
const CRGB COLOR_DASH_HAZARD = CRGB(0xff, 0x6a, 0x00);
const CRGB COLOR_DASH_DAY = CRGB(0xFF, 0xFF, 0xFF);
const CRGB COLOR_DASH_KNIGHT_RIDER = CRGB(0xFF, 0x00, 0x00);
const CRGB COLOR_DASH_TAIL = CRGB(0x00, 0x00, 0xFF);

// Beállítások
const bool SHOW_SIGNAL_BIG_STRIP = true;
const bool SHOW_TAIL_BRAKE_SMALL_STRIP = true;
const uint8_t MAX_BRIGHTNESS_DAY = 254;
const uint8_t MAX_BRIGHTNESS_NIGHT = 100;
const uint8_t MAX_BRIGHTNESS_BRAKE = 254;
const uint8_t MAX_BRIGHTNESS_TAIL = 70;
const bool KNIGHT_RIDER_RAINBOW = false;
const bool KNIGHT_RIDER_OVERRIDE_DAY = true;
const uint8_t KNIGHT_RIDER_SPEED = 45;
const uint8_t KNIGHT_RIDER_TAIL = 12;

// Állapot változók
bool stateLeft = false;
bool stateRight = false;
bool engineOn = false;
bool knightRiderActive = false;
bool brakeActive = false;
bool tailLightsActive = false;

// Időzítés változók
unsigned long lastUpdateTime = 0;
const unsigned long UPDATE_INTERVAL = 10; // ms

void setup() {
  Serial.begin(115200);
  
  // Gombok beállítása
  pinMode(PIN_BUTTON_LEFT, INPUT);
  pinMode(PIN_BUTTON_RIGHT, INPUT);
  pinMode(PIN_BUTTON_ENGINE, INPUT);
  pinMode(PIN_BUTTON_KNIGHT_RIDER, INPUT);
  pinMode(PIN_BUTTON_BRAKE, INPUT);
  pinMode(PIN_BUTTON_TAIL_LIGHTS, INPUT);

  // LED szalagok beállítása
  FastLED.addLeds<NEOPIXEL, 13>(ledsA, NUM_LEDS_PART_A);
  for (int i = 0; i < NUM_STRIPS; i++) {
    FastLED.addLeds<NEOPIXEL, 12>(ledsB[i], NUM_LEDS_PART_B);
  }
  FastLED.addLeds<NEOPIXEL, 8>(ledsC, NUM_LEDS_PART_C);

  // Megszakítások beállítása
  attachInterrupt(digitalPinToInterrupt(PIN_BUTTON_LEFT), handleLeftButton, RISING);
  attachInterrupt(digitalPinToInterrupt(PIN_BUTTON_RIGHT), handleRightButton, RISING);

  // Kezdeti állapot beállítása
  clearAllLeds();
}

void loop() {
  unsigned long currentTime = millis();
  
  if (currentTime - lastUpdateTime >= UPDATE_INTERVAL) {
    lastUpdateTime = currentTime;
    
    updateButtonStates();
    handleTurnSignals();
    handleDayLights();
    handleKnightRider();
    handleBrakeAndTailLights();
    
    FastLED.show();
  }
}

void updateButtonStates() {
  engineOn = digitalRead(PIN_BUTTON_ENGINE);
  knightRiderActive = digitalRead(PIN_BUTTON_KNIGHT_RIDER);
  brakeActive = digitalRead(PIN_BUTTON_BRAKE);
  tailLightsActive = digitalRead(PIN_BUTTON_TAIL_LIGHTS);
}

void handleTurnSignals() {
  static int turnPhase = 0;
  
  if (stateLeft || stateRight) {
    turnPhase = (turnPhase + 1) % (NUM_LEDS_PART_B * 2);
    
    if (stateLeft) updateTurnSignal(0, turnPhase);
    if (stateRight) updateTurnSignal(1, turnPhase);
    
    // Vészvillogó kezelése
    if (stateLeft && stateRight) {
      ledsC[0] = ledsC[2] = COLOR_DASH_HAZARD;
    } else {
      ledsC[0] = stateLeft ? COLOR_DASH_TURN : CRGB::Black;
      ledsC[2] = stateRight ? COLOR_DASH_TURN : CRGB::Black;
    }
  } else {
    turnPhase = 0;
    ledsC[0] = ledsC[2] = CRGB::Black;
  }
}

void updateTurnSignal(int side, int phase) {
  int startLed = (side == 0) ? 0 : (NUM_LEDS_PART_A - NUM_LEDS_PART_B);
  for (int i = 0; i < NUM_LEDS_PART_B; i++) {
    CRGB color = (i < phase && i < NUM_LEDS_PART_B) ? COLOR_TURN : CRGB::Black;
    if (SHOW_SIGNAL_BIG_STRIP) ledsA[startLed + i] = color;
    ledsB[side][i] = ledsB[side + 2][i] = color;
  }
}

void handleDayLights() {
  if (engineOn && !knightRiderActive) {
    uint8_t brightness = tailLightsActive ? MAX_BRIGHTNESS_NIGHT : MAX_BRIGHTNESS_DAY;
    for (int i = 2; i < 4; i++) {
      fill_solid(ledsB[i], NUM_LEDS_PART_B, CRGB(brightness, brightness, brightness));
    }
    ledsC[1] = COLOR_DASH_DAY;
  } else {
    for (int i = 2; i < 4; i++) {
      fill_solid(ledsB[i], NUM_LEDS_PART_B, CRGB::Black);
    }
    ledsC[1] = CRGB::Black;
  }
}

void handleKnightRider() {
  static uint8_t hue = 0;
  
  if (knightRiderActive && (!engineOn || KNIGHT_RIDER_OVERRIDE_DAY)) {
    if (KNIGHT_RIDER_RAINBOW) {
      EVERY_N_MILLISECONDS(20) { hue++; }
    }
    
    int pos = beatsin16(KNIGHT_RIDER_SPEED, 0, NUM_LEDS_PART_B - 1);
    for (int i = 0; i < NUM_STRIPS; i++) {
      fadeToBlackBy(ledsB[i], NUM_LEDS_PART_B, KNIGHT_RIDER_TAIL);
      ledsB[i][pos] += CHSV(hue, 255, 192);
    }
    
    ledsC[1] = COLOR_DASH_KNIGHT_RIDER;
  }
}

void handleBrakeAndTailLights() {
  CRGB color;
  uint8_t brightness;
  
  if (brakeActive) {
    color = CRGB(MAX_BRIGHTNESS_BRAKE, 0, 0);
    brightness = MAX_BRIGHTNESS_BRAKE;
  } else if (tailLightsActive) {
    color = CRGB(MAX_BRIGHTNESS_TAIL, 0, 0);
    brightness = MAX_BRIGHTNESS_TAIL;
  } else {
    color = CRGB::Black;
    brightness = 0;
  }

  // Hátsó lámpák beállítása
  for (int i = NUM_LEDS_PART_B; i < NUM_LEDS_PART_A - NUM_LEDS_PART_B; i++) {
    ledsA[i] = color;
  }

  if (SHOW_TAIL_BRAKE_SMALL_STRIP) {
    fill_solid(ledsB[0], NUM_LEDS_PART_B, color);
    fill_solid(ledsB[1], NUM_LEDS_PART_B, color);
  }

  // Dashboard jelzés
  if (tailLightsActive) {
    ledsC[1] = COLOR_DASH_TAIL;
  } else if (!engineOn && !knightRiderActive) {
    ledsC[1] = CRGB::Black;
  }
}

void clearAllLeds() {
  fill_solid(ledsA, NUM_LEDS_PART_A, CRGB::Black);
  for (int i = 0; i < NUM_STRIPS; i++) {
    fill_solid(ledsB[i], NUM_LEDS_PART_B, CRGB::Black);
  }
  fill_solid(ledsC, NUM_LEDS_PART_C, CRGB::Black);
  FastLED.show();
}

void handleLeftButton() {
  stateLeft = !stateLeft;
  if (stateLeft) stateRight = false;
}

void handleRightButton() {
  stateRight = !stateRight;
  if (stateRight) stateLeft = false;
}