/**
 * MesojedkeSystem.js
 * ==================
 * KRVAVA ŽETEV - Carnivorous Plants System (Phase 39)
 * 
 * Features:
 * - Mario-style carnivorous plants
 * - 5 growth stages
 * - Meat feeding system
 * - Auto-attack defense
 * - Rare material harvest
 * 
 * @author NovaFarma Team
 * @date 2025-12-23
 */

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

        // Plant registry
        this.plants = new Map();
        this.nextPlantId = 1;

        // Growth stages
        this.growthStages = [
            { stage: 1, name: 'Seed', size: 0.2, damage: 0, range: 0, icon: '🌱' },
            { stage: 2, name: 'Sprout', size: 0.4, damage: 0, range: 0, icon: '🌿' },
            { stage: 3, name: 'Young Plant', size: 0.6, damage: 10, range: 100, icon: '🪴' },
            { stage: 4, name: 'Adult Plant', size: 0.8, damage: 25, range: 150, icon: '🌺' },
            { stage: 5, name: 'Giant Carnivorous Flower', size: 1.5, damage: 50, range: 200, icon: '🌸' }
        ];

        // Meat types for feeding
        this.meatTypes = {
            zombie_flesh: { nutrition: 10, growthBoost: 1.0, quality: 'common' },
            mutant_meat: { nutrition: 25, growthBoost: 1.5, quality: 'uncommon' },
            boss_meat: { nutrition: 50, growthBoost: 2.0, quality: 'rare' },
            legendary_meat: { nutrition: 100, growthBoost: 3.0, quality: 'legendary' }
        };

        console.log('🌺 MesojedkeSystem initialized');
    }

    /**
     * Plant mesojedka seed
     */
    plantSeed(x, y) {
        const plantId = `mesojedka_${this.nextPlantId++}`;

        const plant = {
            id: plantId,
            x: x,
            y: y,
            stage: 1,
            growth: 0, // 0-100% per stage
            hunger: 100, // Needs meat to grow
            lastFed: Date.now(),
            lastAttack: 0,
            attackCooldown: 2000, // 2 seconds
            kills: 0,
            totalDamage: 0,
            sprite: null
        };

        this.plants.set(plantId, plant);

        // TODO: Create actual sprite
        console.log(`🌱 Planted mesojedka at (${x}, ${y})`);

        this.showNotification({
            title: 'Mesojedka Planted!',
            text: '🌱 Feed it meat to make it grow!',
            icon: '🌺'
        });

        return plantId;
    }

    /**
     * Feed plant with meat
     */
    feedPlant(plantId, meatType) {
        const plant = this.plants.get(plantId);
        if (!plant) {
            console.error(`Plant ${plantId} not found!`);
            return false;
        }

        const meat = this.meatTypes[meatType];
        if (!meat) {
            console.error(`Meat type ${meatType} not found!`);
            return false;
        }

        // Restore hunger
        plant.hunger = Math.min(100, plant.hunger + meat.nutrition);
        plant.lastFed = Date.now();

        // Boost growth
        const growthGain = 10 * meat.growthBoost;
        plant.growth += growthGain;

        console.log(`🍖 Fed ${plantId} with ${meatType} (+${growthGain}% growth)`);

        // Check for stage up
        if (plant.growth >= 100) {
            this.growPlant(plantId);
        }

        this.showNotification({
            title: 'Plant Fed!',
            text: `🍖 ${meat.quality} meat! +${Math.floor(growthGain)}% growth!`,
            icon: '🌺'
        });

        return true;
    }

    /**
     * Grow plant to next stage
     */
    growPlant(plantId) {
        const plant = this.plants.get(plantId);
        if (!plant) return false;

        if (plant.stage >= 5) {
            console.log(`🌸 ${plantId} already at max stage!`);
            return false;
        }

        // Level up
        plant.stage++;
        plant.growth = 0;

        const stageData = this.growthStages[plant.stage - 1];

        console.log(`🌺 ${plantId} grew to stage ${plant.stage}: ${stageData.name}!`);

        // Update sprite size
        if (plant.sprite) {
            plant.sprite.setScale(stageData.size);
        }

        this.showNotification({
            title: 'Plant Evolved!',
            text: `${stageData.icon} Stage ${plant.stage}: ${stageData.name}!`,
            icon: '✨'
        });

        // Unlock attack at stage 3
        if (plant.stage === 3) {
            this.showNotification({
                title: 'Defense Unlocked!',
                text: '⚔️ Mesojedka can now attack enemies!',
                icon: '🌺'
            });
        }

        // Giant flower achievement
        if (plant.stage === 5) {
            this.showNotification({
                title: 'GIANT CARNIVOROUS FLOWER!',
                text: '🌸 Maximum power achieved! 50 damage, 200 range!',
                icon: '👑'
            });
        }

        return true;
    }

    /**
     * Auto-attack enemies
     */
    attackNearbyEnemies(plantId) {
        const plant = this.plants.get(plantId);
        if (!plant) return;

        const stageData = this.growthStages[plant.stage - 1];

        // Can't attack if too young
        if (plant.stage < 3) return;

        // Check cooldown
        const now = Date.now();
        if (now - plant.lastAttack < plant.attackCooldown) return;

        // TODO: Get enemies within range
        const enemies = this.getEnemiesInRange(plant.x, plant.y, stageData.range);

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

        // Attack nearest enemy
        const target = enemies[0];
        const damage = stageData.damage;

        console.log(`🌺 ${plantId} attacks! ${damage} damage!`);

        // Deal damage
        // TODO: Integrate with enemy system
        plant.totalDamage += damage;

        // Check for kill
        // if (target.health <= damage) {
        //     plant.kills++;
        // }

        plant.lastAttack = now;

        // Visual attack effect
        this.playAttackAnimation(plant, target);
    }

    /**
     * Get enemies in range
     */
    getEnemiesInRange(x, y, range) {
        // TODO: Get actual enemies from enemy system
        // For now, return empty array
        return [];
    }

    /**
     * Play attack animation
     */
    playAttackAnimation(plant, target) {
        // TODO: Create bite animation
        console.log(`💥 CHOMP! Attack animation`);

        // Screen shake for giant plants
        if (plant.stage === 5) {
            this.scene.cameras.main.shake(100, 0.005);
        }
    }

    /**
     * Harvest plant
     */
    harvestPlant(plantId) {
        const plant = this.plants.get(plantId);
        if (!plant) {
            console.error(`Plant ${plantId} not found!`);
            return null;
        }

        if (plant.stage < 4) {
            this.showNotification({
                title: 'Too Young!',
                text: 'Plant must reach stage 4 to harvest!',
                icon: '🌺'
            });
            return null;
        }

        // Calculate harvest based on stage
        const harvest = this.calculateHarvest(plant);

        // Remove plant
        this.plants.delete(plantId);

        // TODO: Remove sprite

        console.log(`✂️ Harvested ${plantId}:`, harvest);

        this.showNotification({
            title: 'Harvest Complete!',
            text: `Collected: ${harvest.petals} Petals, ${harvest.seeds} Seeds!`,
            icon: '🌸'
        });

        return harvest;
    }

    /**
     * Calculate harvest rewards
     */
    calculateHarvest(plant) {
        const harvest = {
            petals: 0,
            seeds: 0,
            special: []
        };

        // Base rewards by stage
        switch (plant.stage) {
            case 4:
                harvest.petals = 5 + Math.floor(Math.random() * 5);
                harvest.seeds = 1;
                break;
            case 5:
                harvest.petals = 15 + Math.floor(Math.random() * 10);
                harvest.seeds = 2 + Math.floor(Math.random() * 2);

                // Chance for legendary drops
                if (Math.random() < 0.1) { // 10%
                    harvest.special.push('legendary_nectar');
                }
                break;
        }

        // Bonus from kills
        harvest.petals += plant.kills;

        return harvest;
    }

    /**
     * Update all plants
     */
    update(delta) {
        const now = Date.now();

        this.plants.forEach((plant, plantId) => {
            // Decrease hunger over time
            const hoursSinceLastFed = (now - plant.lastFed) / (1000 * 60 * 60);
            if (hoursSinceLastFed >= 1) {
                plant.hunger = Math.max(0, plant.hunger - 5);
                plant.lastFed = now;
            }

            // Die if starved
            if (plant.hunger <= 0) {
                this.killPlant(plantId);
                return;
            }

            // Auto-attack if enemies nearby
            this.attackNearbyEnemies(plantId);

            // Passive growth (very slow)
            if (plant.hunger > 50) {
                plant.growth += 0.001 * (delta / 1000); // 0.1% per second

                if (plant.growth >= 100) {
                    this.growPlant(plantId);
                }
            }
        });
    }

    /**
     * Kill plant (starvation)
     */
    killPlant(plantId) {
        const plant = this.plants.get(plantId);
        if (!plant) return;

        console.log(`💀 ${plantId} died from starvation!`);

        this.plants.delete(plantId);

        // TODO: Remove sprite

        this.showNotification({
            title: 'Plant Died!',
            text: '💀 Your mesojedka starved! Feed them meat regularly!',
            icon: '⚠️'
        });
    }

    /**
     * Get plant info
     */
    getPlantInfo(plantId) {
        const plant = this.plants.get(plantId);
        if (!plant) return null;

        const stageData = this.growthStages[plant.stage - 1];

        return {
            ...plant,
            stageData: stageData,
            canAttack: plant.stage >= 3,
            canHarvest: plant.stage >= 4
        };
    }

    /**
     * Get all plants
     */
    getAllPlants() {
        return Array.from(this.plants.values());
    }

    /**
     * Get plant count by stage
     */
    getPlantCountByStage(stage) {
        return Array.from(this.plants.values()).filter(p => p.stage === stage).length;
    }

    /**
     * Get total defense damage
     */
    getTotalDefenseDamage() {
        return Array.from(this.plants.values())
            .reduce((total, plant) => total + plant.totalDamage, 0);
    }

    /**
     * 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);
        }
    }
}