combat manager

import { Spells } from "./spells.js";
import { saveManager } from "./saveManager.js";
import { bossManager } from "./bossManager.js";
import { audio } from "./audioManager.js";

class CombatManager {
    constructor() {
        this.playerHp = 100;
        this.playerMaxHp = 100;

        this.playerMana = 100;
        this.playerMaxMana = 100;

        this.playerLevel = 1;
        this.playerXp = 0;
        this.playerXpNeeded = 100;

        this.combo = 0;
        this.streak = 0;
        this.highestComboThisDuel = 0;

        this.spellsCompleted = 0;
        this.targetSpells = 15;
        this.damageTakenThisDuel = 0;

        this.currentRequestedSpell = null;

        // Callbacks to UI and Animations
        this.onCombatUpdateCallback = null;
        this.onSpellCompletedCallback = null;
        this.onPlayerHitCallback = null;
        this.onPlayerHealedCallback = null;
        this.onLevelUpCallback = null;
        this.onRuneUnlockCallback = null;
    }

    setupDuel(bossConfig, saveState, callbacks) {
        this.playerHp = 100;
        this.playerMaxHp = 100 + (saveState.level - 1) * 10; // health scales with level
        this.playerMana = 100;
        this.playerMaxMana = 100;

        this.playerLevel = saveState.level;
        this.playerXp = saveState.xp;
        this.playerXpNeeded = saveState.xpNeeded;

        this.combo = 0;
        this.streak = 0;
        this.highestComboThisDuel = 0;

        this.spellsCompleted = 0;
        this.targetSpells = bossConfig.targetSpells;
        this.damageTakenThisDuel = 0;

        // Register UI & Animation Callbacks
        this.onCombatUpdateCallback = callbacks.onUpdate;
        this.onSpellCompletedCallback = callbacks.onSpellCompleted;
        this.onPlayerHitCallback = callbacks.onPlayerHit;
        this.onPlayerHealedCallback = callbacks.onPlayerHealed;
        this.onLevelUpCallback = callbacks.onLevelUp;
        this.onRuneUnlockCallback = callbacks.onRuneUnlock;

        // Pick the first requested spell
        this.requestNextSpell(bossConfig.spellsAllowed);

        if (this.onCombatUpdateCallback) {
            this.onCombatUpdateCallback();
        }
    }

    requestNextSpell(allowedSpells) {
        if (!allowedSpells || allowedSpells.length === 0) return;

        // Filter down to make sure we don't request the exact same spell twice in a row if there are multiple options
        let pool = allowedSpells;
        if (allowedSpells.length > 1 && this.currentRequestedSpell) {
            pool = allowedSpells.filter(s => s !== this.currentRequestedSpell);
        }

        const randomIndex = Math.floor(Math.random() * pool.length);
        this.currentRequestedSpell = pool[randomIndex];

        if (this.onCombatUpdateCallback) {
            this.onCombatUpdateCallback();
        }
    }

    // Called when a simulated pose is completed
    handlePoseInput(posePacket, allowedSpells) {
        // Check if the completed spell is the one requested
        if (posePacket.spell === this.currentRequestedSpell) {
            this.handleSpellSuccess(posePacket, allowedSpells);
        } else {
            this.handleSpellMismatch(posePacket.spell);
        }
    }

    handleSpellSuccess(posePacket, allowedSpells) {
        const spellData = Spells[posePacket.spell];
        if (!spellData) return;

        this.spellsCompleted++;
        this.combo++;
        this.streak++;

        if (this.combo > this.highestComboThisDuel) {
            this.highestComboThisDuel = this.combo;
        }

        // Mana reward
        this.playerMana = Math.min(this.playerMaxMana, this.playerMana + spellData.manaReward);

        // Task 5: XP progression based on streak combo
        let xpMultiplier = 1.0;
        if (this.streak >= 15) xpMultiplier = 3.0;
        else if (this.streak >= 10) xpMultiplier = 2.0;
        else if (this.streak >= 5) xpMultiplier = 1.5;

        let xpReward = 10 * xpMultiplier;

        // Task 3: 15 streak double XP reward
        if (this.streak >= 15) {
            xpReward = xpReward * 2;
        }
        xpReward = Math.round(xpReward);

        const leveledUp = saveManager.addXP(xpReward);
        this.playerXp = saveManager.currentData.xp;
        this.playerXpNeeded = saveManager.currentData.xpNeeded;
        this.lastXpAwarded = xpReward; // cache for diagnostics

        if (leveledUp) {
            this.playerLevel = saveManager.currentData.level;
            audio.playHealAura();
            if (this.onLevelUpCallback) {
                this.onLevelUpCallback(this.playerLevel);
            }
        }

        // Task 3: Streak heal rewards
        let healAmount = 0;
        if (this.streak === 5) healAmount = 10;
        else if (this.streak === 10) healAmount = 25;

        if (healAmount > 0) {
            this.playerHp = Math.min(this.playerMaxHp, this.playerHp + healAmount);
            audio.playHealAura();
            if (this.onPlayerHealedCallback) {
                this.onPlayerHealedCallback(healAmount);
            }
        }

        // Task 3: 15 streak stagger boss
        if (this.streak === 15) {
            bossManager.stagger(3000);
        }

        // Play casting whoosh SFX immediately
        audio.playSpellCast(posePacket.spell);

        // Interrupt boss immediately & reset boss attack timer (Task 1 Root Cause Fix)
        bossManager.interrupt();

        // Increase boss rage slightly on player success (Task 2)
        bossManager.rage = Math.min(100, bossManager.rage + 5);

        // Request next spell immediately to keep input HUD snappy
        this.requestNextSpell(allowedSpells);

        // Task 3: Damage bonus based on streak
        let damageMultiplier = 1.0;
        if (this.streak >= 10) damageMultiplier = 1.5;      // +50% damage
        else if (this.streak >= 5) damageMultiplier = 1.2;  // +20% damage
        else if (this.streak >= 3) damageMultiplier = 1.1;  // +10% damage

        const baseDamage = spellData.damage + (this.playerLevel - 1) * 2;
        const finalDamage = Math.round(baseDamage * damageMultiplier);

        // Notify game.js — this triggers the cast animation AND schedules damage at impact frame
        if (this.onSpellCompletedCallback) {
            this.onSpellCompletedCallback(posePacket.spell, finalDamage);
        }

        if (this.onCombatUpdateCallback) {
            this.onCombatUpdateCallback();
        }
    }

    applyPlayerSpellDamage(spellName, damage) {
        const playerHpBefore = this.playerHp;

        // Apply damage to boss HP and Armor at impact frame
        const damageInfo = bossManager.takeDamage(damage);

        // Check if boss defeated (session exercises completed OR boss HP <= 0)
        if (bossManager.hp <= 0 || this.spellsCompleted >= this.targetSpells) {
            bossManager.hp = 0; // Ensure boss is dead
            bossManager.state = 'death';
            bossManager.hitbox = null; // Remove boss hitbox
        }

        // Every successful player attack must log:
        console.log(`BOSS HP BEFORE: ${Math.round(damageInfo.hpBefore)}`);
        console.log(`DAMAGE: ${Math.round(damageInfo.amount)}`);
        console.log(`ARMOR ABSORBED: ${Math.round(damageInfo.armorAbsorbed)}`);
        console.log(`FINAL DAMAGE: ${Math.round(damageInfo.actualDamage)}`);
        console.log(`BOSS HP AFTER: ${Math.round(damageInfo.hpAfter)}`);

        // Task 6: Combat Diagnostics
        this.logCombatDiagnostics("SUCCESS", damage, 0, playerHpBefore, damageInfo.hpBefore, this.lastXpAwarded || 10);

        if (this.onCombatUpdateCallback) {
            this.onCombatUpdateCallback();
        }
    }

    applyBossAttackDamage(attackType, damage) {
        const playerHpBefore = this.playerHp;
        const bossHpBefore = bossManager.hp;

        let finalDamage = damage;

        // If player level is high, slightly mitigate damage
        const levelDefenseBonus = (this.playerLevel - 1) * 1;
        finalDamage = Math.max(5, finalDamage - levelDefenseBonus);

        this.playerHp -= finalDamage;
        this.damageTakenThisDuel += finalDamage;

        // Task 2: Break combo and streak on failed spell / boss hit
        this.combo = 0;
        this.streak = 0;

        audio.playHitImpact();

        if (this.playerHp <= 0) {
            this.playerHp = 0;
        }

        // Trigger callback to game.js (blood burst, hit stop, camera shake)
        if (this.onPlayerHitCallback) {
            this.onPlayerHitCallback(finalDamage);
        }

        // Task 6: Combat Diagnostics
        this.logCombatDiagnostics("FAILURE", 0, finalDamage, playerHpBefore, bossHpBefore, 0);

        if (this.onCombatUpdateCallback) {
            this.onCombatUpdateCallback();
        }
    }

    handleSpellMismatch(spellCast) {
        const playerHpBefore = this.playerHp;
        const bossHpBefore = bossManager.hp;

        // Task 2: Reset combo and streak on mismatch
        this.combo = 0;
        this.streak = 0;

        // Make a minor error sound (wrong spell penalty tone)
        audio.init();
        audio.resume();
        if (audio.ctx) {
            const osc = audio.ctx.createOscillator();
            const gainNode = audio.ctx.createGain();
            osc.type = 'sine';
            osc.frequency.setValueAtTime(180, audio.ctx.currentTime);
            gainNode.gain.setValueAtTime(0.15, audio.ctx.currentTime);
            gainNode.gain.exponentialRampToValueAtTime(0.0001, audio.ctx.currentTime + 0.2);
            osc.connect(gainNode);
            gainNode.connect(audio.sfxGain);
            osc.start();
            osc.stop(audio.ctx.currentTime + 0.2);
        }

        // Task 2: Force boss to execute an immediate attack
        bossManager.forceAttack();

        if (this.onCombatUpdateCallback) {
            this.onCombatUpdateCallback();
        }
    }

    // Task 6: Custom logger formatting diagnostics
    logCombatDiagnostics(result, damageDealt, damageReceived, playerHpBefore, bossHpBefore, xpAwarded) {
        console.log(`
=========================================
🛡️ COMBAT DIAGNOSTICS: ${result}
=========================================
Result:                 ${result}
Player Damage Dealt:    ${damageDealt}
Player Damage Received: ${damageReceived}
Boss HP:                ${Math.round(bossHpBefore)} ➔ ${Math.round(bossManager.hp)} (Max: ${bossManager.currentBoss?.maxHp})
Player HP:              ${Math.round(playerHpBefore)} ➔ ${Math.round(this.playerHp)} (Max: ${this.playerMaxHp})
Current Streak:         ${this.streak}
Current Combo:          ${this.combo}
XP Awarded:             ${xpAwarded}
=========================================
`);
    }

    // End of battle metrics
    getVictoryStats(bossId) {
        const accuracy = Math.round((this.spellsCompleted / (this.spellsCompleted + (this.damageTakenThisDuel > 0 ? 1 : 0))) * 100);
        const calories = this.spellsCompleted * 1.5; // roughly 1.5 kcal per exercise hold

        // Calculate Rank
        let rank = "C";
        if (this.damageTakenThisDuel === 0) rank = "SS";
        else if (this.highestComboThisDuel >= 12 && this.damageTakenThisDuel < 20) rank = "S";
        else if (this.highestComboThisDuel >= 8 && this.damageTakenThisDuel < 40) rank = "A";
        else if (this.highestComboThisDuel >= 5 && this.damageTakenThisDuel < 60) rank = "B";

        // Update local storage save statistics
        saveManager.updateStats({
            exercises: this.spellsCompleted,
            damageTaken: this.damageTakenThisDuel,
            calories: calories,
            highestCombo: this.highestComboThisDuel
        });

        // Save unlocked state
        saveManager.completeLevel(bossId);

        // Task 5: Victory XP bonus (+100 XP)
        const baseVictoryXp = this.spellsCompleted * 15;
        const finalVictoryXp = baseVictoryXp + 100;
        saveManager.addXP(finalVictoryXp);

        // Sync state variables with save file
        this.playerLevel = saveManager.currentData.level;
        this.playerXp = saveManager.currentData.xp;
        this.playerXpNeeded = saveManager.currentData.xpNeeded;

        return {
            xpGained: finalVictoryXp,
            accuracy: accuracy,
            spellsCompleted: this.spellsCompleted,
            damageTaken: this.damageTakenThisDuel,
            highestStreak: this.highestComboThisDuel,
            calories: calories,
            rank: rank
        };
    }
}

export const combatManager = new CombatManager();
export default combatManager;