game.js

// ECLIPSE RISING — Main Game Controller
// Comprehensive: all animations triggered, canvas fixed, full battle loop

import { saveManager } from "./saveManager.js";
import { audio } from "./audioManager.js";
import { inputManager } from "./inputManager.js";
import { bossManager } from "./bossManager.js";
import { combatManager } from "./combatManager.js";
import { uiManager } from "./uiManager.js";
import { animationManager } from "./animationManager.js";
import { Spells } from "./spells.js";
import { characterRenderer } from "./characterRenderer.js";

class GameController {
    constructor() {
        this.gameState = "loading";
        this.currentBossId = null;
        this.currentChar = "knight";
        this.rendererReady = false;
        this.activeSpellProgress = 0;
        // Prevent double win/loss triggers
        this._battleEnded = false;
    }

    start() {
        console.log("Eclipse Rising — boot");

        // Ambient eclipse background canvas
        animationManager.init("bg-canvas");

        // UI system (loads save, runs loading bar, wires all buttons)
        uiManager.init({
            onStartGame: (bossId, charClass) => this.handleStartGame(bossId, charClass),
            onSettingsChange: () => { },
            onCharacterSelectChange: (charClass) => { this.currentChar = charClass; saveManager.setCharacter(charClass); },
        });

        // Input — keyboard hold + future WebSocket
        inputManager.init(
            (spellName, progress) => this.onPoseProgress(spellName, progress),
            (packet) => this.onPoseComplete(packet)
        );

        // Main game loop
        requestAnimationFrame(t => this.loop(t));
    }

    // ─── BATTLE START ─────────────────────────────────────────────────────────
    async handleStartGame(bossId, charClass) {
        this.currentBossId = bossId;
        this.currentChar = charClass || "knight";
        this.gameState = "loading_battle";
        this.rendererReady = false;
        this._battleEnded = false;

        // Boss AI + combat systems
        bossManager.setupBoss(bossId);
        combatManager.setupDuel(bossManager.currentBoss, saveManager.currentData, {
            onUpdate: () => uiManager.updateBattleHUD(),
            onSpellCompleted: (spell, dmg) => this.onPlayerHit(spell, dmg),
            onPlayerHit: (dmg) => this.onBossHitsPlayer(dmg),
            onPlayerHealed: (heal) => this.onPlayerHealed(heal),
            onLevelUp: (lvl) => animationManager.emitHealBurst("#ffd97d"),
        });

        // Show battle screen — canvas now visible in DOM
        uiManager.showScreen("screen-battle");
        uiManager.updateBattleHUD();

        // Re-show loading overlay (hidden after previous battle / retry)
        const loadingOv = document.getElementById("battle-loading-overlay");
        if (loadingOv) loadingOv.classList.remove("hidden");

        // Init particle VFX overlay
        animationManager.initArena("arena-canvas");

        // [FIX Step 5] Always destroy any previous renderer instance before re-init.
        // This prevents ghost WebGL contexts on replays / boss transitions.
        console.log("[Game] Destroying previous characterRenderer instance.");
        characterRenderer.destroy();

        // [FIX Step 1+4] Defer renderer init by one rAF frame so the browser has
        // committed the DOM paint and the canvas has non-zero layout dimensions.
        const gender = charClass === "sorceress" ? "female" : "male";
        requestAnimationFrame(() => {
            // [FIX Step 2] Verify canvas exists and has real dimensions before init.
            const canvas = document.getElementById("arena-canvas-3d");
            if (!canvas) {
                console.error("[Game] FATAL: arena-canvas-3d not found in DOM after rAF.");
                this.gameState = "battle";
                const ov = document.getElementById("battle-loading-overlay");
                if (ov) ov.classList.add("hidden");
                return;
            }
            const cW = canvas.clientWidth, cH = canvas.clientHeight;
            console.log(`[Game] arena-canvas-3d dimensions: ${cW}×${cH} (offsetParent: ${canvas.offsetParent?.id ?? 'null'})`);
            if (cW === 0 || cH === 0) {
                console.warn("[Game] Canvas is zero-sized — waiting one more frame.");
                // Try once more after another rAF if still zero (e.g. CSS transition not committed)
                requestAnimationFrame(() => this._bootRenderer(gender, bossId));
                return;
            }
            this._bootRenderer(gender, bossId);
        });
    }

    // ─── RENDERER BOOT (called from rAF defer in handleStartGame) ────────────
    _bootRenderer(gender, bossId) {
        console.log(`[Game] _bootRenderer() → gender=${gender}, bossId=${bossId}`);
        try {
            characterRenderer.init("arena-canvas-3d", gender, bossId, () => {
                console.log("[Game] characterRenderer.init() onLoaded callback fired ✓");
                this.rendererReady = true;
                this.gameState = "battle";
                const ov = document.getElementById("battle-loading-overlay");
                if (ov) ov.classList.add("hidden");
            });
        } catch (err) {
            console.error("[Game] characterRenderer.init() threw:", err);
            this.gameState = "battle";
            this.rendererReady = false;
            const ov = document.getElementById("battle-loading-overlay");
            if (ov) ov.classList.add("hidden");
        }
    }

    // ─── INPUT CALLBACKS ──────────────────────────────────────────────────────
    onPoseProgress(spellName, progress) {
        this.activeSpellProgress = progress;
        if (!this.rendererReady) return;
        // While the player is charging (holding the key), play the Hold animation
        if (progress > 0.05) characterRenderer.setPlayerHolding();
        else characterRenderer.setPlayerIdle();
    }

    onPoseComplete(packet) {
        if (this.gameState !== "battle") return;
        if (bossManager.state === "death" || bossManager.state === "spawning") return;
        // Resolve the spell through combatManager — it will call back onSpellCompleted
        // which triggers the cast animation + damage
        combatManager.handlePoseInput(packet, bossManager.currentBoss.spellsAllowed);
    }

    // ─── PLAYER CASTS → BOSS STAGGERS ─────────────────────────────────────────
    // Called by combatManager when a spell is confirmed (after hold duration met).
    // The cast animation plays here; damage fires at the impact frame inside characterRenderer.
    onPlayerHit(spellName, damage) {
        if (this.rendererReady) {
            // Play cast animation — damage fires at PLAYER_IMPACT_TIME inside the render loop
            characterRenderer.startPlayerAttack(spellName, damage);
            // Boss hitstagger always plays on every player spell
            characterRenderer.triggerBossHitstagger();
            characterRenderer.triggerShake(12, 0.22);
            characterRenderer.triggerHitStop(0.08);
        }
        const spell = Spells[spellName];
        animationManager.emitSpellImpact(spell ? spell.color : "#e8c99b", damage);
    }

    // ─── BOSS ATTACKS → PLAYER STAGGERS ──────────────────────────────────────
    onBossHitsPlayer(damage) {
        animationManager.emitBloodBurst("#ef4444");
        uiManager.flashScreenHit();
        if (this.rendererReady) {
            characterRenderer.setPlayerHit();
            characterRenderer.triggerShake(18, 0.30);
            characterRenderer.triggerHitStop(0.12);
        }
    }

    onPlayerHealed(heal) {
        animationManager.emitHealBurst("#22c55e");
        uiManager.flashScreenHeal();
    }

    // ─── MAIN GAME LOOP ───────────────────────────────────────────────────────
    loop(timestamp) {
        // Background eclipse canvas — always draws
        animationManager.updateBg(timestamp);



        // Battle tick — runs whether or not 3D renderer is ready
        if (this.gameState === "battle") {
            // Sync boss windup animation
            if (this.rendererReady) {
                const bState = bossManager.state;
                if (bState === "windup") {
                    characterRenderer.startBossWindup();
                    characterRenderer.setBossWindupProgress(bossManager.actionProgress);
                }
            }

            // Boss AI — always ticks
            bossManager.update(timestamp, combatManager.playerLevel);

            // VFX particles
            animationManager.updateVFX(timestamp);

            // Spell hold progress bar
            const pf = document.getElementById("spell-hold-progress");
            if (pf) pf.style.width = `${this.activeSpellProgress * 100}%`;

            // Rune key pulse
            this._pulseRune();

            // Spell guide mini canvas
            uiManager.tickSpellGuide(timestamp);

            // Win / loss check
            if (!this._battleEnded) this._checkBattleEnd();
        }

        requestAnimationFrame(t => this.loop(t));
    }

    _pulseRune() {
        const spell = Spells[combatManager.currentRequestedSpell];
        if (!spell) return;
        document.querySelectorAll(".rune-slot").forEach(r => r.classList.remove("pulsing"));
        const slot = document.getElementById(`rune-${spell.key}`);
        if (slot) slot.classList.add("pulsing");
    }

    // ─── WIN / LOSS ───────────────────────────────────────────────────────────
    _checkBattleEnd() {
        // Defeat
        if (combatManager.playerHp <= 0) {
            this._battleEnded = true;
            this.gameState = "defeat";
            if (this.rendererReady && characterRenderer) {
                characterRenderer.setPlayerState("death");
                characterRenderer.setBossState("idle");
            }
            saveManager.updateStats({ highestCombo: combatManager.highestComboThisDuel });
            setTimeout(() => uiManager.showDefeat(), 2200);
            return;
        }

        // Victory
        if (bossManager.hp <= 0) {
            this._battleEnded = true;
            this.gameState = "victory";
            if (this.rendererReady) {
                characterRenderer.triggerBossDeath();
                characterRenderer.triggerShake(25, 0.5);
                setTimeout(() => characterRenderer.setPlayerVictory(), 900);
            }
            animationManager.emitSpellImpact("#ffd97d", null);
            // Victory screen after death animation completes (≈2.5s)
            setTimeout(() => {
                if (this.currentBossId === 4) {
                    this.gameState = "ending";
                    uiManager.showEnding();
                } else {
                    uiManager.showVictory(this.currentBossId);
                }
            }, 2800);
        }
    }
}

const game = new GameController();
window.game = game;

window.triggerVictory = () => {
    console.log("FAILSAFE VICTORY ACTIVATED");
    if (game._battleEnded) return;
    game._battleEnded = true;
    game.gameState = "victory";
    bossManager.hp = 0;
    bossManager.state = 'death';
    bossManager.hitbox = null; // Remove boss hitbox
    if (game.rendererReady) {
        characterRenderer.triggerBossDeath();
        characterRenderer.triggerShake(25, 0.5);
        setTimeout(() => characterRenderer.setPlayerVictory(), 900);
    }
    animationManager.emitSpellImpact("#ffd97d", null);
    setTimeout(() => {
        if (game.currentBossId === 4) {
            game.gameState = "ending";
            uiManager.showEnding();
        } else {
            uiManager.showVictory(game.currentBossId);
        }
    }, 500);
};

window.combatManager = combatManager;
window.bossManager = bossManager;

window.addEventListener("DOMContentLoaded", () => game.start());