#include <Arduino.h>
#include "config.h"
#include "hub75_driver.h"

// ==================== Game of Life Configuration ====================
// 1 logical cell = 1 pixel on the matrix
#define CELL_W TOTAL_WIDTH   // 64
#define CELL_H TOTAL_HEIGHT  // 64

// Grids for current and next generation (Tracks age: 0 = dead, >0 = alive)
static uint8_t current[CELL_W][CELL_H];
static uint8_t next[CELL_W][CELL_H];

static unsigned long generation = 0;
static unsigned long last_changed_gen = 0; // Tracks stagnation
volatile bool engine_ready = false; 

// ==================== The Pattern Jukebox Library ====================
// Paste your RLE strings here! The engine will pick from them randomly.
// To add more, just add a comma and paste the next string in quotes.
// ==================== The Pattern Jukebox Library (50 Patterns) ====================
// A massive collection of Methuselahs, Spaceships, Oscillators, and Still Lifes.
const char* const PATTERN_LIBRARY[] = {
    // --- METHUSELAHS (Exploders) ---
    "bo5b$3bo3b$2o2b3o!",      // 0: The Acorn (5200+ generations)
    "6bo$2o$bo3b3o!",           // 1: Diehard (Vanishes after 130)
    "b2o$2o$bo!",               // 2: R-Pentomino (1100+ generations)
    "3o$obo$obo!",              // 3: Pi-heptomino 
    "o2b$2o2b$obo$2bo!",        // 4: B-heptomino
    "b2o$2ob$bo!",              // 5: F-pentomino
    "3ob$bobo$b2ob$2b2o!",      // 6: Century
    "b3o$3ob$b2o!",             // 7: C-heptomino
    "bo$o2b$b2o!",              // 8: W-pentomino
    "o$3o$obo$2bo!",            // 9: Herschel
    "o$o$3o!",                  // 10: V-pentomino
    "2o$b2o$2b2o!",             // 11: Z-hexomino
    "2b2o$o2b2o$b3o!",          // 12: Bunnies
    "o$2o$b3o$3bo!",            // 13: Switch Engine precursor

    // --- SPACESHIPS (Travelers) ---
    "bob$2bo$3o!",              // 14: Glider
    "bo2bo$o4b$o3bo$4o!",       // 15: Lightweight Spaceship (LWSS)
    "3bobo$o5b$o4bo$5o!",       // 16: Middleweight Spaceship (MWSS)
    "3b2obo$o6b$o5bo$6o!",      // 17: Heavyweight Spaceship (HWSS)
    "bobo$o$bo$o3bo$2ob2o!",    // 18: Copperhead
    "b2o$o2bo$bobo$2bo!",       // 19: Loafer precursor
    
    // --- GUNS & FACTORIES ---
    "24bo$22bobo$12b2o6b2o12b2o$11bo3bo4b2o12b2o$2o8bo5bo3b2o$2o8bo3bob2o4bobo$10bo5bo7bo$11bo3bo$12b2o!", // 20: Gosper Glider Gun
    
    // --- OSCILLATORS (Looping Animations) ---
    "3o!",                      // 21: Blinker (Period 2)
    "b3o$3o!",                  // 22: Toad (Period 2)
    "2o2b$o3b$3bo$2b2o!",       // 23: Beacon (Period 2)
    "2bo$o2bo$obo$2bo!",        // 24: Clock (Period 2)
    "2bo4bo2b$2ob4ob2o$2bo4bo2b!", // 25: Pentadecathlon (Period 15)
    "2b3o3b3o$b$o4bobo4bo$o4bobo4bo$o4bobo4bo$2b3o3b3o$b$2b3o3b3o$o4bobo4bo$o4bobo4bo$o4bobo4bo$b$2b3o3b3o!", // 26: Pulsar (Period 3)
    "2o$2o$2b2o$2b2o!",         // 27: Figure Eight (Period 8)
    "b2ob2o$b2ob2o$ob2obo$o4bo$o4bo!", // 28: Tumbler (Period 14)
    "2bo$obob$bob2o$2bo!",      // 29: Clock 2
    "3b2o$2bo2bo$bo4bo$o6bo$o6bo$bo4bo$2bo2bo$3b2o!", // 30: Octagon 2 (Period 5)
    "2b2o$b2ob2o$o4bo$b2ob2o$2b2o!", // 31: Honey Farm
    "2o$obobo$2o$2o$obobo$2o!", // 32: Spark Coil
    
    // --- STILL LIFES (Stable Structures) ---
    "2o$2o!",                   // 33: Block
    "b2ob$o2bo$b2ob!",          // 34: Beehive
    "b2ob$o2bo$bobo$2bo!",      // 35: Loaf
    "2ob$obo$b2o!",             // 36: Boat
    "bob$obo$bob!",             // 37: Tub
    "2o$obo$2o!",               // 38: Ship
    "bo$obo$obo$bo!",           // 39: Barge
    "bo$obo$obo$b2o!",          // 40: Long boat
    "bo$obo$o2bo$b2o!",         // 41: Mango
    "2o$o2bo$o2bo$2o!",         // 42: Pond
    "2o$obo$2bo$2b2o!",         // 43: Eater 1
    "3o$o$b2o$2b2o!",           // 44: Eater 2
    "2o$obo$b2o!",              // 45: Snake
    "2o$o$b2o!",                // 46: Carrier
    "2o$o2bo$2b2o!",            // 47: Aircraft carrier
    "2o$o2bo$2o!",              // 48: Elevener
    "2o$o$3o!"                  // 49: Schmoo
};

// Calculates exactly how many patterns are in your library dynamically
const int NUM_PATTERNS = sizeof(PATTERN_LIBRARY) / sizeof(PATTERN_LIBRARY[0]);

 

// ==================== Pattern Spawners ====================

// Clears the board completely
void clear_board() {
    for (int y = 0; y < CELL_H; y++) {
        for (int x = 0; x < CELL_W; x++) {
            current[x][y] = 0;
            next[x][y] = 0;
        }
    }
    generation = 0;
    last_changed_gen = 0;
}

// Safely sets a cell to alive, preventing crashes if patterns hit the boundary
void safe_spawn(int x, int y) {
    if (x >= 0 && x < CELL_W && y >= 0 && y < CELL_H) {
        current[x][y] = 1;
    }
}

// ==================== The RLE Parser ====================
// Reads the compressed text strings from the LifeWiki into actual matrix coordinates
void spawn_from_rle(int start_x, int start_y, const char* rle) {
    int x = 0, y = 0, count = 0;
    while (*rle) {
        if (*rle >= '0' && *rle <= '9') {
            count = count * 10 + (*rle - '0'); 
        } else if (*rle == 'b') { // Dead cell
            if (count == 0) count = 1;
            x += count;
            count = 0;
        } else if (*rle == 'o') { // Live cell
            if (count == 0) count = 1;
            for (int i = 0; i < count; i++) {
                safe_spawn(start_x + x, start_y + y);
                x++;
            }
            count = 0;
        } else if (*rle == '$') { // New row
            if (count == 0) count = 1;
            y += count;
            x = 0;
            count = 0;
        } else if (*rle == '!') { // End of pattern
            break;
        }
        rle++;
    }
}

// ==================== 50 Random Spawner ====================
// Sprinkles a precise number of completely random pixels (Mini Soup)
void spawn_random_soup(int num_cells) {
    for (int i = 0; i < num_cells; i++) {
        int rx = random(0, CELL_W);
        int ry = random(0, CELL_H);
        safe_spawn(rx, ry);
    }
}

// ==================== The Jukebox Engine ====================
// Randomly decides how to repopulate the board when it stagnates
void run_jukebox_spawner() {
    clear_board();
    
    // 33% chance to spawn 60-75 random pixels, 66% chance to use the RLE library
    if (random(100) < 33) {
        // Mode 1: Pure random soup (60 to 75 cells)
        int cell_count = random(60, 76);
        spawn_random_soup(cell_count);
    } else {
        // Mode 2: Spawn 1 to 3 famous patterns from our library at random spots
        int patterns_to_drop = random(1, 4); 
        for (int i = 0; i < patterns_to_drop; i++) {
            int selected_pattern = random(0, NUM_PATTERNS);
            // Keep spawns mostly on-screen by padding the random coordinates
            int spawn_x = random(5, CELL_W - 15);
            int spawn_y = random(5, CELL_H - 15);
            
            spawn_from_rle(spawn_x, spawn_y, PATTERN_LIBRARY[selected_pattern]);
        }
    }
}

// ==================== Helper: Count live neighbors (Hard Boundaries) ====================
int count_neighbors(int x, int y) {
    int live = 0;
    for (int dy = -1; dy <= 1; dy++) {
        for (int dx = -1; dx <= 1; dx++) {
            if (dx == 0 && dy == 0) continue;
            
            int nx = x + dx;
            int ny = y + dy;
            
            // Hard boundaries: Only count if the neighbor is physically on the matrix
            if (nx >= 0 && nx < CELL_W && ny >= 0 && ny < CELL_H) {
                if (current[nx][ny] > 0) live++;
            }
        }
    }
    return live;
}

// We will use this global variable to track if the screen goes totally black
int current_population = 0; 

// ==================== Compute next generation ====================
bool compute_next_generation() {
    bool board_changed = false;
    current_population = 0; // Reset the counter for this frame
    
    for (int y = 0; y < CELL_H; y++) {
        for (int x = 0; x < CELL_W; x++) {
            int neighbors = count_neighbors(x, y);
            uint8_t age = current[x][y];

            if (age > 0) {
                // Survival
                if (neighbors == 2 || neighbors == 3) {
                    next[x][y] = (age < 255) ? age + 1 : 255; 
                    if (age != next[x][y]) board_changed = true;
                } else {
                    // Death
                    next[x][y] = 0;
                    board_changed = true;
                }
            } else {
                // Birth
                if (neighbors == 3) {
                    next[x][y] = 1;
                    board_changed = true;
                } else {
                    next[x][y] = 0;
                }
            }
            
            // Count how many are alive for the instant-reset check!
            if (next[x][y] > 0) {
                current_population++;
            }
        }
    }
    
    memcpy(current, next, sizeof(current));
    generation++;
    
    return board_changed;
}


// ==================== Render current grid to display ====================
void render_grid() {
    hub75_clear();  // Clear the draw buffer

    for (int cy = 0; cy < CELL_H; cy++) {
        for (int cx = 0; cx < CELL_W; cx++) {
            uint8_t age = current[cx][cy];
            if (age > 0) {
                rgb_t color;
                
                // Color Explosion Logic!
                if (age == 1) {
                    // Newborn cells flash stark white for maximum contrast
                    color = RGB_WHITE; 
                } else {
                    // Older cells shift through the rainbow based on BOTH age and generation.
                    uint16_t hue = (generation * 4 + age * 8) % 360; 
                    color = hsv_to_rgb(hue, 255, 255);
                }

                // Draw a single pixel for 1:1 native resolution mapping
                hub75_set_pixel(cx, cy, color);
            }
        }
    }
}

// ==================== Setup (Core 0) ====================
void setup() {
    Serial.begin(115200);
    delay(1000);
    hub75_init();
    hub75_set_brightness(200);

    // Initialize the random number generator
    randomSeed(micros());

    // Kick off the first generation using the Jukebox!
    run_jukebox_spawner();

    Serial.println("Conway's Game of Life (Endless Jukebox Edition) started");
    engine_ready = true; 
}

// ==================== Main loop (Core 0) ====================
// ==================== Main loop (Core 0) ====================
void loop() {
    static unsigned long last_frame = 0;

    // Limit frame rate to ~15 fps (66 ms per gen)
    unsigned long now = millis();
    if (now - last_frame < 66) {
        delay(1);
        return;
    }
    last_frame = now;

    // 1. Compute the next generation
    bool changed = compute_next_generation();
    if (changed) {
        last_changed_gen = generation;
    }

    // --- NEW: THE COSMIC RAY DISRUPTOR ---
    // Every 40 frames, if the board is still alive, drop 1 random pixel on it.
    // If the board is stuck in an endless oscillator loop, this will blow it up!
    if (generation % 40 == 0 && current_population > 0) {
        safe_spawn(random(0, CELL_W), random(0, CELL_H));
    }

    // --- NEW: THE SMART AUTO-RESET ENGINE ---
    // Trigger 1: INSTANT RESET. If the board is totally empty, don't wait.
    if (current_population == 0) {
        run_jukebox_spawner();
    }
    // Trigger 2: TRUE STAGNATION. If absolutely nothing has moved in 20 frames.
    else if (generation - last_changed_gen > 50) {
        run_jukebox_spawner();
    }
    // Trigger 3: THE HARD LIMIT. Cut down to 800 frames so we cycle through 
    // the 50 patterns much faster and keep things visually exciting.
    else if (generation > 800) {
        run_jukebox_spawner(); 
    }

    // 3. Render the new generation into the draw buffer
    render_grid();

    // 4. Swap buffers – the display now shows the new generation
    hub75_swap_buffers();
}

// ==================== CORE 1 (Screen Refresh) ====================
void setup1() {}

void loop1() {
    if (!engine_ready) return; 
    
    // Run the HUB75 driver's refresh system purely on Core 1
    // This ensures your LED matrix never flickers while Core 0 does the heavy math!
    hub75_refresh();
}