/**
 * WORKER CREATURES SYSTEM
 * Specialized creature workers with unique abilities
 */
class WorkerCreaturesSystem {
    constructor(scene) {
        this.scene = scene;
        this.enabled = true;

        // Worker creatures
        this.workers = new Map();

        // Creature types
        this.creatureTypes = new Map();

        // Active tasks
        this.activeTasks = [];

        this.init();
        console.log('✅ Worker Creatures System initialized');
    }

    init() {
        this.defineCreatureTypes();
        console.log('🦌 Worker creatures ready');
    }

    // ========== CREATURE TYPES ==========

    defineCreatureTypes() {
        // Donkey - Transport specialist
        this.defineCreature('donkey', {
            name: 'Donkey',
            specialty: 'transport',
            efficiency: 0.8,
            abilities: ['carry_items', 'cart_transport', 'long_distance'],
            carryCapacity: 50,
            speed: 1.2,
            tamingDifficulty: 'easy',
            cost: { carrot: 10, apple: 5 }
        });

        // Bigfoot - Forest gathering specialist
        this.defineCreature('bigfoot', {
            name: 'Bigfoot',
            specialty: 'gathering',
            efficiency: 1.0,
            abilities: ['tree_chopping', 'berry_picking', 'mushroom_finding', 'forest_navigation'],
            gatherBonus: 1.5,
            speed: 0.9,
            tamingDifficulty: 'medium',
            cost: { honey: 5, berries: 20 }
        });

        // Yeti - Snow biome specialist
        this.defineCreature('yeti', {
            name: 'Yeti',
            specialty: 'snow_tasks',
            efficiency: 1.2,
            abilities: ['ice_mining', 'snow_clearing', 'cold_resistance', 'ice_fishing'],
            coldBonus: 2.0,
            speed: 0.8,
            tamingDifficulty: 'hard',
            cost: { frozen_meat: 10, ice_crystal: 3 }
        });

        // Elf - Crafting specialist
        this.defineCreature('elf', {
            name: 'Elf',
            specialty: 'crafting',
            efficiency: 1.5,
            abilities: ['auto_craft', 'enchanting', 'potion_making', 'tool_repair'],
            craftingSpeed: 2.0,
            speed: 1.0,
            tamingDifficulty: 'hard',
            cost: { magic_dust: 5, golden_apple: 2 }
        });

        // Gnome - Mining specialist
        this.defineCreature('gnome', {
            name: 'Gnome',
            specialty: 'mining',
            efficiency: 1.3,
            abilities: ['ore_detection', 'tunnel_digging', 'gem_finding', 'cave_navigation'],
            miningBonus: 1.8,
            speed: 0.7,
            tamingDifficulty: 'medium',
            cost: { gold_nugget: 5, diamond: 1 }
        });

        // Fairy - Plant care specialist
        this.defineCreature('fairy', {
            name: 'Fairy',
            specialty: 'plant_care',
            efficiency: 1.4,
            abilities: ['instant_growth', 'disease_cure', 'crop_blessing', 'flower_magic'],
            growthBonus: 2.5,
            speed: 1.5,
            tamingDifficulty: 'very_hard',
            cost: { rainbow_flower: 3, fairy_dust: 10 }
        });

        // Golem - Heavy labor specialist
        this.defineCreature('golem', {
            name: 'Golem',
            specialty: 'heavy_labor',
            efficiency: 0.9,
            abilities: ['boulder_moving', 'building_construction', 'land_clearing', 'defense'],
            strengthBonus: 3.0,
            speed: 0.5,
            tamingDifficulty: 'very_hard',
            cost: { stone: 100, iron: 50, magic_core: 1 }
        });

        // Dragon - Ultimate worker
        this.defineCreature('dragon', {
            name: 'Dragon',
            specialty: 'all',
            efficiency: 2.0,
            abilities: ['flight', 'fire_breath', 'treasure_finding', 'all_tasks'],
            allBonus: 2.0,
            speed: 2.0,
            tamingDifficulty: 'legendary',
            cost: { dragon_egg: 1, legendary_meat: 10, gold: 1000 }
        });
    }

    defineCreature(id, data) {
        this.creatureTypes.set(id, {
            id,
            ...data
        });
    }

    // ========== TAMING ==========

    canTame(creatureType) {
        const creature = this.creatureTypes.get(creatureType);
        if (!creature) return false;

        // Check if player has required items
        if (!this.scene.inventorySystem) return false;

        for (const [item, amount] of Object.entries(creature.cost)) {
            const has = this.scene.inventorySystem.getItemCount(item);
            if (has < amount) {
                console.log(`❌ Missing ${item}: ${has}/${amount}`);
                return false;
            }
        }

        return true;
    }

    tameCreature(creatureType, x, y) {
        if (!this.canTame(creatureType)) return false;

        const creatureData = this.creatureTypes.get(creatureType);

        // Consume taming items
        for (const [item, amount] of Object.entries(creatureData.cost)) {
            this.scene.inventorySystem.removeItem(item, amount);
        }

        // Create worker
        const worker = {
            id: `worker_${creatureType}_${Date.now()}`,
            type: creatureType,
            name: creatureData.name,
            specialty: creatureData.specialty,
            efficiency: creatureData.efficiency,
            abilities: creatureData.abilities,
            x, y,
            currentTask: null,
            level: 1,
            xp: 0,
            loyalty: 50,
            sprite: null
        };

        this.workers.set(worker.id, worker);

        // Notify automation tier system
        if (this.scene.automationTiers) {
            this.scene.automationTiers.befriendCreature();
        }

        // Visual effect
        if (this.scene.visualEnhancements) {
            this.scene.visualEnhancements.createSparkleEffect(x, y);
            this.scene.visualEnhancements.screenFlash(0x00ff00, 500);
        }

        console.log(`✅ Tamed ${creatureData.name}!`);
        return worker;
    }

    // ========== TASK ASSIGNMENT ==========

    assignTask(workerId, task) {
        const worker = this.workers.get(workerId);
        if (!worker) return false;

        const creatureData = this.creatureTypes.get(worker.type);

        // Check if creature can do this task
        if (!this.canDoTask(worker, task)) {
            console.log(`❌ ${worker.name} cannot do ${task.type}`);
            return false;
        }

        // Assign task
        worker.currentTask = {
            ...task,
            startTime: Date.now(),
            efficiency: this.calculateEfficiency(worker, task)
        };

        console.log(`📋 ${worker.name} assigned to ${task.type}`);
        return true;
    }

    canDoTask(worker, task) {
        const creatureData = this.creatureTypes.get(worker.type);

        // Dragons can do everything
        if (worker.type === 'dragon') return true;

        // Check specialty
        const taskSpecialties = {
            'transport': ['donkey'],
            'gather_wood': ['bigfoot'],
            'gather_berries': ['bigfoot'],
            'mine_ice': ['yeti'],
            'ice_fishing': ['yeti'],
            'craft_item': ['elf'],
            'enchant_item': ['elf'],
            'mine_ore': ['gnome'],
            'find_gems': ['gnome'],
            'water_crops': ['fairy'],
            'grow_crops': ['fairy'],
            'build': ['golem'],
            'clear_land': ['golem']
        };

        const validTypes = taskSpecialties[task.type] || [];
        return validTypes.includes(worker.type);
    }

    calculateEfficiency(worker, task) {
        const creatureData = this.creatureTypes.get(worker.type);
        let efficiency = creatureData.efficiency;

        // Apply specialty bonuses
        if (task.type.includes('gather') && creatureData.gatherBonus) {
            efficiency *= creatureData.gatherBonus;
        }
        if (task.type.includes('mine') && creatureData.miningBonus) {
            efficiency *= creatureData.miningBonus;
        }
        if (task.type.includes('craft') && creatureData.craftingSpeed) {
            efficiency *= creatureData.craftingSpeed;
        }
        if (task.type.includes('grow') && creatureData.growthBonus) {
            efficiency *= creatureData.growthBonus;
        }

        // Apply level bonus
        efficiency *= (1 + worker.level * 0.1);

        return efficiency;
    }

    // ========== TASK EXECUTION ==========

    updateWorkers(delta) {
        for (const worker of this.workers.values()) {
            if (!worker.currentTask) continue;

            const elapsed = Date.now() - worker.currentTask.startTime;
            const taskTime = worker.currentTask.duration / worker.currentTask.efficiency;

            if (elapsed >= taskTime) {
                this.completeTask(worker);
            }
        }
    }

    completeTask(worker) {
        const task = worker.currentTask;

        // Execute task
        this.executeTask(worker, task);

        // Grant XP
        this.addWorkerXP(worker, task.xp || 10);

        // Increase loyalty
        worker.loyalty = Math.min(100, worker.loyalty + 1);

        // Clear task
        worker.currentTask = null;

        console.log(`✅ ${worker.name} completed ${task.type}!`);
    }

    executeTask(worker, task) {
        switch (task.type) {
            case 'transport':
                this.transportItems(worker, task);
                break;
            case 'gather_wood':
                this.gatherResource(worker, 'wood', task.amount);
                break;
            case 'gather_berries':
                this.gatherResource(worker, 'berries', task.amount);
                break;
            case 'mine_ore':
                this.gatherResource(worker, 'ore', task.amount);
                break;
            case 'craft_item':
                this.craftItem(worker, task.item);
                break;
            case 'grow_crops':
                this.growCrops(worker, task.crops);
                break;
            default:
                console.log(`Unknown task: ${task.type}`);
        }
    }

    transportItems(worker, task) {
        // Move items from A to B
        console.log(`🚚 ${worker.name} transported items`);
    }

    gatherResource(worker, resource, amount) {
        // Add resource to inventory
        if (this.scene.inventorySystem) {
            const bonus = this.workers.get(worker.id).currentTask.efficiency;
            const finalAmount = Math.floor(amount * bonus);
            this.scene.inventorySystem.addItem(resource, finalAmount);
            console.log(`📦 Gathered ${finalAmount} ${resource}`);
        }
    }

    craftItem(worker, item) {
        // Craft item
        if (this.scene.inventorySystem) {
            this.scene.inventorySystem.addItem(item, 1);
            console.log(`🔨 Crafted ${item}`);
        }
    }

    growCrops(worker, crops) {
        // Instantly grow crops
        console.log(`🌱 Grew ${crops.length} crops`);
    }

    // ========== LEVELING ==========

    addWorkerXP(worker, amount) {
        worker.xp += amount;

        const xpNeeded = this.getXPForLevel(worker.level + 1);
        if (worker.xp >= xpNeeded) {
            this.levelUpWorker(worker);
        }
    }

    getXPForLevel(level) {
        return Math.floor(100 * Math.pow(1.5, level - 1));
    }

    levelUpWorker(worker) {
        worker.level++;
        worker.xp = 0;

        console.log(`🎉 ${worker.name} leveled up to ${worker.level}!`);

        // Visual effect
        if (this.scene.visualEnhancements) {
            this.scene.visualEnhancements.createSparkleEffect(worker.x, worker.y);
        }
    }

    // ========== SPECIAL ABILITIES ==========

    useAbility(workerId, abilityName) {
        const worker = this.workers.get(workerId);
        if (!worker) return false;

        const creatureData = this.creatureTypes.get(worker.type);
        if (!creatureData.abilities.includes(abilityName)) {
            console.log(`❌ ${worker.name} doesn't have ${abilityName}`);
            return false;
        }

        // Execute ability
        switch (abilityName) {
            case 'instant_growth':
                this.instantGrowth(worker);
                break;
            case 'fire_breath':
                this.fireBreath(worker);
                break;
            case 'treasure_finding':
                this.findTreasure(worker);
                break;
            default:
                console.log(`✨ ${worker.name} used ${abilityName}!`);
        }

        return true;
    }

    instantGrowth(worker) {
        // Fairy ability - instantly grow all nearby crops
        console.log('🌸 Fairy magic! All crops instantly grown!');
    }

    fireBreath(worker) {
        // Dragon ability - clear area with fire
        console.log('🔥 Dragon fire breath!');
    }

    findTreasure(worker) {
        // Dragon ability - find hidden treasure
        console.log('💎 Found treasure!');
        if (this.scene.inventorySystem) {
            this.scene.inventorySystem.addItem('gold', 100);
        }
    }

    // ========== UPDATE ==========

    update(delta) {
        this.updateWorkers(delta);
    }

    destroy() {
        console.log('🦌 Worker Creatures System destroyed');
    }
}