/*

⚠️ VAROVÁNÍ: Tento kód je pouze pro LEGÁLNÍ výzkum a testování 

vlastních zařízení v uzavřeném prostředí. Rušení komunikací je ILEGÁLNÍ.

*/

#include <RF24.h>

#include <esp_bt.h>

#include <esp_wifi.h>

#include <esp_now.h>

#include <BLEDevice.h>

#include <BLEServer.h>

#include <freertos/FreeRTOS.h>

#include <freertos/task.h>

#include <freertos/semphr.h>

#include <math.h>

#include <vector>

#include <algorithm>

// Pinout ESP32-S3

#define LED_PIN 21

#define NRF24_CE1 4

#define NRF24_CSN1 5

#define NRF24_CE2 15

#define NRF24_CSN2 16

// Módy systému podle bliknutí LED

enum SystemMode {

    MODE_IDLE = 0,      // 0 bliknutí - čistá logika bez RF

    MODE_BLUETOOTH = 1, // 1 bliknutí - Bluetooth Classic frekvence

    MODE_BLE = 2,       // 2 bliknutí - BLE frekvence

    MODE_WIFI = 3,      // 3 bliknutí - WiFi kanály

    MODE_RC = 4,        // 4 bliknutí - RC/2.4GHz zařízení

    MODE_ADAPTIVE = 5,  // 5 bliknutí - Adaptivní mód

    MODE_CHAOS = 6      // 6 bliknutí - Maximální chaos

};

// Globální stav

SystemMode currentMode = MODE_IDLE;

SystemMode nextMode = MODE_IDLE;

volatile bool modeChangeRequested = false;

volatile int blinkCounter = 0;

volatile bool ledActive = false;

// NRF24 instance

RF24 radio1(NRF24_CE1, NRF24_CSN1);

RF24 radio2(NRF24_CE2, NRF24_CSN2);

// =============================================

// JÁDRO LOGIKY - SPOLEČNÉ PRO VŠECHNY MÓDY

// =============================================

class CoreLogic {

private:

    // META-STATES pro anti-pattern

    enum MetaState {

        META_OBSERVE,      // Pozorování

        META_PRESSURE,     // Tlaková fáze

        META_DISRUPT,      // Narušení

        META_FALSE_QUIET,  // Falešný klid

        META_RESET         // Reset adaptace

    };

    

    MetaState metaState;

    float pressureLevel;    // 0.0-1.0

    float instabilityIndex; // 0.0-1.0

    float adaptationScore;  // 0.0-1.0

    uint32_t lastChange;

    uint32_t metaTimer;

    

    // Chaos parameters

    float chaosX[2];        // Chaos proměnné pro každý NRF

    float chaosR[2];        // Chaos parametry

    

    // Anti-pattern memory

    uint8_t lastChannels[2][3]; // Poslední 3 kanály každého NRF

    uint32_t patternEntropy;

    

    float chaos_map(float x, float r, float noise = 0.0) {

        // Logistická mapa s šumem

        float val = r * x * (1 - x);

        val += noise * ((float)esp_random() / UINT32_MAX - 0.5);

        return fmod(fabs(val), 1.0);

    }

    

    void updateMetaState() {

        uint32_t now = millis();

        uint32_t elapsed = now - metaTimer;

        

        // Nikdy neměň stav v pravidelných intervalech

        float changeProb = 0.001 * (1.0 + sin(now * 0.001)) * 

                          (1.0 - adaptationScore * 0.5);

        

        if(((float)esp_random() / UINT32_MAX) < changeProb || elapsed > 5000) {

            // Nepravidelná změna stavu

            MetaState newState;

            do {

                newState = (MetaState)(esp_random() % 5);

            } while(newState == metaState && (esp_random() % 3) != 0);

            

            metaState = newState;

            metaTimer = now;

            

            // Aktualizuj chaos parametry při změně

            chaosR[0] = 3.7 + ((float)esp_random() / UINT32_MAX) * 0.4;

            chaosR[1] = 3.7 + ((float)esp_random() / UINT32_MAX) * 0.4;

        }

    }

    

public:

    CoreLogic() {

        metaState = META_OBSERVE;

        pressureLevel = 0.1;

        instabilityIndex = 0.3;

        adaptationScore = 0.0;

        lastChange = millis();

        metaTimer = millis();

        

        chaosX[0] = 0.5;

        chaosX[1] = 0.6;

        chaosR[0] = 3.75;

        chaosR[1] = 3.78;

        

        memset(lastChannels, 0, sizeof(lastChannels));

        patternEntropy = 0;

    }

    

    // Hlavní rozhodovací funkce - VOLÁ SE Z KAŽDÉHO MÓDU

    void computeAction(SystemMode mode, uint8_t unit, 

                      uint8_t &channel, uint8_t &power, 

                      uint16_t &duration, uint8_t &patternType) {

        

        updateMetaState();

        

        // Aktualizuj chaos proměnné

        chaosX[unit] = chaos_map(chaosX[unit], chaosR[unit], 0.01);

        

        // Frekvenční targeting podle módu

        uint8_t baseChannel = 0;

        uint8_t channelRange = 125;

        

        switch(mode) {

            case MODE_BLUETOOTH:

                // Bluetooth Classic: 2402-2480 MHz

                baseChannel = 2;  // 2402 MHz

                channelRange = 78; // do 2480 MHz

                break;

                

            case MODE_BLE:

                // BLE: primárně advertising kanály 37,38,39

                baseChannel = (unit == 0) ? 37 : 38;

                channelRange = 3;

                break;

                

            case MODE_WIFI:

                // WiFi kanály: 1,6,11 nebo 1-13

                baseChannel = (unit == 0) ? 1 : 11;

                channelRange = 13;

                break;

                

            case MODE_RC:

                // RC zařízení: celé pásmo s hoppingem

                baseChannel = 0;

                channelRange = 125;

                break;

                

            case MODE_ADAPTIVE:

                // Adaptivní: kombinace všeho

                baseChannel = (millis() / 1000) % 50;

                channelRange = 75;

                break;

                

            case MODE_CHAOS:

                // Chaos: maximální rozsah

                baseChannel = 0;

                channelRange = 125;

                break;

                

            default: // IDLE

                channel = 0;

                power = 0;

                duration = 0;

                patternType = 0;

                return;

        }

        

        // Vypočti kanál s anti-pattern logikou

        uint8_t newChannel;

        do {

            float chaosVal = chaosX[unit];

            

            // Aplikuj meta-state vliv

            switch(metaState) {

                case META_OBSERVE:

                    chaosVal *= 0.3; // Nižší aktivita

                    break;

                case META_PRESSURE:

                    chaosVal = 0.5 + chaosVal * 0.5; // Vyšší aktivita

                    break;

                case META_DISRUPT:

                    chaosVal = fmod(chaosVal * 1.7, 1.0); // Maximální chaos

                    break;

                case META_FALSE_QUIET:

                    chaosVal *= 0.1; // Minimální aktivita

                    break;

                case META_RESET:

                    chaosVal = fmod(chaosVal + 0.5, 1.0); // Reset patternu

                    break;

            }

            

            newChannel = baseChannel + (uint8_t)(chaosVal * channelRange);

            newChannel %= 126;

            

            // Anti-pattern: nikdy stejný kanál 2x za sebou

        } while(newChannel == lastChannels[unit][0] && channelRange > 1);

        

        // Ulož do historie

        lastChannels[unit][2] = lastChannels[unit][1];

        lastChannels[unit][1] = lastChannels[unit][0];

        lastChannels[unit][0] = newChannel;

        

        channel = newChannel;

        

        // Výkon podle meta-stavu a pressureLevel

        if(metaState == META_OBSERVE || metaState == META_FALSE_QUIET) {

            power = (esp_random() % 2); // Nízký výkon

        } else if(metaState == META_DISRUPT) {

            power = 3; // Maximální výkon

        } else {

            power = 1 + (esp_random() % 2); // Střední výkon

        }

        

        // Doba trvání - nikdy stejná

        float durationBase = 50.0; // ms

        if(metaState == META_DISRUPT) {

            durationBase *= (1.0 + chaosX[unit]);

        } else if(metaState == META_FALSE_QUIET) {

            durationBase *= 0.3;

        }

        

        duration = (uint16_t)(durationBase * (0.8 + 0.4 * chaosX[(unit + 1) % 2]));

        duration = constrain(duration, 10, 500);

        

        // Typ patternu (0=silent, 1=noise, 2=pattern, 3=sweep)

        uint32_t timeSeed = millis() / (duration + 1);

        patternType = (timeSeed + unit) % 4;

        

        // Někdy přeskoč úplně (anti-pattern)

        if((esp_random() % 1000) < 30) {

            patternType = 0; // Silent

            duration = 100; // Krátká pauza

        }

        

        // Aktualizuj globální metriky

        pressureLevel = 0.95 * pressureLevel + 0.05 * (power / 3.0);

        instabilityIndex = 0.9 * instabilityIndex + 

                          0.1 * fabs(chaosX[0] - chaosX[1]);

        

        // Sleduj adaptaci prostředí

        static uint32_t lastActivity = 0;

        uint32_t now = millis();

        if(patternType != 0 && power > 0) {

            uint32_t activityInterval = now - lastActivity;

            if(activityInterval < 1000) {

                // Častá aktivita = prostředí se možná adaptuje

                adaptationScore = fmin(1.0, adaptationScore + 0.01);

            }

            lastActivity = now;

        }

        

        // Pokud se prostředí adaptuje, změň meta-state

        if(adaptationScore > 0.7) {

            metaState = META_RESET;

            adaptationScore *= 0.5; // Resetuj skóre

        }

        

        lastChange = now;

    }

    

    float getPressure() { return pressureLevel; }

    float getInstability() { return instabilityIndex; }

    MetaState getMetaState() { return metaState; }

};

// =============================================

// LED INDIKACE

// =============================================

void blinkLED(int times, int delayMs = 200) {

    for(int i = 0; i < times; i++) {

        digitalWrite(LED_PIN, HIGH);

        delay(delayMs);

        digitalWrite(LED_PIN, LOW);

        if(i < times - 1) delay(delayMs);

    }

}

void indicateMode(SystemMode mode) {

    Serial.printf("\n=== MÓD %d ===", mode);

    

    switch(mode) {

        case MODE_IDLE:

            Serial.println(" IDLE - Čistá logika bez RF");

            blinkLED(0);

            break;

        case MODE_BLUETOOTH:

            Serial.println(" BLUETOOTH CLASSIC frekvence");

            blinkLED(1);

            break;

        case MODE_BLE:

            Serial.println(" BLE frekvence");

            blinkLED(2);

            break;

        case MODE_WIFI:

            Serial.println(" WiFi kanály");

            blinkLED(3);

            break;

        case MODE_RC:

            Serial.println(" RC/2.4GHz zařízení");

            blinkLED(4);

            break;

        case MODE_ADAPTIVE:

            Serial.println(" ADAPTIVNÍ MÓD");

            blinkLED(5);

            break;

        case MODE_CHAOS:

            Serial.println(" CHAOS MÓD - maximální anti-pattern");

            blinkLED(6);

            break;

    }

}

// =============================================

// RF EXECUTOR - SPOLEČNÝ PRO VŠECHNY MÓDY

// =============================================

class RFExecutor {

private:

    RF24* radios[2];

    CoreLogic core;

    SemaphoreHandle_t radioMutex[2];

    TaskHandle_t taskHandles[2];

    

    void executePattern(uint8_t unit, uint8_t channel, uint8_t power, 

                       uint16_t duration, uint8_t patternType) {

        

        if(patternType == 0 || power == 0) {

            // Silent mode - jen počkej

            delayMicroseconds(duration * 100);

            return;

        }

        

        xSemaphoreTake(radioMutex[unit], portMAX_DELAY);

        

        // Nastav rádio

        radios[unit]->stopListening();

        radios[unit]->setChannel(channel);

        radios[unit]->setPALevel((rf24_pa_dbm_e)power);

        

        uint32_t start = micros();

        

        switch(patternType) {

            case 1: // Noise burst

                for(uint16_t i = 0; i < duration / 2; i++) {

                    uint8_t noise[32];

                    esp_fill_random(noise, 32);

                    radios[unit]->writeFast(noise, 32);

                    delayMicroseconds(100 + (esp_random() % 100));

                }

                break;

                

            case 2: // Pattern (ale ne pravidelný)

                for(uint16_t i = 0; i < duration / 3; i++) {

                    uint8_t pattern[32];

                    for(uint8_t j = 0; j < 32; j++) {

                        pattern[j] = (i * j + channel + unit * 17) % 256;

                    }

                    radios[unit]->writeFast(pattern, 32);

                    delayMicroseconds(150 + (i % 7) * 20);

                }

                break;

                

            case 3: // Frequency sweep

                for(uint8_t ch = channel; 

                    ch < channel + 5 && ch < 126; ch++) {

                    radios[unit]->setChannel(ch);

                    uint8_t data = ch;

                    radios[unit]->writeFast(&data, 1);

                    delayMicroseconds(80 + (esp_random() % 40));

                }

                break;

        }

        

        xSemaphoreGive(radioMutex[unit]);

        

        // Mikro-pauza pro anti-pattern

        if((esp_random() % 10) < 3) {

            delayMicroseconds(500 + (esp_random() % 1500));

        }

    }

    

    static void radioTask(void* arg) {

        RFExecutor* executor = (RFExecutor*)arg;

        uint8_t unit = (uintptr_t)arg & 0x01;

        

        while(true) {

            if(currentMode == MODE_IDLE) {

                vTaskDelay(pdMS_TO_TICKS(100));

                continue;

            }

            

            uint8_t channel, power, patternType;

            uint16_t duration;

            

            // VYVOLÁNÍ JÁDROVÉ LOGIKY - SPOLEČNÉ PRO VŠECHNY MÓDY

            executor->core.computeAction(currentMode, unit, 

                                        channel, power, 

                                        duration, patternType);

            

            // Proveď akci

            executor->executePattern(unit, channel, power, 

                                   duration, patternType);

            

            // Dynamický delay - KLÍČOVÝ PRO ANTI-PATTERN

            uint32_t delayTime = 50 + (esp_random() % 200);

            

            // Někdy dlouhá pauza (anti-pattern)

            if((esp_random() % 100) < 10) {

                delayTime += 300 + (esp_random() % 700);

            }

            

            vTaskDelay(pdMS_TO_TICKS(delayTime));

        }

    }

    

public:

    RFExecutor(RF24* r1, RF24* r2) {

        radios[0] = r1;

        radios[1] = r2;

        

        radioMutex[0] = xSemaphoreCreateMutex();

        radioMutex[1] = xSemaphoreCreateMutex();

    }

    

    void start() {

        // Inicializace NRF24

        for(int i = 0; i < 2; i++) {

            radios[i]->begin();

            radios[i]->setAutoAck(false);

            radios[i]->setDataRate(RF24_2MBPS);

            radios[i]->setCRCLength(RF24_CRC_DISABLED);

            radios[i]->setAddressWidth(3);

            radios[i]->setRetries(0, 0);

            

            uint8_t address[3] = {0xCE, 0xCE, (uint8_t)(0xCE + i)};

            radios[i]->openWritingPipe(address);

        }

        

        // Spuštění úloh na různých jádrech

        xTaskCreatePinnedToCore(radioTask, "Radio0", 4096, 

                               (void*)0, 3, &taskHandles[0], 0);

        xTaskCreatePinnedToCore(radioTask, "Radio1", 4096, 

                               (void*)1, 3, &taskHandles[1], 1);

    }

    

    CoreLogic& getCoreLogic() { return core; }

};

// =============================================

// MÓDOVÝ MANAGER

// =============================================

class ModeManager {

private:

    RFExecutor* executor;

    uint32_t modeStartTime;

    uint32_t modeDuration;

    

    void setModeDuration(SystemMode mode) {

        // Nepravidelné časy pro každý mód

        switch(mode) {

            case MODE_IDLE:

                modeDuration = 5000 + (esp_random() % 10000);

                break;

            case MODE_BLUETOOTH:

                modeDuration = 8000 + (esp_random() % 15000);

                break;

            case MODE_BLE:

                modeDuration = 6000 + (esp_random() % 12000);

                break;

            case MODE_WIFI:

                modeDuration = 10000 + (esp_random() % 20000);

                break;

            case MODE_RC:

                modeDuration = 12000 + (esp_random() % 18000);

                break;

            case MODE_ADAPTIVE:

                modeDuration = 15000 + (esp_random() % 25000);

                break;

            case MODE_CHAOS:

                modeDuration = 5000 + (esp_random() % 8000);

                break;

        }

    }

    

public:

    ModeManager(RFExecutor* exec) : executor(exec) {

        modeStartTime = millis();

        setModeDuration(currentMode);

    }

    

    void update() {

        uint32_t now = millis();

        

        // Automatická rotace módů

        if(now - modeStartTime > modeDuration) {

            SystemMode newMode;

            do {

                newMode = (SystemMode)((currentMode + 1 + (esp_random() % 3)) % 7);

            } while(newMode == currentMode);

            

            changeMode(newMode);

        }

        

        // Ruční změna módu přes sériový port

        if(Serial.available()) {

            char cmd = Serial.read();

            if(cmd >= '0' && cmd <= '6') {

                changeMode((SystemMode)(cmd - '0'));

            }

        }

    }

    

    void changeMode(SystemMode newMode) {

        Serial.printf("\n🔄 Změna módu: %d -> %d\n", currentMode, newMode);

        

        // Krátká pauza při změně módu

        delay(200);

        

        currentMode = newMode;

        indicateMode(currentMode);

        

        modeStartTime = millis();

        setModeDuration(currentMode);

        

        // Resetuj část logiky při změně módu

        executor->getCoreLogic() = CoreLogic();

    }

    

    void printStatus() {

        static uint32_t lastPrint = 0;

        uint32_t now = millis();

        

        if(now - lastPrint > 2000) {

            CoreLogic& core = executor->getCoreLogic();

            

            Serial.printf("\n📊 Stav: Mód=%d Tlak=%.2f Nestabilita=%.2f",

                         currentMode, core.getPressure(), core.getInstability());

            

            const char* metaStates[] = {"OBSERVE", "PRESSURE", "DISRUPT", 

                                       "FALSE_QUIET", "RESET"};

            Serial.printf(" Meta=%s\n", metaStates[core.getMetaState()]);

            

            lastPrint = now;

        }

    }

};

// =============================================

// GLOBÁLNÍ INSTANCE

// =============================================

RFExecutor* rfExecutor;

ModeManager* modeManager;

// =============================================

// SETUP A LOOP

// =============================================

void setup() {

    Serial.begin(115200);

    pinMode(LED_PIN, OUTPUT);

    

    Serial.println("\n🚀 ESP32-S3 Anti-Adaptive System");

    Serial.println("================================");

    Serial.println("0: IDLE        (0x blink)");

    Serial.println("1: BLUETOOTH   (1x blink)");

    Serial.println("2: BLE         (2x blink)");

    Serial.println("3: WIFI        (3x blink)");

    Serial.println("4: RC          (4x blink)");

    Serial.println("5: ADAPTIVE    (5x blink)");

    Serial.println("6: CHAOS       (6x blink)");

    Serial.println("================================");

    

    // Vypni Bluetooth Classic (šetří interference)

    esp_bt_controller_disable();

    

    // Inicializace RF systému

    rfExecutor = new RFExecutor(&radio1, &radio2);

    rfExecutor->start();

    

    // Inicializace módového manageru

    modeManager = new ModeManager(rfExecutor);

    

    // Start v IDLE módu

    indicateMode(MODE_IDLE);

    

    Serial.println("\n✅ Systém připraven. Posílaj '0'-'6' pro změnu módu.");

}

void loop() {

    // Hlavní smyčka jen řídí módy a zobrazuje status

    modeManager->update();

    modeManager->printStatus();

    

    delay(100);

}