#include "kknd.h"
#include <unistd.h>

/* =========================================================================
 * main.c - Entry point, headless sim mode and the real-time game loop.
 * ========================================================================= */

static void print_stats(Game *g) {
    Faction human = g->human, enemy = g->enemy;
    int hu = 0, eu = 0, hb = 0, eb = 0;
    for (int i = 0; i < g->unit_count; i++) {
        if (g->units[i].dead) continue;
        if (g->units[i].faction == human) hu++;
        else if (g->units[i].faction == enemy) eu++;
    }
    for (int i = 0; i < g->bld_count; i++) {
        if (g->buildings[i].dead) continue;
        if (g->buildings[i].faction == human) hb++;
        else if (g->buildings[i].faction == enemy) eb++;
    }
    const char *st = (g->state == GAME_WON) ? "WON" :
                     (g->state == GAME_LOST) ? "LOST" :
                     (g->state == GAME_PAUSED) ? "PAUSED" : "PLAY";
    printf("[t=%6.1f] state=%-6s  %s u=%3d b=%2d scrap=%5d | %s u=%3d b=%2d scrap=%5d | bullets=%d parts=%d obj=%s\n",
           g->time, st, faction_name(human), hu, hb, g->scrap[human],
           faction_name(enemy), eu, eb, g->scrap[enemy], g->bullet_count, g->particle_count,
           g->objective == OBJ_SURVIVE ? "survive" :
           g->objective == OBJ_GATHER  ? "scrap"   : "destroy");
    fflush(stdout);
}

static void save_snapshot(Game *g, int n) {
    char path[64];
    snprintf(path, sizeof path, "shot_%04d.png", n);
    void *pixels = malloc((size_t)VIEW_W * VIEW_H * 4);
    if (!pixels) return;
    if (SDL_RenderReadPixels(g->ren, NULL, SDL_PIXELFORMAT_RGBA32,
                             pixels, VIEW_W * 4) == 0) {
        if (png_save(path, VIEW_W, VIEW_H, (const uint8_t *)pixels) == 0)
            engine_log("snapshot -> %s", path);
    }
    free(pixels);
}

int main(int argc, char **argv) {
    Game *g = (Game *)malloc(sizeof(Game));
    if (!g) { fprintf(stderr, "Out of memory\n"); return 1; }

    int headless = 0; float sim_seconds = 0;
    Difficulty diff = DIFF_NORMAL;
    int mission = 0;
    int loaded = 0;
    float speed = 1.0f;
    Faction faction_override = FACTION_NONE;
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "--speed") == 0 && i + 1 < argc)
            speed = (float)atof(argv[++i]);
    }
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "--easy") == 0) diff = DIFF_EASY;
        else if (strcmp(argv[i], "--hard") == 0) diff = DIFF_HARD;
        else if (strcmp(argv[i], "--mission") == 0 && i + 1 < argc)
            mission = atoi(argv[++i]);
        else if (strcmp(argv[i], "--headless") == 0 && i + 1 < argc)
            { headless = 1; sim_seconds = (float)atof(argv[++i]); }
        else if (strcmp(argv[i], "--auto") == 0)
            { g_auto = 1; }
        else if (strcmp(argv[i], "--faction") == 0 && i + 1 < argc) {
            i++;
            if (!strcmp(argv[i], "evolved")) faction_override = FACTION_EVOLVED;
            else if (!strcmp(argv[i], "series9")) faction_override = FACTION_SERIES9;
            else faction_override = FACTION_SURVIVOR;
        }
        else if (strcmp(argv[i], "--load") == 0 && i + 1 < argc) {
            g_headless = headless;
            engine_init(g, KKND_NAME);
            engine_setup_match(g, mission);
            load_game(g, argv[++i]);
            loaded = 1;
        }
    }

    g_headless = headless;
    if (getenv("KKND_SHOT")) g_headless = 1;   /* snapshot mode = pure software, no SDL */
    if (!loaded) engine_init(g, KKND_NAME);
    if (faction_override != FACTION_NONE) g->human = faction_override;
    if (getenv("KKND_SPEED")) speed = (float)atof(getenv("KKND_SPEED"));
    g->speed_mul = speed;
    /* load campaign progress (highest unlocked mission id + 1) */
    {
        FILE *pf = fopen("progress.kknd", "r");
        if (pf) { int u = 0; if (fscanf(pf, "%d", &u) == 1 && u > 0) g->unlocked = u; fclose(pf); }
    }
    int shot_mode = (!headless && getenv("KKND_SHOT")) ? 1 : 0;
    if (shot_mode) engine_setup_match(g, mission);

    if (headless) {
        if (!loaded) engine_setup_match(g, mission);
        engine_log("Headless simulation for %.0f s (mission %d)", sim_seconds, mission);
        float t = 0, step = 1.0f/30.0f, stat = 0;
        print_stats(g);
        while (t < sim_seconds && g->state == GAME_PLAYING) {
            engine_update(g, step);
            t += step; stat += step;
            if (stat >= 1.0f) { print_stats(g); stat -= 1.0f; }
        }
        print_stats(g);
        engine_log("Simulation complete (winner=%s)",
            g->winner ? faction_name(g->winner) : "none");
        engine_shutdown(g);
        free(g);
        return 0;
    }

    engine_log("%s %s - choose a mission, SPACE pause, F5 save, RMB command", KKND_NAME, KKND_VERSION);

    /* Snapshot mode: fast-forward the simulation headlessly (no SDL), then
     * draw the world to an RGBA buffer with the software renderer and save a
     * PNG. Avoids the broken GPU readback on this box entirely. */
    if (shot_mode) {
        /* Mid-fight default: short so the raid pack is still dense in-frame
         * (env KKND_SHOT_T overrides; 3.5s emptied the clash before). */
        float pre = 1.0f;
        if (getenv("KKND_SHOT_T")) pre = (float)atof(getenv("KKND_SHOT_T"));
        float hdt = 1.0f / 30.0f;
        int steps = (int)(pre / hdt);
        for (int i = 0; i < steps; i++) engine_update(g, hdt);
        /* Particle life is short (~0.5–1.2s); reseed FX at the live clash so
         * the PNG shows explosions/smoke instead of a quiet mid-fight plate. */
        {
            /* FX at raid clash near human HQ (ignore far-base garrison). */
            float hx = 0, hy = 0;
            {
                int sx = g->map.spawn_x[g->human], sy = g->map.spawn_y[g->human];
                map_tile_to_world(sx, sy, &hx, &hy);
            }
            float clash_x = hx + 88.0f, clash_y = hy - 48.0f;
            float cx = 0, cy = 0;
            int n = 0;
            const float r2 = 220.0f * 220.0f;
            for (int i = 0; i < g->unit_count; i++) {
                Unit *u = &g->units[i];
                if (u->dead || u->faction == g->human) continue;
                float dx = u->x - clash_x, dy = u->y - clash_y;
                if (dx * dx + dy * dy > r2) continue;
                cx += u->x; cy += u->y; n++;
            }
            if (n > 0) { cx /= n; cy /= n; }
            else { cx = clash_x; cy = clash_y; }
            /* bigger impact blooms on plate: denser fire cores + smoke + debris */
            particle_burst(g, cx, cy, 96, 1, 255, 140, 40);
            particle_burst(g, cx + 22, cy - 12, 64, 0, 110, 100, 90);
            particle_burst(g, cx - 18, cy + 14, 60, 2, 255, 230, 90);
            particle_burst(g, cx + 36, cy + 8, 52, 1, 255, 90, 30);
            particle_burst(g, cx - 8, cy - 28, 48, 3, 95, 80, 65);
            particle_burst(g, cx + 12, cy + 30, 48, 1, 255, 170, 55);
            particle_burst(g, cx - 30, cy - 6, 44, 1, 255, 120, 40);
            particle_burst(g, cx + 28, cy + 22, 40, 2, 255, 210, 80);
            particle_burst(g, cx - 40, cy + 18, 40, 1, 255, 100, 35);
            particle_burst(g, cx + 44, cy - 16, 36, 2, 255, 240, 100);
            particle_burst(g, cx + 8, cy - 40, 36, 1, 255, 150, 45);
            particle_burst(g, cx - 22, cy + 36, 34, 0, 120, 110, 95);
            particle_burst(g, cx + 52, cy + 4, 32, 1, 255, 110, 30);
            particle_burst(g, cx - 48, cy - 14, 30, 0, 100, 95, 85);
            particle_burst(g, cx + 16, cy + 48, 28, 3, 85, 70, 55);
            particle_burst(g, cx - 12, cy - 48, 28, 1, 255, 160, 50);
            particle_burst(g, cx + 18, cy + 14, 36, 1, 255, 110, 35);
            particle_burst(g, cx - 24, cy - 18, 32, 3, 255, 150, 45);
            /* tall stacked building smoke / fire plumes (HQ, walls, turrets) */
            for (int i = 0; i < g->bld_count; i++) {
                Building *bl = &g->buildings[i];
                if (bl->dead || bl->build < 1.0f) continue;
                float bx = (float)(bl->tx * TILE + bl->w * TILE / 2);
                float by = (float)(bl->ty * TILE + bl->h * TILE / 2);
                float bdx = bx - clash_x, bdy = by - clash_y;
                if (bdx * bdx + bdy * bdy > r2) continue;
                int heavy = (bl->type == BT_BASE || bl->type == BT_TURRET);
                int smoke_n = heavy ? 22 : 14;
                /* Y-offset stack: base → mid → high → tip */
                particle_burst(g, bx, by - 10.0f, smoke_n, 0, 105, 95, 85);
                particle_burst(g, bx + 3.0f, by - 28.0f, smoke_n - 4, 0, 95, 88, 78);
                particle_burst(g, bx - 2.0f, by - 46.0f, smoke_n - 8, 0, 85, 80, 72);
                particle_burst(g, bx + 1.0f, by - 64.0f, smoke_n - 12, 0, 75, 70, 65);
                if (bl->hp < bl->max_hp * 0.85f || bl->type == BT_TURRET) {
                    particle_burst(g, bx + 4.0f, by - 6.0f, 16, 1, 255, 130, 40);
                    particle_burst(g, bx - 3.0f, by - 28.0f, 14, 1, 255, 110, 35);
                    particle_burst(g, bx + 2.0f, by - 46.0f, 12, 1, 255, 150, 45);
                    particle_burst(g, bx - 1.0f, by - 64.0f, 10, 1, 255, 90, 30);
                    particle_burst(g, bx - 3.0f, by - 14.0f, 8, 3, 90, 75, 60);
                    particle_burst(g, bx + 5.0f, by - 36.0f, 6, 3, 80, 65, 50);
                }
            }
            /* muzzle flashes on units in the clash radius */
            {
                int muz = 0;
                for (int i = 0; i < g->unit_count && muz < 28; i++) {
                    Unit *u = &g->units[i];
                    if (u->dead) continue;
                    float ux = u->x - clash_x, uy = u->y - clash_y;
                    if (ux * ux + uy * uy > r2) continue;
                    if ((i + muz) % 3 != 0) continue;
                    particle_burst(g, u->x + 6.0f, u->y - 4.0f, 6, 2, 255, 230, 120);
                    particle_burst(g, u->x + 4.0f, u->y - 2.0f, 4, 1, 255, 160, 50);
                    muz++;
                }
            }
            /* Mid-flight shells/missiles/lasers: after ~1s sim most live
             * bullets have already impacted. Reseed from attacker origin with
             * mid-flight prog so lofted kinds keep their parabolic arc in PNG. */
            {
                int spawned = 0;
                const float pair_r2 = 180.0f * 180.0f;
                for (int i = 0; i < g->unit_count && spawned < 110; i++) {
                    Unit *a = &g->units[i];
                    if (a->dead) continue;
                    float ax = a->x - clash_x, ay = a->y - clash_y;
                    if (ax * ax + ay * ay > r2) continue;
                    int shots = 0;
                    for (int j = 0; j < g->unit_count && spawned < 110 && shots < 4; j++) {
                        Unit *b = &g->units[j];
                        if (b->dead || b->faction == a->faction) continue;
                        float dx = b->x - a->x, dy = b->y - a->y;
                        float d2 = dx * dx + dy * dy;
                        if (d2 > pair_r2 || d2 < 20.0f * 20.0f) continue;
                        /* bias shell/missile arcs over MG/laser */
                        int kind = (spawned % 5 == 0) ? 0
                                 : (spawned % 5 == 1) ? 2
                                 : (spawned % 5 == 2) ? 1
                                 : (spawned % 5 == 3) ? 3 : 1;
                        float t = 0.18f + 0.60f * ((spawned * 37) % 100) / 100.0f;
                        int before = g->bullet_count;
                        bullet_spawn(g, a->x, a->y, b->id, -1, 1.0f, a->faction, kind);
                        if (g->bullet_count > before)
                            bullet_place_at_prog(&g->bullets[g->bullet_count - 1], t);
                        spawned++;
                        shots++;
                    }
                }
                /* turret / base guns → nearest enemy in clash */
                for (int i = 0; i < g->bld_count && spawned < 130; i++) {
                    Building *bl = &g->buildings[i];
                    if (bl->dead || (bl->type != BT_TURRET && bl->type != BT_BASE))
                        continue;
                    float bx = (float)(bl->tx * TILE + bl->w * TILE / 2);
                    float by = (float)(bl->ty * TILE + bl->h * TILE / 2);
                    float bdx = bx - clash_x, bdy = by - clash_y;
                    if (bdx * bdx + bdy * bdy > r2) continue;
                    int best = -1; float bestd = 1e12f;
                    for (int j = 0; j < g->unit_count; j++) {
                        Unit *u = &g->units[j];
                        if (u->dead || u->faction == bl->faction) continue;
                        float dx = u->x - bx, dy = u->y - by;
                        float d2 = dx * dx + dy * dy;
                        if (d2 < bestd && d2 < pair_r2) { bestd = d2; best = j; }
                    }
                    if (best < 0) continue;
                    Unit *tgt = &g->units[best];
                    float t = 0.25f + 0.45f * ((spawned * 19) % 100) / 100.0f;
                    int kind = (spawned % 3 == 0) ? 3 : 1;
                    int before = g->bullet_count;
                    bullet_spawn(g, bx, by, tgt->id, -1, 2.0f, bl->faction, kind);
                    if (g->bullet_count > before)
                        bullet_place_at_prog(&g->bullets[g->bullet_count - 1], t);
                    particle_burst(g, bx, by - 4.0f, 5, 2, 255, 220, 100);
                    spawned++;
                }
            }
            /* secondary SE clash: lingering columns + tracers */
            float clash2_x = hx + 40.0f, clash2_y = hy + 70.0f;
            float c2x = clash2_x, c2y = clash2_y;
            int n2 = 0;
            float sx2 = 0, sy2 = 0;
            for (int i = 0; i < g->unit_count; i++) {
                Unit *u = &g->units[i];
                if (u->dead || u->faction == g->human) continue;
                float dx = u->x - clash2_x, dy = u->y - clash2_y;
                if (dx * dx + dy * dy > 140.0f * 140.0f) continue;
                sx2 += u->x; sy2 += u->y; n2++;
            }
            if (n2 > 0) { c2x = sx2 / n2; c2y = sy2 / n2; }
            particle_burst(g, c2x, c2y, 72, 1, 255, 135, 35);
            particle_burst(g, c2x + 18, c2y - 10, 48, 0, 115, 105, 90);
            particle_burst(g, c2x - 14, c2y + 12, 52, 2, 255, 220, 85);
            particle_burst(g, c2x + 26, c2y + 8, 40, 1, 255, 95, 28);
            particle_burst(g, c2x - 6, c2y - 20, 40, 3, 90, 78, 62);
            particle_burst(g, c2x + 10, c2y + 24, 36, 1, 255, 160, 50);
            particle_burst(g, c2x - 28, c2y + 8, 32, 0, 100, 95, 80);
            particle_burst(g, c2x + 32, c2y - 16, 30, 1, 255, 120, 40);
            particle_burst(g, c2x + 14, c2y + 16, 28, 1, 255, 110, 35);
            particle_burst(g, c2x - 20, c2y - 12, 24, 3, 255, 150, 45);
            /* SE building fire/smoke columns (same tall stack) */
            {
                const float r2b = 140.0f * 140.0f;
                for (int i = 0; i < g->bld_count; i++) {
                    Building *bl = &g->buildings[i];
                    if (bl->dead || bl->build < 1.0f) continue;
                    float bx = (float)(bl->tx * TILE + bl->w * TILE / 2);
                    float by = (float)(bl->ty * TILE + bl->h * TILE / 2);
                    float bdx = bx - clash2_x, bdy = by - clash2_y;
                    if (bdx * bdx + bdy * bdy > r2b) continue;
                    int heavy = (bl->type == BT_BASE || bl->type == BT_TURRET);
                    int smoke_n = heavy ? 18 : 12;
                    particle_burst(g, bx, by - 10.0f, smoke_n, 0, 100, 92, 82);
                    particle_burst(g, bx + 2.0f, by - 28.0f, smoke_n - 4, 0, 90, 84, 74);
                    particle_burst(g, bx - 2.0f, by - 46.0f, smoke_n - 8, 0, 80, 76, 68);
                    particle_burst(g, bx + 1.0f, by - 64.0f, smoke_n - 10, 0, 70, 66, 60);
                    if (bl->hp < bl->max_hp * 0.85f || bl->type == BT_TURRET) {
                        particle_burst(g, bx + 3.0f, by - 8.0f, 14, 1, 255, 125, 38);
                        particle_burst(g, bx - 2.0f, by - 28.0f, 12, 1, 255, 105, 32);
                        particle_burst(g, bx + 2.0f, by - 46.0f, 10, 1, 255, 145, 42);
                        particle_burst(g, bx - 1.0f, by - 64.0f, 8, 1, 255, 95, 28);
                    }
                }
            }
            {
                int spawned2 = 0;
                const float pair_r2 = 160.0f * 160.0f;
                const float r2b = 140.0f * 140.0f;
                for (int i = 0; i < g->unit_count && spawned2 < 72; i++) {
                    Unit *a = &g->units[i];
                    if (a->dead) continue;
                    float ax = a->x - clash2_x, ay = a->y - clash2_y;
                    if (ax * ax + ay * ay > r2b) continue;
                    int shots = 0;
                    for (int j = 0; j < g->unit_count && spawned2 < 72 && shots < 4; j++) {
                        Unit *b = &g->units[j];
                        if (b->dead || b->faction == a->faction) continue;
                        float dx = b->x - a->x, dy = b->y - a->y;
                        float d2 = dx * dx + dy * dy;
                        if (d2 > pair_r2 || d2 < 18.0f * 18.0f) continue;
                        int kind = (spawned2 % 5 == 0) ? 0
                                 : (spawned2 % 5 == 1) ? 2
                                 : (spawned2 % 5 == 2) ? 1
                                 : (spawned2 % 5 == 3) ? 3 : 1;
                        float t = 0.18f + 0.58f * ((spawned2 * 41) % 100) / 100.0f;
                        int before = g->bullet_count;
                        bullet_spawn(g, a->x, a->y, b->id, -1, 1.0f, a->faction, kind);
                        if (g->bullet_count > before)
                            bullet_place_at_prog(&g->bullets[g->bullet_count - 1], t);
                        spawned2++;
                        shots++;
                    }
                }
                for (int i = 0; i < g->bld_count && spawned2 < 88; i++) {
                    Building *bl = &g->buildings[i];
                    if (bl->dead || (bl->type != BT_TURRET && bl->type != BT_BASE))
                        continue;
                    float bx = (float)(bl->tx * TILE + bl->w * TILE / 2);
                    float by = (float)(bl->ty * TILE + bl->h * TILE / 2);
                    float bdx = bx - clash2_x, bdy = by - clash2_y;
                    if (bdx * bdx + bdy * bdy > r2b) continue;
                    int best = -1; float bestd = 1e12f;
                    for (int j = 0; j < g->unit_count; j++) {
                        Unit *u = &g->units[j];
                        if (u->dead || u->faction == bl->faction) continue;
                        float dx = u->x - bx, dy = u->y - by;
                        float d2 = dx * dx + dy * dy;
                        if (d2 < bestd && d2 < pair_r2) { bestd = d2; best = j; }
                    }
                    if (best < 0) continue;
                    Unit *tgt = &g->units[best];
                    float t = 0.26f + 0.44f * ((spawned2 * 23) % 100) / 100.0f;
                    int kind = (spawned2 % 3 == 0) ? 3 : 1;
                    int before = g->bullet_count;
                    bullet_spawn(g, bx, by, tgt->id, -1, 2.0f, bl->faction, kind);
                    if (g->bullet_count > before)
                        bullet_place_at_prog(&g->bullets[g->bullet_count - 1], t);
                    spawned2++;
                }
            }
        }
        char path[64]; snprintf(path, sizeof path, "shot_%04d.png", 1);
        snapshot_capture(g, path);
        engine_log("snapshot -> %s", path);
        _exit(0);
    }

    Uint32 last = SDL_GetTicks();
    int running = 1;
    while (running) {
        SDL_Event e;
        while (SDL_PollEvent(&e)) {
            if (e.type == SDL_QUIT) { running = 0; break; }
            input_handle(g, &e);
        }
        if (!running) break;
        Uint32 now = SDL_GetTicks();
        float dt = (float)(now - last) / 1000.0f;
        last = now;
        if (dt > 0.05f) dt = 0.05f;
        if (g->state != GAME_MENU) {
            int prev_state = g->state;
            input_camera(g, dt);
            engine_update(g, dt);
            if (g->state == GAME_WON && prev_state != GAME_WON) {
                int next = g->mission_id + 2;   /* unlock the following mission */
                if (next > g->unlocked) {
                    g->unlocked = next;
                    FILE *pf = fopen("progress.kknd", "w");
                    if (pf) { fprintf(pf, "%d\n", g->unlocked); fclose(pf); }
                    engine_log("Unlocked next mission (%d)", g->unlocked - 1);
                }
                g->menu_sel = (g->mission_id + 1 < g->unlocked) ? g->mission_id + 1 : g->mission_id;
            }
        }
        render_frame(g);
    }

    save_game(g, "savegame.kknd");
    engine_shutdown(g);
    free(g);
    return 0;
}