/**
 * Galaxy Strike Online - Server Dungeon System
 * Manages dungeon instances, encounters, and rewards
 */

class DungeonSystem {
    constructor() {
        this.dungeons = new Map();
        this.instances = new Map(); // instanceId -> dungeon instance
        this.playerInstances = new Map(); // userId -> instanceId
        
        // Initialize room templates
        this.roomTypes = {
            entrance: { name: 'Entrance', enemies: 0, rewards: false },
            corridor: { name: 'Corridor', enemies: 1, rewards: false },
            chamber: { name: 'Chamber', enemies: 2, rewards: true },
            treasure: { name: 'Treasure Room', enemies: 0, rewards: true },
            boss: { name: 'Boss Room', enemies: 1, rewards: true, isBoss: true },
            exit: { name: 'Exit', enemies: 0, rewards: false }
        };
        
        // Initialize enemy templates
        this.enemyTemplates = {
            // Original enemies
            training_drone: {
                name: 'Training Drone',
                health: 10,
                attack: 5,
                defense: 2,
                experience: 5,
                credits: 3
            },
            practice_target: {
                name: 'Practice Target',
                health: 5,
                attack: 0,
                defense: 0,
                experience: 2,
                credits: 1
            },
            alien_guardian: {
                name: 'Alien Guardian',
                health: 50,
                attack: 8,
                defense: 5,
                experience: 25,
                credits: 15
            },
            ancient_drone: {
                name: 'Ancient Drone',
                health: 30,
                attack: 12,
                defense: 2,
                experience: 20,
                credits: 10
            },
            crystal_golem: {
                name: 'Crystal Golem',
                health: 80,
                attack: 6,
                defense: 10,
                experience: 35,
                credits: 25
            },
            space_pirate: {
                name: 'Space Pirate',
                health: 25,
                attack: 10,
                defense: 3,
                experience: 15,
                credits: 12
            },
            pirate_captain: {
                name: 'Pirate Captain',
                health: 40,
                attack: 15,
                defense: 6,
                experience: 30,
                credits: 20
            },
            defense_turret: {
                name: 'Defense Turret',
                health: 20,
                attack: 18,
                defense: 8,
                experience: 18,
                credits: 8
            },
            security_drone: {
                name: 'Security Drone',
                health: 35,
                attack: 14,
                defense: 4,
                experience: 22,
                credits: 15
            },
            corrupted_ai: {
                name: 'Corrupted AI',
                health: 60,
                attack: 20,
                defense: 2,
                experience: 40,
                credits: 30
            },
            virus_program: {
                name: 'Virus Program',
                health: 15,
                attack: 25,
                defense: 1,
                experience: 20,
                credits: 12
            },
            mining_drone: {
                name: 'Mining Drone',
                health: 20,
                attack: 8,
                defense: 3,
                experience: 12,
                credits: 8
            },
            rock_creature: {
                name: 'Rock Creature',
                health: 45,
                attack: 6,
                defense: 12,
                experience: 25,
                credits: 15
            },
            explosive_asteroid: {
                name: 'Explosive Asteroid',
                health: 10,
                attack: 30,
                defense: 0,
                experience: 15,
                credits: 5
            },
            energy_being: {
                name: 'Energy Being',
                health: 55,
                attack: 22,
                defense: 3,
                experience: 45,
                credits: 35
            },
            phase_shifter: {
                name: 'Phase Shifter',
                health: 30,
                attack: 28,
                defense: 1,
                experience: 35,
                credits: 25
            },
            quantum_entity: {
                name: 'Quantum Entity',
                health: 70,
                attack: 35,
                defense: 5,
                experience: 60,
                credits: 50
            },
            
            // NEW ENEMIES - Space Theme
            maintenance_drone: {
                name: 'Maintenance Drone',
                health: 28,
                attack: 11,
                defense: 4,
                experience: 18,
                credits: 12
            },
            security_android: {
                name: 'Security Android',
                health: 42,
                attack: 16,
                defense: 7,
                experience: 28,
                credits: 20
            },
            station_ai: {
                name: 'Station AI',
                health: 65,
                attack: 24,
                defense: 3,
                experience: 45,
                credits: 32
            },
            ice_elemental: {
                name: 'Ice Elemental',
                health: 38,
                attack: 18,
                defense: 8,
                experience: 32,
                credits: 24
            },
            frost_wyrm: {
                name: 'Frost Wyrm',
                health: 72,
                attack: 26,
                defense: 6,
                experience: 52,
                credits: 38
            },
            gravity_wraith: {
                name: 'Gravity Wraith',
                health: 85,
                attack: 32,
                defense: 4,
                experience: 68,
                credits: 48
            },
            void_stalker: {
                name: 'Void Stalker',
                health: 78,
                attack: 38,
                defense: 5,
                experience: 72,
                credits: 52
            },
            singularity_spawn: {
                name: 'Singularity Spawn',
                health: 95,
                attack: 42,
                defense: 8,
                experience: 85,
                credits: 65
            },
            plasma_elemental: {
                name: 'Plasma Elemental',
                health: 58,
                attack: 28,
                defense: 4,
                experience: 48,
                credits: 35
            },
            solar_guardian: {
                name: 'Solar Guardian',
                health: 82,
                attack: 34,
                defense: 7,
                experience: 65,
                credits: 48
            },
            fusion_core: {
                name: 'Fusion Core',
                health: 68,
                attack: 30,
                defense: 12,
                experience: 58,
                credits: 42
            },
            scrap_golem: {
                name: 'Scrap Golem',
                health: 35,
                attack: 14,
                defense: 9,
                experience: 22,
                credits: 16
            },
            hull_breacher: {
                name: 'Hull Breacher',
                health: 32,
                attack: 20,
                defense: 3,
                experience: 26,
                credits: 18
            },
            salage_drone: {
                name: 'Salvage Drone',
                health: 22,
                attack: 12,
                defense: 5,
                experience: 16,
                credits: 11
            },
            
            // NEW ENEMIES - Planet Theme
            plant_beast: {
                name: 'Plant Beast',
                health: 48,
                attack: 15,
                defense: 8,
                experience: 35,
                credits: 26
            },
            tribal_warrior: {
                name: 'Tribal Warrior',
                health: 38,
                attack: 18,
                defense: 6,
                experience: 28,
                credits: 20
            },
            jungle_spirit: {
                name: 'Jungle Spirit',
                health: 55,
                attack: 22,
                defense: 4,
                experience: 42,
                credits: 30
            },
            sand_worm: {
                name: 'Sand Worm',
                health: 75,
                attack: 28,
                defense: 9,
                experience: 58,
                credits: 42
            },
            mummy_guardian: {
                name: 'Mummy Guardian',
                health: 62,
                attack: 24,
                defense: 7,
                experience: 48,
                credits: 35
            },
            heat_elemental: {
                name: 'Heat Elemental',
                health: 52,
                attack: 26,
                defense: 3,
                experience: 45,
                credits: 32
            },
            lava_elemental: {
                name: 'Lava Elemental',
                health: 68,
                attack: 30,
                defense: 5,
                experience: 55,
                credits: 40
            },
            fire_demon: {
                name: 'Fire Demon',
                health: 72,
                attack: 32,
                defense: 6,
                experience: 62,
                credits: 45
            },
            magma_beast: {
                name: 'Magma Beast',
                health: 85,
                attack: 28,
                defense: 12,
                experience: 68,
                credits: 50
            },
            cryo_mutant: {
                name: 'Cryo Mutant',
                health: 45,
                attack: 20,
                defense: 7,
                experience: 38,
                credits: 28
            },
            frost_android: {
                name: 'Frost Android',
                health: 52,
                attack: 22,
                defense: 8,
                experience: 42,
                credits: 30
            },
            ice_wraith: {
                name: 'Ice Wraith',
                health: 58,
                attack: 25,
                defense: 4,
                experience: 48,
                credits: 35
            },
            swamp_beast: {
                name: 'Swamp Beast',
                health: 35,
                attack: 16,
                defense: 9,
                experience: 24,
                credits: 18
            },
            toxic_spitter: {
                name: 'Toxic Spitter',
                health: 28,
                attack: 19,
                defense: 3,
                experience: 22,
                credits: 16
            },
            mud_golem: {
                name: 'Mud Golem',
                health: 42,
                attack: 12,
                defense: 11,
                experience: 26,
                credits: 19
            },
            
            // NEW ENEMIES - Technology Theme
            glitch_wraith: {
                name: 'Glitch Wraith',
                health: 48,
                attack: 26,
                defense: 2,
                experience: 45,
                credits: 32
            },
            firewall_guardian: {
                name: 'Firewall Guardian',
                health: 65,
                attack: 22,
                defense: 8,
                experience: 52,
                credits: 38
            },
            data_vampire: {
                name: 'Data Vampire',
                health: 38,
                attack: 30,
                defense: 3,
                experience: 35,
                credits: 26
            },
            assembly_drone: {
                name: 'Assembly Drone',
                health: 32,
                attack: 15,
                defense: 6,
                experience: 24,
                credits: 17
            },
            welder_bot: {
                name: 'Welder Bot',
                health: 28,
                attack: 20,
                defense: 4,
                experience: 22,
                credits: 15
            },
            factory_overseer: {
                name: 'Factory Overseer',
                health: 58,
                attack: 24,
                defense: 7,
                experience: 46,
                credits: 33
            },
            quantum_phantom: {
                name: 'Quantum Phantom',
                health: 78,
                attack: 35,
                defense: 4,
                experience: 68,
                credits: 50
            },
            particle_accelerator: {
                name: 'Particle Accelerator',
                health: 92,
                attack: 40,
                defense: 6,
                experience: 85,
                credits: 62
            },
            reality_bender: {
                name: 'Reality Bender',
                health: 88,
                attack: 45,
                defense: 3,
                experience: 92,
                credits: 68
            },
            sentinel_program: {
                name: 'Sentinel Program',
                health: 42,
                attack: 21,
                defense: 8,
                experience: 32,
                credits: 24
            },
            data_corruptor: {
                name: 'Data Corruptor',
                health: 35,
                attack: 25,
                defense: 3,
                experience: 28,
                credits: 20
            },
            system_guardian: {
                name: 'System Guardian',
                health: 55,
                attack: 23,
                defense: 9,
                experience: 42,
                credits: 30
            },
            
            // NEW ENEMIES - Biome/Elemental Theme
            shard_elemental: {
                name: 'Shard Elemental',
                health: 45,
                attack: 19,
                defense: 10,
                experience: 38,
                credits: 28
            },
            resonance_beast: {
                name: 'Resonance Beast',
                health: 52,
                attack: 22,
                defense: 6,
                experience: 42,
                credits: 30
            },
            mutant_horror: {
                name: 'Mutant Horror',
                health: 68,
                attack: 28,
                defense: 5,
                experience: 58,
                credits: 42
            },
            toxic_slime: {
                name: 'Toxic Slime',
                health: 42,
                attack: 18,
                defense: 8,
                experience: 32,
                credits: 24
            },
            radiation_beast: {
                name: 'Radiation Beast',
                health: 75,
                attack: 30,
                defense: 4,
                experience: 65,
                credits: 48
            },
            shadow_demon: {
                name: 'Shadow Demon',
                health: 72,
                attack: 34,
                defense: 3,
                experience: 68,
                credits: 50
            },
            nightmare_stalker: {
                name: 'Nightmare Stalker',
                health: 85,
                attack: 38,
                defense: 5,
                experience: 78,
                credits: 58
            },
            void_walker: {
                name: 'Void Walker',
                health: 92,
                attack: 42,
                defense: 7,
                experience: 88,
                credits: 65
            },
            temporal_paradox: {
                name: 'Temporal Paradox',
                health: 78,
                attack: 40,
                defense: 4,
                experience: 75,
                credits: 55
            },
            future_soldier: {
                name: 'Future Soldier',
                health: 65,
                attack: 32,
                defense: 9,
                experience: 58,
                credits: 42
            },
            past_guardian: {
                name: 'Past Guardian',
                health: 70,
                attack: 28,
                defense: 12,
                experience: 62,
                credits: 45
            },
            
            // NEW ENEMIES - Military/War Theme
            enemy_soldier: {
                name: 'Enemy Soldier',
                health: 45,
                attack: 20,
                defense: 7,
                experience: 35,
                credits: 26
            },
            combat_drone: {
                name: 'Combat Drone',
                health: 38,
                attack: 22,
                defense: 5,
                experience: 30,
                credits: 22
            },
            field_commander: {
                name: 'Field Commander',
                health: 62,
                attack: 28,
                defense: 9,
                experience: 52,
                credits: 38
            },
            turret_system: {
                name: 'Turret System',
                health: 48,
                attack: 26,
                defense: 10,
                experience: 38,
                credits: 28
            },
            combat_android: {
                name: 'Combat Android',
                health: 55,
                attack: 24,
                defense: 8,
                experience: 45,
                credits: 33
            },
            base_commander: {
                name: 'Base Commander',
                health: 72,
                attack: 30,
                defense: 11,
                experience: 62,
                credits: 45
            },
            weapon_drone: {
                name: 'Weapon Drone',
                health: 42,
                attack: 28,
                defense: 4,
                experience: 38,
                credits: 28
            },
            test_subject: {
                name: 'Test Subject',
                health: 58,
                attack: 25,
                defense: 6,
                experience: 48,
                credits: 35
            },
            chief_scientist: {
                name: 'Chief Scientist',
                health: 35,
                attack: 32,
                defense: 3,
                experience: 42,
                credits: 30
            },
            
            // NEW ENEMIES - Special/Unique Theme
            nightmare_creature: {
                name: 'Nightmare Creature',
                health: 62,
                attack: 28,
                defense: 5,
                experience: 55,
                credits: 40
            },
            dream_guardian: {
                name: 'Dream Guardian',
                health: 68,
                attack: 30,
                defense: 8,
                experience: 58,
                credits: 42
            },
            subconscious_demon: {
                name: 'Subconscious Demon',
                health: 75,
                attack: 34,
                defense: 4,
                experience: 68,
                credits: 50
            },
            memory_fragment: {
                name: 'Memory Fragment',
                health: 48,
                attack: 26,
                defense: 6,
                experience: 45,
                credits: 33
            },
            forgetfulness_demon: {
                name: 'Forgetfulness Demon',
                health: 55,
                attack: 30,
                defense: 3,
                experience: 48,
                credits: 35
            },
            nostalgia_spirit: {
                name: 'Nostalgia Spirit',
                health: 52,
                attack: 24,
                defense: 9,
                experience: 42,
                credits: 30
            },
            rift_demon: {
                name: 'Rift Demon',
                health: 88,
                attack: 44,
                defense: 5,
                experience: 92,
                credits: 68
            },
            dimensional_hunter: {
                name: 'Dimensional Hunter',
                health: 95,
                attack: 48,
                defense: 8,
                experience: 105,
                credits: 78
            },
            reality_tear: {
                name: 'Reality Tear',
                health: 102,
                attack: 52,
                defense: 3,
                experience: 115,
                credits: 85
            }
        };
        
        this.initializeDungeons();
    }
    
    initializeDungeons() {
        // Tutorial Dungeon
        this.addDungeon('tutorial', {
            name: 'Tutorial Dungeon',
            description: 'Learn the basics of dungeon exploration in this guided tutorial',
            difficulty: 'tutorial',
            enemyTypes: ['training_drone', 'practice_target'],
            rewardMultiplier: 0.5,
            oneTimeOnly: true,
            healthType: 'player', // Ground mission
            energyCost: 0,
            minLevel: 1,
            maxLevel: 5,
            maxPlayers: 4,
            estimatedTime: 15
        });
        
        // Space Theme Dungeons
        this.addDungeon('alien_ruins', {
            name: 'Alien Ruins',
            description: 'Ancient alien structures filled with mysterious technology',
            difficulty: 'medium',
            enemyTypes: ['alien_guardian', 'ancient_drone', 'crystal_golem'],
            rewardMultiplier: 1.2,
            healthType: 'player', // Ground mission
            energyCost: 20,
            minLevel: 5,
            maxLevel: 15,
            maxPlayers: 4,
            estimatedTime: 25
        });
        
        this.addDungeon('pirate_lair', {
            name: 'Pirate Lair',
            description: 'Dangerous pirate hideouts with valuable loot',
            difficulty: 'easy',
            enemyTypes: ['space_pirate', 'pirate_captain', 'defense_turret'],
            rewardMultiplier: 1.0,
            healthType: 'ship', // Space mission
            energyCost: 15,
            minLevel: 3,
            maxLevel: 10,
            maxPlayers: 4,
            estimatedTime: 20
        });
        
        this.addDungeon('corrupted_vault', {
            name: 'Corrupted AI Vault',
            description: ' malfunctioning AI facilities with corrupted security',
            difficulty: 'hard',
            enemyTypes: ['security_drone', 'corrupted_ai', 'virus_program'],
            rewardMultiplier: 1.5,
            healthType: 'ship', // Space mission
            energyCost: 25,
            minLevel: 10,
            maxLevel: 20,
            maxPlayers: 4,
            estimatedTime: 35
        });
        
        this.addDungeon('asteroid_mine', {
            name: 'Asteroid Mine',
            description: 'Abandoned mining facilities in asteroid fields',
            difficulty: 'easy',
            enemyTypes: ['mining_drone', 'rock_creature', 'explosive_asteroid'],
            rewardMultiplier: 0.8,
            healthType: 'ship', // Space mission
            energyCost: 10,
            minLevel: 2,
            maxLevel: 8,
            maxPlayers: 4,
            estimatedTime: 18
        });
        
        this.addDungeon('nebula_anomaly', {
            name: 'Nebula Anomaly',
            description: 'Strange energy anomalies in deep space',
            difficulty: 'extreme',
            enemyTypes: ['energy_being', 'phase_shifter', 'quantum_entity'],
            rewardMultiplier: 2.0,
            healthType: 'ship', // Space mission
            energyCost: 30,
            minLevel: 15,
            maxLevel: 25,
            maxPlayers: 4,
            estimatedTime: 40
        });
        
        this.addDungeon('space_station', {
            name: 'Abandoned Space Station',
            description: 'A derelict space station floating in the void',
            difficulty: 'medium',
            enemyTypes: ['maintenance_drone', 'security_android', 'station_ai'],
            rewardMultiplier: 1.3,
            healthType: 'player',
            energyCost: 22,
            minLevel: 6,
            maxLevel: 16,
            maxPlayers: 4,
            estimatedTime: 28
        });
        
        this.addDungeon('comet_core', {
            name: 'Comet Core',
            description: 'The frozen heart of a passing comet',
            difficulty: 'hard',
            enemyTypes: ['ice_elemental', 'frost_wyrm', 'crystal_guardian'],
            rewardMultiplier: 1.6,
            healthType: 'ship',
            energyCost: 28,
            minLevel: 12,
            maxLevel: 22,
            maxPlayers: 4,
            estimatedTime: 32
        });
        
        this.addDungeon('black_hole_perimeter', {
            name: 'Black Hole Perimeter',
            description: 'Dangerous space near a black hole event horizon',
            difficulty: 'extreme',
            enemyTypes: ['gravity_wraith', 'void_stalker', 'singularity_spawn'],
            rewardMultiplier: 2.5,
            healthType: 'ship',
            energyCost: 35,
            minLevel: 18,
            maxLevel: 30,
            maxPlayers: 4,
            estimatedTime: 45
        });
        
        this.addDungeon('star_forge', {
            name: 'Star Forge',
            description: 'Ancient facility that harnesses stellar energy',
            difficulty: 'hard',
            enemyTypes: ['plasma_elemental', 'solar_guardian', 'fusion_core'],
            rewardMultiplier: 1.8,
            healthType: 'ship',
            energyCost: 30,
            minLevel: 14,
            maxLevel: 24,
            maxPlayers: 4,
            estimatedTime: 35
        });
        
        this.addDungeon('debris_field', {
            name: 'Ship Debris Field',
            description: 'Graveyard of destroyed spacecraft',
            difficulty: 'easy',
            enemyTypes: ['scrap_golem', 'hull_breacher', 'salage_drone'],
            rewardMultiplier: 0.9,
            healthType: 'ship',
            energyCost: 12,
            minLevel: 3,
            maxLevel: 9,
            maxPlayers: 4,
            estimatedTime: 20
        });
        
        // Planet Theme Dungeons
        this.addDungeon('jungle_temple', {
            name: 'Jungle Temple',
            description: 'Overgrown temple hidden in dense alien jungle',
            difficulty: 'medium',
            enemyTypes: ['plant_beast', 'tribal_warrior', 'jungle_spirit'],
            rewardMultiplier: 1.4,
            healthType: 'player',
            energyCost: 25,
            minLevel: 7,
            maxLevel: 17,
            maxPlayers: 4,
            estimatedTime: 30
        });
        
        this.addDungeon('desert_pyramid', {
            name: 'Desert Pyramid',
            description: 'Ancient pyramid buried under endless sand dunes',
            difficulty: 'hard',
            enemyTypes: ['sand_worm', 'mummy_guardian', 'heat_elemental'],
            rewardMultiplier: 1.7,
            healthType: 'player',
            energyCost: 28,
            minLevel: 13,
            maxLevel: 23,
            maxPlayers: 4,
            estimatedTime: 33
        });
        
        this.addDungeon('volcanic_caverns', {
            name: 'Volcanic Caverns',
            description: 'Molten caverns deep within an active volcano',
            difficulty: 'hard',
            enemyTypes: ['lava_elemental', 'fire_demon', 'magma_beast'],
            rewardMultiplier: 1.6,
            healthType: 'player',
            energyCost: 26,
            minLevel: 12,
            maxLevel: 22,
            maxPlayers: 4,
            estimatedTime: 32
        });
        
        this.addDungeon('arctic_research', {
            name: 'Arctic Research Base',
            description: 'Frozen research facility with failed experiments',
            difficulty: 'medium',
            enemyTypes: ['cryo_mutant', 'frost_android', 'ice_wraith'],
            rewardMultiplier: 1.5,
            healthType: 'player',
            energyCost: 24,
            minLevel: 8,
            maxLevel: 18,
            maxPlayers: 4,
            estimatedTime: 29
        });
        
        this.addDungeon('swamp_lair', {
            name: 'Swamp Lair',
            description: 'Murky swamp inhabited by strange creatures',
            difficulty: 'easy',
            enemyTypes: ['swamp_beast', 'toxic_spitter', 'mud_golem'],
            rewardMultiplier: 1.1,
            healthType: 'player',
            energyCost: 18,
            minLevel: 4,
            maxLevel: 12,
            maxPlayers: 4,
            estimatedTime: 22
        });
        
        // Technology Theme Dungeons
        this.addDungeon('cyber_realm', {
            name: 'Cyber Realm',
            description: 'Virtual reality space corrupted by malware',
            difficulty: 'hard',
            enemyTypes: ['glitch_wraith', 'firewall_guardian', 'data_vampire'],
            rewardMultiplier: 1.9,
            healthType: 'player',
            energyCost: 32,
            minLevel: 16,
            maxLevel: 26,
            maxPlayers: 4,
            estimatedTime: 38
        });
        
        this.addDungeon('robot_factory', {
            name: 'Robot Factory',
            description: 'Automated factory producing hostile machines',
            difficulty: 'medium',
            enemyTypes: ['assembly_drone', 'welder_bot', 'factory_overseer'],
            rewardMultiplier: 1.4,
            healthType: 'player',
            energyCost: 23,
            minLevel: 9,
            maxLevel: 19,
            maxPlayers: 4,
            estimatedTime: 27
        });
        
        this.addDungeon('quantum_lab', {
            name: 'Quantum Laboratory',
            description: 'Research facility experimenting with quantum physics',
            difficulty: 'extreme',
            enemyTypes: ['quantum_phantom', 'particle_accelerator', 'reality_bender'],
            rewardMultiplier: 2.3,
            healthType: 'player',
            energyCost: 38,
            minLevel: 20,
            maxLevel: 30,
            maxPlayers: 4,
            estimatedTime: 42
        });
        
        this.addDungeon('server_farm', {
            name: 'Server Farm',
            description: 'Massive data center with rogue security programs',
            difficulty: 'medium',
            enemyTypes: ['sentinel_program', 'data_corruptor', 'system_guardian'],
            rewardMultiplier: 1.3,
            healthType: 'player',
            energyCost: 21,
            minLevel: 7,
            maxLevel: 17,
            maxPlayers: 4,
            estimatedTime: 25
        });
        
        console.log(`[DUNGEON SYSTEM] Initialized ${this.dungeons.size} dungeons`);
    }
    
    setIO(io) {
        this.io = io;
        console.log('[DUNGEON SYSTEM] Socket.IO instance set for quest events');
    }
    
    generateDungeonEncounters(dungeon) {
        console.log('[DUNGEON SYSTEM] Generating encounters for dungeon:', dungeon.id);
        
        const encounters = [];
        const encounterCount = Math.max(3, Math.floor(dungeon.estimatedTime / 5)); // 1 encounter per ~5 minutes
        
        console.log('[DUNGEON SYSTEM] Encounter count:', encounterCount, 'for difficulty:', dungeon.difficulty);
        
        // Always start with entrance
        encounters.push({
            type: 'entrance',
            name: 'Dungeon Entrance',
            description: 'The entrance to the dungeon',
            enemies: [],
            rewards: false
        });
        
        // Generate random encounters based on dungeon difficulty
        for (let i = 1; i < encounterCount - 1; i++) {
            const encounterTypes = ['corridor', 'chamber'];
            if (i === Math.floor(encounterCount / 2)) {
                encounterTypes.push('treasure'); // Mid-dungeon treasure room
            }
            
            const type = encounterTypes[Math.floor(Math.random() * encounterTypes.length)];
            const template = this.roomTypes[type];
            
            encounters.push({
                type,
                name: template.name,
                description: `A ${template.name.toLowerCase()} in the dungeon`,
                enemies: this.generateEnemies(dungeon.enemyTypes, template.enemies),
                rewards: template.rewards
            });
        }
        
        // Always end with boss room (except tutorial)
        if (dungeon.difficulty !== 'tutorial') {
            encounters.push({
                type: 'boss',
                name: 'Boss Chamber',
                description: 'The final chamber with a powerful enemy',
                enemies: this.generateEnemies(dungeon.enemyTypes, 1, true),
                rewards: true,
                isBoss: true
            });
        } else {
            // Tutorial ends with simple chamber (only practice targets for auto-completion)
            encounters.push({
                type: 'chamber',
                name: 'Training Room',
                description: 'The final training room',
                enemies: this.generateEnemies(['practice_target'], 1), // Only practice targets
                rewards: true
            });
        }
        
        console.log('[DUNGEON SYSTEM] Generated encounters:', encounters.map((e, i) => ({
            index: i,
            type: e.type,
            name: e.name,
            enemyCount: e.enemies?.length || 0
        })));
        
        return encounters;
    }
    
    generateEnemies(enemyTypes, count, isBoss = false) {
        console.log('[DUNGEON SYSTEM] Generating enemies:', { enemyTypes, count, isBoss });
        console.log('[DUNGEON SYSTEM] Available enemy templates:', Object.keys(this.enemyTemplates));
        
        const enemies = [];
        
        for (let i = 0; i < count; i++) {
            const enemyTypeId = enemyTypes[Math.floor(Math.random() * enemyTypes.length)];
            const template = this.enemyTemplates[enemyTypeId];
            
            console.log(`[DUNGEON SYSTEM] Generating enemy ${i}: type=${enemyTypeId}, template=`, template);
            
            if (!template) {
                console.warn(`[DUNGEON SYSTEM] Enemy template not found for type: ${enemyTypeId}`);
                continue;
            }
            
            // Scale enemy for boss fights
            const enemy = { ...template };
            if (isBoss) {
                enemy.health *= 3;
                enemy.attack *= 2;
                enemy.defense *= 1.5;
                enemy.experience *= 5;
                enemy.credits *= 3;
                enemy.name = `Elite ${enemy.name}`;
            }
            
            enemies.push(enemy);
        }
        
        console.log('[DUNGEON SYSTEM] Generated enemies:', enemies);
        return enemies;
    }
    
    addDungeon(id, dungeon) {
        // Generate encounters for this dungeon
        const encounters = this.generateDungeonEncounters(dungeon);
        
        this.dungeons.set(id, {
            id,
            ...dungeon,
            encounters,
            createdAt: new Date().toISOString(),
            updatedAt: new Date().toISOString()
        });
    }
    
    getDungeon(id) {
        return this.dungeons.get(id);
    }
    
    getAllDungeons() {
        return Array.from(this.dungeons.values());
    }
    
    getDungeonsGroupedByDifficulty() {
        const dungeonsByDifficulty = {
            tutorial: [],
            easy: [],
            medium: [],
            hard: [],
            extreme: []
        };
        
        this.dungeons.forEach(dungeon => {
            if (dungeonsByDifficulty[dungeon.difficulty]) {
                dungeonsByDifficulty[dungeon.difficulty].push(dungeon);
            }
        });
        
        return dungeonsByDifficulty;
    }
    
    getRoomTypes() {
        return this.roomTypes;
    }
    
    getEnemyTemplates() {
        return this.enemyTemplates;
    }
    
    getEnemyTemplate(enemyId) {
        return this.enemyTemplates[enemyId];
    }
    
    getDungeonsByDifficulty(difficulty) {
        return Array.from(this.dungeons.values()).filter(dungeon => dungeon.difficulty === difficulty);
    }
    
    createInstance(dungeonId, creatorId, playerIds = []) {
        console.log('[DUNGEON SYSTEM] Creating instance:', { dungeonId, creatorId, playerIds });
        
        const dungeon = this.getDungeon(dungeonId);
        if (!dungeon) {
            throw new Error('Dungeon not found');
        }
        
        console.log('[DUNGEON SYSTEM] Dungeon found:', {
            id: dungeon.id,
            encountersCount: dungeon.encounters?.length || 0,
            encounters: dungeon.encounters?.map((e, i) => ({ index: i, type: e.type, name: e.name }))
        });
        
        // Validate requirements
        if (playerIds.length > dungeon.maxPlayers) {
            throw new Error('Too many players for this dungeon');
        }
        
        const instanceId = `instance_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
        
        const instance = {
            id: instanceId,
            dungeonId,
            creatorId,
            players: new Set([creatorId, ...playerIds]),
            currentEncounter: 0,
            status: 'active',
            startedAt: new Date().toISOString(),
            completedAt: null,
            progress: {},
            rewards: null,
            deaths: new Map() // userId -> death count
        };
        
        // Initialize progress tracking
        dungeon.encounters.forEach((encounter, index) => {
            instance.progress[index] = {
                completed: false,
                attempts: 0,
                deaths: 0
            };
        });
        
        this.instances.set(instanceId, instance);
        
        // Track player instances
        for (const playerId of instance.players) {
            this.playerInstances.set(playerId, instanceId);
        }
        
        return instance;
    }
    
    getInstance(instanceId) {
        return this.instances.get(instanceId);
    }
    
    getPlayerInstance(userId) {
        const instanceId = this.playerInstances.get(userId);
        return instanceId ? this.getInstance(instanceId) : null;
    }
    
    joinInstance(instanceId, userId) {
        const instance = this.getInstance(instanceId);
        if (!instance) {
            throw new Error('Instance not found');
        }
        
        if (instance.status !== 'active') {
            throw new Error('Instance is not active');
        }
        
        const dungeon = this.getDungeon(instance.dungeonId);
        if (instance.players.size >= dungeon.maxPlayers) {
            throw new Error('Instance is full');
        }
        
        // Remove from existing instance if any
        const existingInstanceId = this.playerInstances.get(userId);
        if (existingInstanceId) {
            this.leaveInstance(userId);
        }
        
        // Add to new instance
        instance.players.add(userId);
        this.playerInstances.set(userId, instanceId);
        
        return instance;
    }
    
    leaveInstance(userId) {
        const instanceId = this.playerInstances.get(userId);
        if (!instanceId) {
            return null;
        }
        
        const instance = this.getInstance(instanceId);
        if (instance) {
            instance.players.delete(userId);
            
            // If instance is empty, clean it up
            if (instance.players.size === 0) {
                this.instances.delete(instanceId);
            }
        }
        
        this.playerInstances.delete(userId);
        return instance;
    }
    
    startEncounter(instanceId, userId) {
        const instance = this.getInstance(instanceId);
        if (!instance) {
            throw new Error('Instance not found');
        }
        
        if (!instance.players.has(userId)) {
            throw new Error('Player not in instance');
        }
        
        const dungeon = this.getDungeon(instance.dungeonId);
        const encounter = dungeon.encounters[instance.currentEncounter];
        
        if (!encounter) {
            throw new Error('No more encounters');
        }
        
        return {
            encounter,
            encounterIndex: instance.currentEncounter,
            instance
        };
    }
    
    completeEncounter(instanceId, userId, result) {
        const instance = this.getInstance(instanceId);
        if (!instance) {
            throw new Error('Instance not found');
        }
        
        const dungeon = this.getDungeon(instance.dungeonId);
        const encounter = dungeon.encounters[instance.currentEncounter];
        
        if (!encounter) {
            throw new Error('No encounter to complete');
        }
        
        const progress = instance.progress[instance.currentEncounter];
        progress.completed = true;
        progress.attempts++;
        
        if (result.deaths) {
            progress.deaths += result.deaths;
            instance.deaths.set(userId, (instance.deaths.get(userId) || 0) + result.deaths);
        }
        
        // Move to next encounter
        instance.currentEncounter++;
        
        // Check if dungeon is complete
        if (instance.currentEncounter >= dungeon.encounters.length) {
            return this.completeDungeon(instanceId);
        }
        
        return {
            success: true,
            nextEncounter: instance.currentEncounter < dungeon.encounters.length ? dungeon.encounters[instance.currentEncounter] : null,
            encounterIndex: instance.currentEncounter,
            instance
        };
    }
    
    completeDungeon(instanceId) {
        const instance = this.getInstance(instanceId);
        if (!instance) {
            throw new Error('Instance not found');
        }
        
        const dungeon = this.getDungeon(instance.dungeonId);
        
        // Calculate rewards
        const rewards = this.calculateRewards(dungeon, instance);
        
        // Mark as completed
        instance.status = 'completed';
        instance.completedAt = new Date().toISOString();
        instance.rewards = rewards;
        
        // Remove players from instance tracking
        for (const playerId of instance.players) {
            this.playerInstances.delete(playerId);
            
            // Check for quest completion
            this.checkQuestCompletion(playerId, instance.dungeonId);
        }
        
        return {
            success: true,
            dungeon,
            rewards,
            instance,
            encounterIndex: -1, // Dungeon complete
            isComplete: true
        };
    }
    
    // Check if dungeon completion should trigger quests
    checkQuestCompletion(userId, dungeonId) {
        // Tutorial dungeon completion should trigger main story progression
        if (dungeonId === 'tutorial') {
            console.log('[DUNGEON SYSTEM] Tutorial dungeon completed, triggering quest progression');
            
            // Set player stat for tutorial completion
            if (this.io) {
                this.io.emit('player_stat_update', {
                    userId: userId,
                    stat: 'tutorialDungeonCompleted',
                    value: true
                });
                
                // Emit quest completion event for quest system
                this.io.emit('quest_completed', {
                    userId: userId,
                    questId: 'main_story_first_dungeon',
                    questType: 'dungeon',
                    dungeonId: dungeonId,
                    rewards: {
                        experience: 50,
                        credits: 25
                    }
                });
            }
        }
    }
    
    getPlayerCompletedDungeons(userId) {
        const instances = Array.from(this.instances.values()).filter(instance => 
            instance.players.has(userId) && instance.status === 'completed'
        );
        
        return instances.map(instance => instance.dungeonId);
    }
    
    calculateRewards(dungeon, instance) {
        const rewards = {
            experience: 0,
            credits: 0,
            items: []
        };
        
        // Check if dungeon has rewards defined
        if (!dungeon.rewards) {
            console.warn('[DUNGEON SYSTEM] No rewards defined for dungeon:', dungeon.id);
            return rewards;
        }
        
        // Calculate base rewards
        const expRange = dungeon.rewards.experience;
        const creditRange = dungeon.rewards.credits;
        
        if (!expRange || !creditRange) {
            console.warn('[DUNGEON SYSTEM] Incomplete rewards defined for dungeon:', dungeon.id);
            return rewards;
        }
        
        rewards.experience = Math.floor(Math.random() * (expRange.max - expRange.min + 1)) + expRange.min;
        rewards.credits = Math.floor(Math.random() * (creditRange.max - creditRange.min + 1)) + creditRange.min;
        
        // Add death penalty
        const totalDeaths = Array.from(instance.deaths.values()).reduce((sum, deaths) => sum + deaths, 0);
        const deathPenalty = Math.floor(totalDeaths * 0.1); // 10% penalty per death
        rewards.experience = Math.max(0, rewards.experience - deathPenalty);
        rewards.credits = Math.max(0, rewards.credits - (deathPenalty * 2));
        
        // Add items (chance based on performance)
        const itemChance = Math.max(0.1, 0.5 - (totalDeaths * 0.1)); // Lower chance with more deaths
        if (Math.random() < itemChance) {
            const itemPool = dungeon.rewards.items;
            if (itemPool && itemPool.length > 0) {
                rewards.items.push(itemPool[Math.floor(Math.random() * itemPool.length)]);
            }
        }
        
        return rewards;
    }
    
    getAvailableDungeons(playerLevel, playerCount = 1) {
        return Array.from(this.dungeons.values()).filter(dungeon => 
            dungeon.minLevel <= playerLevel && 
            dungeon.maxLevel >= playerLevel &&
            dungeon.maxPlayers >= playerCount
        );
    }
    
    moveToNextRoom(instanceId, userId) {
        console.log('[DUNGEON SYSTEM] moveToNextRoom called:', { instanceId, userId });
        
        const instance = this.getInstance(instanceId);
        if (!instance) {
            throw new Error('Instance not found');
        }
        
        if (!instance.players.has(userId)) {
            throw new Error('Player not in instance');
        }
        
        const dungeon = this.getDungeon(instance.dungeonId);
        
        console.log('[DUNGEON SYSTEM] Current state:', {
            currentEncounter: instance.currentEncounter,
            totalEncounters: dungeon.encounters.length,
            dungeonId: dungeon.id
        });
        
        // Move to next encounter
        instance.currentEncounter++;
        
        console.log('[DUNGEON SYSTEM] After increment:', {
            newEncounter: instance.currentEncounter,
            isComplete: instance.currentEncounter >= dungeon.encounters.length
        });
        
        // Check if dungeon is complete
        if (instance.currentEncounter >= dungeon.encounters.length) {
            return this.completeDungeon(instanceId);
        }
        
        // Get next encounter
        const encounter = dungeon.encounters[instance.currentEncounter];
        
        console.log('[DUNGEON SYSTEM] Next encounter:', {
            encounterIndex: instance.currentEncounter,
            encounterType: encounter.type,
            encounterName: encounter.name,
            enemies: encounter.enemies
        });
        
        return {
            success: true,
            encounter,
            encounterIndex: instance.currentEncounter,
            instance,
            isComplete: false
        };
    }
    
    getDungeonStatistics(userId) {
        const instances = Array.from(this.instances.values()).filter(instance => 
            instance.players.has(userId)
        );
        
        const completed = instances.filter(instance => instance.status === 'completed');
        const active = instances.filter(instance => instance.status === 'active');
        
        return {
            totalDungeons: instances.length,
            completedDungeons: completed.length,
            activeDungeons: active.length,
            totalDeaths: Array.from(this.playerInstances.values()).length,
            recentCompletions: completed.slice(-5).map(instance => ({
                dungeonId: instance.dungeonId,
                completedAt: instance.completedAt,
                rewards: instance.rewards
            }))
        };
    }
    
    cleanupExpiredInstances() {
        const now = Date.now();
        const expiredInstances = [];
        
        for (const [instanceId, instance] of this.instances) {
            const age = now - new Date(instance.startedAt).getTime();
            const maxAge = 2 * 60 * 60 * 1000; // 2 hours
            
            if (age > maxAge && instance.status === 'active') {
                expiredInstances.push(instanceId);
            }
        }
        
        // Clean up expired instances
        for (const instanceId of expiredInstances) {
            const instance = this.instances.get(instanceId);
            if (instance) {
                for (const playerId of instance.players) {
                    this.playerInstances.delete(playerId);
                }
                this.instances.delete(instanceId);
            }
        }
        
        return expiredInstances.length;
    }
}

module.exports = DungeonSystem;