// ==================== MODUL 4 - SENZORJI VITRINE (KANAL 1) ====================
#include <esp_now.h>
#include <esp_wifi.h>  // <<< POMEMBNO: Dodajte to vrstico!
#include <WiFi.h>
#include <DHT.h>

// ==================== DEFINICIJE PINOV ====================
#define DHTPIN 14
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

#define LDR_PIN 4
#define SOIL_MOISTURE_PIN 5

#define MODULE_ID 4

// MAC naslov glavnega sistema (master ESP32)
// PREVERITE TA NASLOV - MORA BITI PRAVILEN!
uint8_t masterMAC[] = {0xB4, 0x3A, 0x45, 0xF3, 0xEB, 0xF0};

const unsigned long SEND_INTERVAL = 10000;  // 10 sekund

// ==================== GLOBALNE SPREMENLJIVKE ====================
float airTemperature = 0;
float airHumidity = 0;
int lightPercent = 0;
float soilTemperature = 0;
int soilMoisturePercent = 0;

bool dhtInitialized = false;

// Kalibracijske vrednosti
int ldrMinADC = 500;
int ldrMaxADC = 3000;
int SOIL_DRY_VALUE = 4095;
int SOIL_WET_VALUE = 1500;

unsigned long lastSendTime = 0;
unsigned long lastSensorRead = 0;
#define SENSOR_READ_INTERVAL 2000

// ==================== FUNKCIJE ZA BRANJE SENZORJEV ====================

void readDHT22() {
    float h = dht.readHumidity();
    float t = dht.readTemperature();
    
    if (isnan(t) || isnan(h)) {
        delay(100);
        h = dht.readHumidity();
        t = dht.readTemperature();
    }
    
    if (!isnan(t) && !isnan(h)) {
        airTemperature = t;
        airHumidity = h;
        Serial.printf("  DHT22: T=%.1f°C, H=%.1f%%\n", airTemperature, airHumidity);
        dhtInitialized = true;
    } else {
        Serial.println("  DHT22: Napaka pri branju!");
    }
}

void readLDR() {
    int rawValue = analogRead(LDR_PIN);
    rawValue = constrain(rawValue, 0, 4095);
    
    if (ldrMaxADC > ldrMinADC) {
        lightPercent = map(rawValue, ldrMinADC, ldrMaxADC, 100, 0);
    } else {
        lightPercent = map(rawValue, 500, 3000, 100, 0);
    }
    lightPercent = constrain(lightPercent, 0, 100);
    
    Serial.printf("  LDR: ADC=%d, Light=%d%%\n", rawValue, lightPercent);
}

void readSoilMoisture() {
    int rawValue = analogRead(SOIL_MOISTURE_PIN);
    rawValue = constrain(rawValue, 0, 4095);
    
    if (SOIL_DRY_VALUE > SOIL_WET_VALUE) {
        soilMoisturePercent = map(rawValue, SOIL_DRY_VALUE, SOIL_WET_VALUE, 0, 100);
    } else {
        soilMoisturePercent = map(rawValue, 4095, 1500, 0, 100);
    }
    soilMoisturePercent = constrain(soilMoisturePercent, 0, 100);
    
    Serial.printf("  Soil Moisture: ADC=%d, Percent=%d%%\n", rawValue, soilMoisturePercent);
}

void readAllSensors() {
    Serial.println("\n📊 Branje senzorjev:");
    readDHT22();
    readLDR();
    readSoilMoisture();
}

// ==================== POŠILJANJE PODATKOV ====================

void sendDataToMaster() {
    if (!dhtInitialized && airTemperature == 0 && airHumidity == 0) {
        Serial.println("⚠ DHT22 ni inicializiran, preskakujem pošiljanje");
        return;
    }
    
    // Format: M4:temp,hum,0,light,soilTemp,soilMoisture,TVOC=0,CO2=0,CH2O=0
    char buffer[256];
    snprintf(buffer, sizeof(buffer),
             "M4:%.1f,%.1f,0.0,%d,%.1f,%d,TVOC=0,CO2=0,CH2O=0",
             airTemperature, airHumidity, lightPercent,
             0.0, soilMoisturePercent);
    
    Serial.printf("\n📡 Pošiljam podatke: %s\n", buffer);
    
    esp_err_t result = esp_now_send(masterMAC, (uint8_t*)buffer, strlen(buffer));
    
    if (result == ESP_OK) {
        Serial.println("  ✅ Podatki poslani!");
    } else {
        Serial.printf("  ❌ Napaka pri pošiljanju: %d\n", result);
    }
}

// ==================== INICIALIZACIJA ====================

void initSensors() {
    Serial.println("\n🔧 INICIALIZACIJA SENZORJEV");
    
    Serial.print("  DHT22... ");
    dht.begin();
    delay(1000);
    
    float testH = dht.readHumidity();
    float testT = dht.readTemperature();
    if (!isnan(testT) && !isnan(testH)) {
        dhtInitialized = true;
        airTemperature = testT;
        airHumidity = testH;
        Serial.printf("OK (T=%.1f°C, H=%.1f%%)\n", testT, testH);
    } else {
        Serial.println("NAPAKA!");
        dhtInitialized = false;
    }
    
    Serial.print("  LDR... ");
    pinMode(LDR_PIN, INPUT);
    Serial.println("OK");
    
    Serial.print("  Soil Moisture... ");
    pinMode(SOIL_MOISTURE_PIN, INPUT);
    Serial.println("OK");
}

void initESPNow() {
    Serial.println("\n🔧 INICIALIZACIJA ESP-NOW");
    
    WiFi.mode(WIFI_STA);
    delay(100);
    
    // ========== POMEMBNO: KANAL 1 (ISTI KOT GLAVNI SISTEM IN OSTALI MODULI) ==========
    esp_wifi_set_promiscuous(true);
    esp_wifi_set_channel(1, WIFI_SECOND_CHAN_NONE);
    esp_wifi_set_promiscuous(false);
    Serial.println("  📡 Kanal nastavljen na 1");
    
    if (esp_now_init() != ESP_OK) {
        Serial.println("  ❌ Napaka pri inicializaciji ESP-NOW!");
        return;
    }
    Serial.println("  ✅ ESP-NOW inicializiran!");
    
    // Dodaj master kot peerja - KANAL 1
    esp_now_peer_info_t peerInfo;
    memset(&peerInfo, 0, sizeof(peerInfo));
    memcpy(peerInfo.peer_addr, masterMAC, 6);
    peerInfo.channel = 1;  // KANAL 1
    peerInfo.encrypt = false;
    peerInfo.ifidx = WIFI_IF_STA;
    
    if (esp_now_add_peer(&peerInfo) == ESP_OK) {
        Serial.println("  ✅ Peer (glavni sistem) dodan!");
        Serial.print("     MAC naslov glavnega sistema: ");
        for(int i = 0; i < 6; i++) {
            Serial.printf("%02X", masterMAC[i]);
            if(i < 5) Serial.print(":");
        }
        Serial.println();
    } else {
        Serial.println("  ❌ Napaka pri dodajanju peer-ja!");
    }
}

// ==================== SETUP ====================

void setup() {
    Serial.begin(115200);
    delay(1000);
    
    Serial.println("\n\n╔════════════════════════════════════════════════════╗");
    Serial.println("║     MODUL 4 - SENZORJI VITRINE (KANAL 1)       ║");
    Serial.println("╚════════════════════════════════════════════════════╝\n");
    
    WiFi.mode(WIFI_STA);
    delay(100);
    Serial.print("📡 MAC naslov Modula 4: ");
    Serial.println(WiFi.macAddress());
    
    initSensors();
    initESPNow();
    
    Serial.println("\n📊 Začetne meritve:");
    delay(1000);
    readAllSensors();
    
    Serial.println("\n✅ Modul 4 pripravljen!");
    Serial.println("📡 Kanal: 1 (isti kot glavni sistem)");
    Serial.println("📡 Pošiljanje podatkov vsakih 10 sekund...\n");
    
    lastSendTime = millis();
    lastSensorRead = millis();
}

// ==================== LOOP ====================

void loop() {
    unsigned long now = millis();
    
    // ========== PREVERI IN POPRAVI KANAL NA 1 ==========
    static unsigned long lastChannelCheck = 0;
    if (now - lastChannelCheck > 10000) {
        int currentChannel = WiFi.channel();
        if (currentChannel != 1) {
            Serial.printf("⚠ Kanal je %d, nastavljam na 1...\n", currentChannel);
            WiFi.setChannel(1);
            delay(50);
            
            esp_wifi_set_promiscuous(true);
            esp_wifi_set_channel(1, WIFI_SECOND_CHAN_NONE);
            esp_wifi_set_promiscuous(false);
            
            if (WiFi.channel() == 1) {
                Serial.println("✓ Kanal uspešno nastavljen na 1");
            }
        }
        lastChannelCheck = now;
    }
    
    // ========== PREVERI ALI PEER OBSTAJA ==========
    static unsigned long lastPeerCheck = 0;
    if (now - lastPeerCheck > 30000) {
        if (!esp_now_is_peer_exist(masterMAC)) {
            Serial.println("⚠ Peer ne obstaja - ponovno dodajanje...");
            
            esp_now_peer_info_t peerInfo;
            memset(&peerInfo, 0, sizeof(peerInfo));
            memcpy(peerInfo.peer_addr, masterMAC, 6);
            peerInfo.channel = 1;
            peerInfo.encrypt = false;
            peerInfo.ifidx = WIFI_IF_STA;
            
            if (esp_now_add_peer(&peerInfo) == ESP_OK) {
                Serial.println("✓ Peer ponovno dodan");
            }
        }
        lastPeerCheck = now;
    }
    
    // ========== BRANJE SENZORJEV ==========
    if (now - lastSensorRead > SENSOR_READ_INTERVAL) {
        readAllSensors();
        lastSensorRead = now;
    }
    
    // ========== POŠILJANJE PODATKOV ==========
    if (now - lastSendTime > SEND_INTERVAL) {
        sendDataToMaster();
        lastSendTime = now;
    }
    
    delay(50);
}

// MODUL 4