/**
 * GiantTrollKingBoss.js
 * =====================
 * KRVAVA ŽETEV - Giant Troll King Boss (Phase 43)
 * 
 * Features:
 * - Epic 3-phase boss fight
 * - Special attacks (club smash, roar, ground pound)
 * - Weak points (head, legs)
 * - Environmental hazards
 * - Legendary loot
 * 
 * @author NovaFarma Team
 * @date 2025-12-23
 */

export default class GiantTrollKingBoss {
    constructor(scene) {
        this.scene = scene;

        // Boss state
        this.isActive = false;
        this.currentPhase = 1;
        this.health = 0;
        this.maxHealth = 10000;

        // Boss stats
        this.stats = {
            damage: 100,
            defense: 50,
            speed: 60,
            attackCooldown: 3000
        };

        // Attack patterns
        this.attacks = new Map();
        this.lastAttack = 0;

        // Weak points
        this.weakPoints = {
            head: { multiplier: 2.0, exposed: false },
            leftLeg: { multiplier: 1.5, exposed: true },
            rightLeg: { multiplier: 1.5, exposed: true }
        };

        console.log('👹 GiantTrollKingBoss initialized');

        // Register attacks
        this.registerAttacks();
    }

    /**
     * Register boss attacks
     */
    registerAttacks() {
        // PHASE 1 ATTACKS
        this.attacks.set('club_smash', {
            name: 'Club Smash',
            phase: 1,
            damage: 150,
            range: 200,
            cooldown: 4000,
            description: 'Smashes giant club on ground, AoE damage',
            animation: 'troll_club_smash'
        });

        this.attacks.set('roar', {
            name: 'Intimidating Roar',
            phase: 1,
            damage: 0,
            range: 300,
            cooldown: 8000,
            effect: 'fear', // Stun player for 2 seconds
            description: 'Roars loudly, stunning nearby enemies',
            animation: 'troll_roar'
        });

        // PHASE 2 ATTACKS (Below 66% HP)
        this.attacks.set('ground_pound', {
            name: 'Ground Pound',
            phase: 2,
            damage: 200,
            range: 400,
            cooldown: 5000,
            effect: 'knockback',
            description: 'Jumps and pounds ground, massive AoE',
            animation: 'troll_ground_pound'
        });

        this.attacks.set('rock_throw', {
            name: 'Rock Throw',
            phase: 2,
            damage: 100,
            range: 600,
            cooldown: 6000,
            description: 'Throws massive boulder at player',
            animation: 'troll_throw'
        });

        // PHASE 3 ATTACKS (Below 33% HP - ENRAGED!)
        this.attacks.set('berserk_combo', {
            name: 'Berserk Combo',
            phase: 3,
            damage: 250,
            range: 250,
            cooldown: 3000,
            hits: 3,
            description: 'Rapid 3-hit combo attack',
            animation: 'troll_berserk'
        });

        this.attacks.set('earthquake', {
            name: 'Earthquake Slam',
            phase: 3,
            damage: 300,
            range: 800,
            cooldown: 10000,
            effect: 'earthquake',
            description: 'Causes screen-wide earthquake damage',
            animation: 'troll_earthquake'
        });

        console.log(`✅ Registered ${this.attacks.size} boss attacks`);
    }

    /**
     * Start boss fight
     */
    startFight() {
        this.isActive = true;
        this.currentPhase = 1;
        this.health = this.maxHealth;
        this.lastAttack = Date.now();

        console.log('👹 GIANT TROLL KING BOSS FIGHT STARTED!');

        // Boss intro
        this.playIntro();

        // Start boss music
        // TODO: Play epic boss music

        this.showNotification({
            title: 'BOSS FIGHT!',
            text: '👹 GIANT TROLL KING has awakened!',
            icon: '⚔️'
        });

        // Lock arena exits
        if (this.scene.bossArenaSystem) {
            this.scene.bossArenaSystem.startBossFight('giant_troll_king');
        }
    }

    /**
     * Play boss intro cutscene
     */
    playIntro() {
        console.log('🎬 Boss intro cutscene:');
        console.log('   Troll King roars!');
        console.log('   Ground shakes!');
        console.log('   Camera zoom to boss!');

        // Screen shake
        this.scene.cameras.main.shake(2000, 0.02);

        // TODO: Actual cutscene
    }

    /**
     * Take damage
     */
    takeDamage(amount, hitLocation = 'body') {
        if (!this.isActive) return;

        // Apply weak point multiplier
        const weakPoint = this.weakPoints[hitLocation];
        let finalDamage = amount;

        if (weakPoint && weakPoint.exposed) {
            finalDamage *= weakPoint.multiplier;
            console.log(`💥 WEAK POINT HIT! ${finalDamage} damage (${weakPoint.multiplier}x)`);

            this.showNotification({
                title: 'WEAK POINT!',
                text: `Critical hit! ${finalDamage} damage!`,
                icon: '💥'
            });
        }

        this.health -= finalDamage;

        console.log(`👹 Troll King HP: ${this.health}/${this.maxHealth}`);

        // Check phase transitions
        this.checkPhaseTransition();

        // Check defeat
        if (this.health <= 0) {
            this.defeat();
        }
    }

    /**
     * Check phase transition
     */
    checkPhaseTransition() {
        const healthPercent = (this.health / this.maxHealth) * 100;

        if (healthPercent <= 33 && this.currentPhase < 3) {
            this.enterPhase3();
        } else if (healthPercent <= 66 && this.currentPhase < 2) {
            this.enterPhase2();
        }
    }

    /**
     * Enter Phase 2
     */
    enterPhase2() {
        this.currentPhase = 2;

        console.log('👹 PHASE 2: ENRAGED!');

        // Troll gets angrier, faster
        this.stats.speed = 80;
        this.stats.attackCooldown = 2500;

        // Screen effects
        this.scene.cameras.main.shake(1000, 0.015);
        this.scene.cameras.main.flash(500, 255, 0, 0); // Red flash

        this.showNotification({
            title: 'PHASE 2!',
            text: '👹 Troll King is ENRAGED!',
            icon: '🔥'
        });
    }

    /**
     * Enter Phase 3
     */
    enterPhase3() {
        this.currentPhase = 3;

        console.log('👹 PHASE 3: BERSERK MODE!');

        // Troll goes berserk!
        this.stats.speed = 100;
        this.stats.damage = 150;
        this.stats.attackCooldown = 2000;

        // Expose head weak point
        this.weakPoints.head.exposed = true;

        // Massive screen effects
        this.scene.cameras.main.shake(2000, 0.03);
        this.scene.cameras.main.flash(1000, 255, 0, 0);

        this.showNotification({
            title: 'PHASE 3: BERSERK!',
            text: '👹 FINAL PHASE! Head weak point exposed!',
            icon: '💀'
        });
    }

    /**
     * Execute boss attack
     */
    executeAttack() {
        if (!this.isActive) return;

        const now = Date.now();
        if (now - this.lastAttack < this.stats.attackCooldown) return;

        // Get available attacks for current phase
        const availableAttacks = Array.from(this.attacks.values())
            .filter(attack => attack.phase <= this.currentPhase);

        if (availableAttacks.length === 0) return;

        // Pick random attack
        const attack = Phaser.Utils.Array.GetRandom(availableAttacks);

        console.log(`👹 TROLL KING: ${attack.name}!`);

        // Play attack animation
        this.playAttackAnimation(attack);

        // Deal damage
        // TODO: Integrate with actual combat system

        this.lastAttack = now;
    }

    /**
     * Play attack animation
     */
    playAttackAnimation(attack) {
        console.log(`   💥 ${attack.description}`);

        // Special effects based on attack
        switch (attack.animation) {
            case 'troll_club_smash':
                this.scene.cameras.main.shake(500, 0.02);
                break;
            case 'troll_ground_pound':
                this.scene.cameras.main.shake(1000, 0.03);
                break;
            case 'troll_earthquake':
                this.scene.cameras.main.shake(3000, 0.05);
                break;
        }
    }

    /**
     * Boss defeated
     */
    defeat() {
        this.isActive = false;
        this.health = 0;

        console.log('👹 GIANT TROLL KING DEFEATED!');

        // Victory cutscene
        this.playDefeatCutscene();

        // Unlock arena exits
        if (this.scene.bossArenaSystem) {
            this.scene.bossArenaSystem.endBossFight(true);
        }

        // Grant rewards
        this.grantRewards();

        this.showNotification({
            title: 'VICTORY!',
            text: '👑 Giant Troll King defeated! Legendary loot acquired!',
            icon: '🏆'
        });
    }

    /**
     * Play defeat cutscene
     */
    playDefeatCutscene() {
        console.log('🎬 Defeat cutscene:');
        console.log('   Troll King falls to knees');
        console.log('   Final roar');
        console.log('   Boss dies, drops loot');

        // Epic camera effects
        this.scene.cameras.main.shake(3000, 0.04);
        this.scene.cameras.main.flash(2000, 255, 215, 0); // Golden flash
    }

    /**
     * Grant boss rewards
     */
    grantRewards() {
        const rewards = {
            zlatniki: 10000,
            xp: 50000,
            items: [
                { id: 'troll_king_trophy', name: 'Troll King Trophy', rarity: 'legendary' },
                { id: 'troll_club', name: 'Giant Troll Club', rarity: 'legendary', damage: 500 },
                { id: 'troll_hide', name: 'Troll King Hide', rarity: 'rare', quantity: 10 },
                { id: 'troll_tooth', name: 'Troll Tooth', rarity: 'uncommon', quantity: 50 }
            ]
        };

        console.log('🎁 Boss rewards:', rewards);

        // TODO: Actually grant rewards to player
    }

    /**
     * Get boss info
     */
    getBossInfo() {
        return {
            name: 'Giant Troll King',
            currentPhase: this.currentPhase,
            health: this.health,
            maxHealth: this.maxHealth,
            healthPercent: (this.health / this.maxHealth * 100).toFixed(1),
            isActive: this.isActive,
            weakPoints: this.weakPoints
        };
    }

    /**
     * Update boss AI
     */
    update(delta) {
        if (!this.isActive) return;

        // Execute attacks
        this.executeAttack();

        // Update AI behavior
        // TODO: Implement actual AI (movement, targeting, etc.)
    }

    /**
     * Helper: Show notification
     */
    showNotification(notification) {
        console.log(`📢 ${notification.icon} ${notification.title}: ${notification.text}`);

        const ui = this.scene.scene.get('UIScene');
        if (ui && ui.showNotification) {
            ui.showNotification(notification);
        }
    }
}