// ==================== MODUL 1 - VREMENSKI MODUL ZUNANJI ====================
#include <esp_now.h>
#include <WiFi.h>
#include <Wire.h>
#include <Adafruit_AHTX0.h>
#include <Adafruit_BMP280.h>
#include <Preferences.h>

// ==================== PIN DEFINICIJE ====================
#define I2C_SDA 4
#define I2C_SCL 5
#define LDR_PIN 6
#define STATUS_LED 2

#define MODULE_ID 1

// ===== PRAVILEN MAC NASLOV GLAVNEGA SISTEMA =====
// Ta MAC naslov DOBITE IZ SERIAL MONITORJA GLAVNEGA SISTEMA!
// Začasno uporabite broadcat MAC za testiranje
uint8_t masterMAC[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

const unsigned long SEND_INTERVAL = 5000;

// ==================== STRUKTURE ====================
struct ModuleData {
    uint8_t moduleId;
    uint8_t moduleType;
    unsigned long timestamp;
    uint8_t errorCode;
    float batteryVoltage;
    float temperature;
    float humidity;
    float pressure;
    float lux;
    float bmpTemperature;
};

struct CommandData { 
    uint8_t targetModuleId; 
    uint8_t command; 
    float param1; 
    float param2; 
};

// ==================== GLOBALNE SPREMENLJIVKE ====================
ModuleData sendData;
Adafruit_AHTX0 aht;
Adafruit_BMP280 bmp;
Preferences preferences;

int ldrMinADC = 500;
int ldrMaxADC = 3000;

// ==================== SETUP ====================
void setup() {
    Serial.begin(115200);
    delay(2000);
    
    Serial.println("\n\n=========================================");
    Serial.println("MODUL 1 - VREMENSKI MODUL");
    Serial.println("=========================================");
    
    pinMode(STATUS_LED, OUTPUT);
    digitalWrite(STATUS_LED, LOW);
    
    // ===== 1. NAJENOSTAVNEJŠA WIFI INICIALIZACIJA =====
    Serial.println("\n--- Inicializacija WiFi ---");
    
    // Samo nastavi način - BREZ kakršnegakoli nastavljanja kanala!
    WiFi.mode(WIFI_STA);
    delay(100);
    
    String mac = WiFi.macAddress();
    Serial.printf("📡 MAC naslov: %s\n", mac.c_str());
    
    if (mac == "00:00:00:00:00:00" || mac == "FF:FF:FF:FF:FF:FF") {
        Serial.println("⚠ Neveljaven MAC! Poskus ponovne inicializacije...");
        WiFi.mode(WIFI_OFF);
        delay(500);
        WiFi.mode(WIFI_STA);
        delay(500);
        mac = WiFi.macAddress();
        Serial.printf("📡 Nov MAC naslov: %s\n", mac.c_str());
    }
    
    // ===== 2. ESP-NOW INICIALIZACIJA =====
    Serial.println("\n--- Inicializacija ESP-NOW ---");
    
    if (esp_now_init() != ESP_OK) {
        Serial.println("❌ ESP-NOW napaka!");
        while(1) {
            digitalWrite(STATUS_LED, HIGH);
            delay(500);
            digitalWrite(STATUS_LED, LOW);
            delay(500);
        }
    }
    Serial.println("✅ ESP-NOW inicializiran");
    
    esp_now_register_recv_cb(onDataRecv);
    
    // ===== 3. DODAJ MASTER PEER =====
    Serial.println("\n--- Dodajanje master peer-ja ---");
    
    esp_now_peer_info_t peerInfo;
    memset(&peerInfo, 0, sizeof(peerInfo));
    memcpy(peerInfo.peer_addr, masterMAC, 6);
    peerInfo.channel = 0;      // 0 = trenutni kanal
    peerInfo.encrypt = false;
    peerInfo.ifidx = WIFI_IF_STA;
    
    if (esp_now_add_peer(&peerInfo) == ESP_OK) {
        Serial.println("✅ Master peer dodan");
    } else {
        Serial.println("❌ Napaka pri dodajanju peer-ja!");
    }
    
    // ===== 4. SENZORJI =====
    Serial.println("\n--- Inicializacija senzorjev ---");
    
    Wire.begin(I2C_SDA, I2C_SCL);
    Wire.setClock(100000);
    delay(100);
    
    if (!aht.begin()) {
        Serial.println("❌ AHT20 napaka!");
    } else {
        Serial.println("✅ AHT20 OK");
    }
    
    if (!bmp.begin(0x76) && !bmp.begin(0x77)) {
        Serial.println("❌ BMP280 napaka!");
    } else {
        Serial.println("✅ BMP280 OK");
    }
    
    pinMode(LDR_PIN, INPUT);
    
    // Naloži kalibracijo
    preferences.begin("ldr-calib", true);
    ldrMinADC = preferences.getInt("min_adc", 500);
    ldrMaxADC = preferences.getInt("max_adc", 3000);
    preferences.end();
    
    // Pripravi podatke
    sendData.moduleId = MODULE_ID;
    sendData.moduleType = 1;
    sendData.batteryVoltage = 0;
    
    Serial.println("\n✅ Modul 1 pripravljen!");
    Serial.printf("📡 MAC: %s\n", WiFi.macAddress().c_str());
    Serial.println("📡 Pošiljanje podatkov vsakih 5 sekund...\n");
    
    // Utripni LED
    for(int i = 0; i < 3; i++) {
        digitalWrite(STATUS_LED, HIGH);
        delay(100);
        digitalWrite(STATUS_LED, LOW);
        delay(100);
    }
}

// ==================== GLAVNA ZANKA ====================
void loop() {
    static unsigned long lastSend = 0;
    static unsigned long lastRead = 0;
    unsigned long now = millis();
    
    // Branje senzorjev vsake 2 sekundi
    if (now - lastRead >= 2000) {
        sensors_event_t humidity, temp;
        if (aht.getEvent(&humidity, &temp)) {
            sendData.temperature = temp.temperature;
            sendData.humidity = humidity.relative_humidity;
        }
        
        sendData.pressure = bmp.readPressure() / 100.0F;
        sendData.bmpTemperature = bmp.readTemperature();
        
        int adcValue = analogRead(LDR_PIN);
        if (ldrMaxADC > ldrMinADC) {
            int percent = map(adcValue, ldrMinADC, ldrMaxADC, 100, 0);
            percent = constrain(percent, 0, 100);
            sendData.lux = map(percent, 0, 100, 0, 20000);
        } else {
            sendData.lux = 0;
        }
        
        lastRead = now;
    }
    
    // Pošiljanje vsakih 5 sekund
    if (now - lastSend >= SEND_INTERVAL) {
        sendData.timestamp = now;
        sendData.errorCode = 0;
        
        Serial.printf("📡 Pošiljam: T=%.1f°C, H=%.1f%%, Lux=%.0f\n", 
                      sendData.temperature, sendData.humidity, sendData.lux);
        
        esp_err_t result = esp_now_send(masterMAC, (uint8_t*)&sendData, sizeof(sendData));
        
        if (result == ESP_OK) {
            digitalWrite(STATUS_LED, HIGH);
            delay(10);
            digitalWrite(STATUS_LED, LOW);
            Serial.println("  ✅ Poslano!");
        } else {
            Serial.printf("  ❌ Napaka pri pošiljanju: %d\n", result);
        }
        
        lastSend = now;
    }
    
    delay(10);
}

// ==================== CALLBACK ZA PREJEM UKAZOV ====================
void onDataRecv(const esp_now_recv_info_t *recv_info, const uint8_t *incomingData, int len) {
    if (len == sizeof(CommandData)) {
        CommandData cmd;
        memcpy(&cmd, incomingData, sizeof(cmd));
        
        if (cmd.targetModuleId == MODULE_ID) {
            Serial.printf("📡 Prejet ukaz: cmd=%d\n", cmd.command);
            
            if (cmd.command == 10) {  // CALIB_DARK
                int darkADC = analogRead(LDR_PIN);
                ModuleData response;
                response.moduleId = MODULE_ID;
                response.errorCode = 100;  // CALIB_DARK
                response.lux = darkADC;
                esp_now_send(recv_info->src_addr, (uint8_t*)&response, sizeof(response));
                Serial.printf("  Temna vrednost: %d\n", darkADC);
            }
            else if (cmd.command == 11) {  // CALIB_BRIGHT
                int brightADC = analogRead(LDR_PIN);
                ModuleData response;
                response.moduleId = MODULE_ID;
                response.errorCode = 101;  // CALIB_BRIGHT
                response.lux = brightADC;
                esp_now_send(recv_info->src_addr, (uint8_t*)&response, sizeof(response));
                Serial.printf("  Svetla vrednost: %d\n", brightADC);
            }
            else if (cmd.command == 12) {  // CALIB_CONFIRM
                ldrMinADC = (int)cmd.param1;
                ldrMaxADC = (int)cmd.param2;
                preferences.begin("ldr-calib", false);
                preferences.putInt("min_adc", ldrMinADC);
                preferences.putInt("max_adc", ldrMaxADC);
                preferences.end();
                Serial.printf("  Kalibracija shranjena: min=%d, max=%d\n", ldrMinADC, ldrMaxADC);
            }
        }
    }
}