// ESP32 + RC522 RFID + Servo + Buzzer + LEDs + OLED
// Pin haritasi: RST=GPIO2, OLED SCL=GPIO22 (default I2C)
// Kart okundu → yetkiliyse servo aç (yesil LED + 2 bip)
// Yetkisiz kart → kirmizi LED + 3 hizli bip
// Servo 5sn sonra otomatik kilitler

#include <SPI.h>
#include <MFRC522.h>
#include <ESP32Servo.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define RFID_SS_PIN   5
#define RFID_RST_PIN  2    // D2 — ustteki bos pin
#define SERVO_PIN     4
#define BUZZER_PIN    15
#define LED_GREEN     25
#define LED_RED       26

#define OLED_ADDR     0x3C
#define SCREEN_W      128
#define SCREEN_H      64

#define SERVO_LOCK    0
#define SERVO_UNLOCK  90
#define UNLOCK_MS     5000

Adafruit_SSD1306 oled(SCREEN_W, SCREEN_H, &Wire, -1);
MFRC522 rfid(RFID_SS_PIN, RFID_RST_PIN);
Servo lockServo;

// Yetkili kart UID'leri (birden fazla eklenebilir)
struct AuthCard { byte uid[4]; const char* owner; };
AuthCard authorized[] = {
  { {0x01, 0x02, 0x03, 0x04}, "BlueGrays" },
};
const int authCount = sizeof(authorized) / sizeof(AuthCard);

bool locked = true;
unsigned long unlockTimeMs = 0;

void lcdAt(int x, int y, uint8_t size, const String &text) {
  oled.setTextSize(size);
  oled.setCursor(x, y);
  oled.print(text);
}

bool checkAuthorized(byte *uid, byte uidLen, const char* &owner) {
  if (uidLen != 4) return false;
  for (int i = 0; i < authCount; i++) {
    bool match = true;
    for (int b = 0; b < 4; b++) {
      if (uid[b] != authorized[i].uid[b]) { match = false; break; }
    }
    if (match) { owner = authorized[i].owner; return true; }
  }
  return false;
}

String uidToString(byte *uid, byte uidLen) {
  String s = "";
  for (byte i = 0; i < uidLen; i++) {
    if (uid[i] < 0x10) s += "0";
    s += String(uid[i], HEX);
    if (i < uidLen - 1) s += ":";
  }
  s.toUpperCase();
  return s;
}

void drawSplash() {
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
  lcdAt(8, 10, 2, "BlueGrays");
  lcdAt(12, 38, 1, "Kapi Kilidi v1");
  oled.drawRoundRect(2, 2, 124, 60, 6, SSD1306_WHITE);
  oled.display();
}

void drawIdle() {
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
  lcdAt(0, 0, 1, "> KILITLI");
  oled.drawLine(0, 10, 127, 10, SSD1306_WHITE);
  lcdAt(20, 22, 2, "Karti");
  lcdAt(10, 42, 2, "Okutun");
  oled.display();
}

void drawUnlocked(const char* owner) {
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
  lcdAt(0, 0, 1, "> ACIK");
  oled.drawLine(0, 10, 127, 10, SSD1306_WHITE);
  lcdAt(20, 15, 2, "Hosgeldin");
  lcdAt(0, 38, 2, owner);
  lcdAt(0, 56, 1, "5sn sonra kilit");
  oled.display();
}

void drawDenied(const String &uid) {
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
  oled.fillRect(0, 0, 128, 12, SSD1306_WHITE);
  oled.setTextColor(SSD1306_BLACK);
  lcdAt(0, 2, 1, "> ERISIM RED");
  oled.setTextColor(SSD1306_WHITE);
  lcdAt(0, 18, 1, "Bilinmeyen kart:");
  lcdAt(0, 32, 1, uid);
  lcdAt(0, 50, 1, "Yetki yok");
  oled.display();
}

void beepShort(int count) {
  for (int i = 0; i < count; i++) {
    digitalWrite(BUZZER_PIN, HIGH);
    delay(80);
    digitalWrite(BUZZER_PIN, LOW);
    delay(80);
  }
}

void unlock(const char* owner) {
  locked = false;
  unlockTimeMs = millis();
  lockServo.write(SERVO_UNLOCK);
  digitalWrite(LED_GREEN, HIGH);
  drawUnlocked(owner);
  beepShort(2);
}

void lock() {
  locked = true;
  lockServo.write(SERVO_LOCK);
  digitalWrite(LED_GREEN, LOW);
  drawIdle();
  beepShort(1);
}

void denyAccess(const String &uid) {
  digitalWrite(LED_RED, HIGH);
  drawDenied(uid);
  beepShort(3);
  delay(500);
  digitalWrite(LED_RED, LOW);
  delay(2000);
  drawIdle();
}

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  pinMode(LED_RED, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);
  digitalWrite(LED_GREEN, LOW);
  digitalWrite(LED_RED, LOW);

  // Default I2C: SDA=21, SCL=22
  Wire.begin();
  if (!oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
    while (1);
  }
  drawSplash();
  delay(2500);

  SPI.begin();
  rfid.PCD_Init();

  lockServo.attach(SERVO_PIN);
  lockServo.write(SERVO_LOCK);

  drawIdle();
}

void loop() {
  if (!locked && (millis() - unlockTimeMs > UNLOCK_MS)) {
    lock();
  }

  if (!rfid.PICC_IsNewCardPresent()) { delay(80); return; }
  if (!rfid.PICC_ReadCardSerial())   { delay(80); return; }

  String uidStr = uidToString(rfid.uid.uidByte, rfid.uid.size);
  const char* owner = nullptr;
  bool ok = checkAuthorized(rfid.uid.uidByte, rfid.uid.size, owner);

  if (ok) {
    unlock(owner);
  } else if (locked) {
    denyAccess(uidStr);
  }

  rfid.PICC_HaltA();
  delay(200);
}