/**
 * MiningSystem.js
 * ===============
 * KRVAVA ŽETEV - Complete Mining System (Phase 16)
 * 
 * Features:
 * - 5 mine types (Iron, Crystal, Coal, Radioactive, Atlantean)
 * - 50-100 levels per mine
 * - Ore spawning & collection
 * - Boss encounters
 * - Hazard systems (radiation, oxygen, explosions)
 * - Mining tools (6 tiers)
 * - Elevator/transport system
 * 
 * @author NovaFarma Team
 * @date 2025-12-23
 */

class MiningSystem {
    constructor(scene) {
        this.scene = scene;

        // Mine registry
        this.mines = new Map();
        this.currentMine = null;
        this.currentLevel = 0;

        // Player state
        this.playerDepth = 0;
        this.oxygenLevel = 100;
        this.radiationLevel = 0;

        // Ore nodes
        this.oreNodes = [];

        // Mining tools
        this.currentTool = null;
        this.toolTier = 1;

        console.log('⛏️ MiningSystem initialized');

        // Register all mines
        this.registerMines();

        // Register mining tools
        this.registerTools();
    }

    /**
     * Register all mine types
     */
    registerMines() {
        // Iron Mine (50 levels)
        this.mines.set('iron_mine', {
            id: 'iron_mine',
            name: 'Iron Mine',
            icon: '⛏️',
            maxLevels: 50,
            ores: ['iron_ore', 'copper_ore', 'tin_ore'],
            hazards: ['cave_in', 'poison_gas'],
            boss: {
                level: 50,
                name: 'Stone Golem',
                hp: 5000,
                damage: 100,
                rewards: { iron_ore: 100, golem_core: 1 }
            },
            elevatorSpeed: 2, // seconds per level
            lightingRequired: true
        });

        // Crystal Cavern (75 levels)
        this.mines.set('crystal_cavern', {
            id: 'crystal_cavern',
            name: 'Crystal Cavern',
            icon: '💎',
            maxLevels: 75,
            ores: ['crystal', 'amethyst', 'emerald', 'ruby', 'sapphire'],
            hazards: ['crystal_shards', 'magic_surge'],
            boss: {
                level: 75,
                name: 'Crystal Guardian',
                hp: 8000,
                damage: 150,
                rewards: { legendary_crystal: 1, gems: 50 }
            },
            elevatorSpeed: 3,
            lightingRequired: true,
            gemVeins: true
        });

        // Coal Mine (40 levels)
        this.mines.set('coal_mine', {
            id: 'coal_mine',
            name: 'Coal Mine',
            icon: '🪨',
            maxLevels: 40,
            ores: ['coal', 'fossil', 'amber'],
            hazards: ['methane_explosion', 'cave_in', 'undead_miners'],
            boss: {
                level: 40,
                name: 'Undead Miner King',
                hp: 4000,
                damage: 80,
                rewards: { ancient_pickaxe: 1, coal: 100 }
            },
            elevatorSpeed: 1.5,
            lightingRequired: true,
            explosionRisk: true
        });

        // Radioactive Mine (100 levels)
        this.mines.set('radioactive_mine', {
            id: 'radioactive_mine',
            name: 'Radioactive Mine',
            icon: '☢️',
            maxLevels: 100,
            ores: ['uranium', 'plutonium', 'reactor_fragments'],
            hazards: ['radiation', 'meltdown', 'mutants'],
            boss: {
                level: 100,
                name: 'Radiation Colossus',
                hp: 15000,
                damage: 300,
                rewards: { reactor_core: 1, uranium: 200 }
            },
            elevatorSpeed: 4,
            lightingRequired: false, // Glows
            radiationDamage: true,
            hazmatRequired: true
        });

        // Atlantean Deep Mine (50 levels)
        this.mines.set('atlantean_mine', {
            id: 'atlantean_mine',
            name: 'Atlantean Deep Mine',
            icon: '🔱',
            maxLevels: 50,
            ores: ['orichalcum', 'atlantean_steel', 'sea_crystal'],
            hazards: ['water_pressure', 'sea_monsters', 'oxygen_loss'],
            boss: {
                level: 50,
                name: 'Kraken',
                hp: 10000,
                damage: 200,
                rewards: { kraken_tentacle: 1, orichalcum: 50 }
            },
            elevatorSpeed: 3,
            lightingRequired: true,
            underwater: true,
            oxygenSystem: true
        });

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

    /**
     * Register mining tools (6 tiers)
     */
    registerTools() {
        this.tools = [
            { tier: 1, name: 'Wooden Pickaxe', speed: 1.0, durability: 100 },
            { tier: 2, name: 'Stone Pickaxe', speed: 1.5, durability: 200 },
            { tier: 3, name: 'Iron Pickaxe', speed: 2.0, durability: 400 },
            { tier: 4, name: 'Steel Pickaxe', speed: 3.0, durability: 800 },
            { tier: 5, name: 'Diamond Drill', speed: 5.0, durability: 2000, autoCollect: true },
            { tier: 6, name: 'Orichalcum Drill', speed: 10.0, durability: 5000, autoCollect: true }
        ];

        console.log(`✅ Registered ${this.tools.length} mining tools`);
    }

    /**
     * Enter mine
     */
    enterMine(mineId, startLevel = 1) {
        const mine = this.mines.get(mineId);
        if (!mine) {
            console.error(`Mine ${mineId} not found!`);
            return false;
        }

        this.currentMine = mine;
        this.currentLevel = startLevel;
        this.playerDepth = 0;

        // Reset hazard states
        this.oxygenLevel = 100;
        this.radiationLevel = 0;

        console.log(`⛏️ Entered ${mine.name} - Level ${startLevel}`);

        // Initialize level
        this.initializeLevel(startLevel);

        this.showNotification({
            title: `Entered ${mine.name}`,
            text: `${mine.icon} Level ${startLevel}/${mine.maxLevels}`,
            icon: '⛏️'
        });

        return true;
    }

    /**
     * Initialize mine level
     */
    initializeLevel(level) {
        if (!this.currentMine) return;

        // Clear previous ore nodes
        this.oreNodes = [];

        // Spawn ore nodes based on level
        const oreCount = 10 + level * 2; // More ores deeper
        for (let i = 0; i < oreCount; i++) {
            this.spawnOreNode(level);
        }

        // Check for boss level
        if (level === this.currentMine.boss.level) {
            this.spawnBoss();
        }

        console.log(`✅ Level ${level} initialized with ${this.oreNodes.length} ore nodes`);
    }

    /**
     * Spawn ore node
     */
    spawnOreNode(level) {
        const mine = this.currentMine;

        // Random ore type
        const oreType = Phaser.Utils.Array.GetRandom(mine.ores);

        // Random position
        const x = Phaser.Math.Between(100, 700);
        const y = Phaser.Math.Between(100, 500);

        const node = {
            id: `ore_${this.oreNodes.length}`,
            type: oreType,
            x: x,
            y: y,
            hp: 50 + level * 5,
            maxHp: 50 + level * 5,
            quantity: Math.floor(1 + level * 0.5),
            respawnTime: 60000, // 60 seconds
            mined: false
        };

        this.oreNodes.push(node);
    }

    /**
     * Mine ore node
     */
    mineOre(nodeId) {
        const node = this.oreNodes.find(n => n.id === nodeId);
        if (!node || node.mined) return null;

        const tool = this.tools[this.toolTier - 1];
        const damage = 10 * tool.speed;

        node.hp -= damage;

        if (node.hp <= 0) {
            // Node depleted
            node.mined = true;

            // Grant ore
            const ore = {
                type: node.type,
                quantity: node.quantity
            };

            console.log(`⛏️ Mined ${ore.quantity}x ${ore.type}`);

            // Auto-collect if tool has feature
            if (tool.autoCollect) {
                this.collectOre(ore);
            }

            // Schedule respawn
            setTimeout(() => {
                node.mined = false;
                node.hp = node.maxHp;
            }, node.respawnTime);

            return ore;
        }

        return null;
    }

    /**
     * Collect ore
     */
    collectOre(ore) {
        console.log(`📦 Collected ${ore.quantity}x ${ore.type}`);
        // TODO: Add to inventory
    }

    /**
     * Use elevator
     */
    useElevator(targetLevel) {
        if (!this.currentMine) return false;

        if (targetLevel < 1 || targetLevel > this.currentMine.maxLevels) {
            console.error(`Invalid level: ${targetLevel}`);
            return false;
        }

        const travelTime = Math.abs(targetLevel - this.currentLevel) * this.currentMine.elevatorSpeed;

        console.log(`🛗 Traveling to level ${targetLevel} (${travelTime}s)`);

        setTimeout(() => {
            this.currentLevel = targetLevel;
            this.initializeLevel(targetLevel);

            this.showNotification({
                title: 'Elevator Arrived',
                text: `Level ${targetLevel}/${this.currentMine.maxLevels}`,
                icon: '🛗'
            });
        }, travelTime * 1000);

        return true;
    }

    /**
     * Spawn boss
     */
    spawnBoss() {
        const boss = this.currentMine.boss;

        console.log(`👹 ${boss.name} has appeared!`);

        this.showNotification({
            title: 'BOSS ENCOUNTER!',
            text: `${boss.name} - ${boss.hp} HP`,
            icon: '👹'
        });

        // TODO: Integrate with boss fight system
    }

    /**
     * Update hazards
     */
    updateHazards(delta) {
        if (!this.currentMine) return;

        const mine = this.currentMine;

        // Radiation damage
        if (mine.radiationDamage) {
            this.radiationLevel += 0.1 * (delta / 1000);

            if (this.radiationLevel > 100) {
                console.log('☢️ Radiation poisoning!');
                // TODO: Apply damage
            }
        }

        // Oxygen depletion
        if (mine.oxygenSystem) {
            this.oxygenLevel -= 0.5 * (delta / 1000);

            if (this.oxygenLevel <= 0) {
                console.log('💨 Out of oxygen!');
                // TODO: Force ascent
            }
        }

        // Methane explosion risk
        if (mine.explosionRisk) {
            if (Math.random() < 0.001) { // 0.1% per frame
                console.log('💥 Methane explosion!');
                this.triggerExplosion();
            }
        }
    }

    /**
     * Trigger explosion
     */
    triggerExplosion() {
        console.log('💥 EXPLOSION! Take damage!');
        this.scene.cameras.main.shake(1000, 0.03);
        // TODO: Apply damage
    }

    /**
     * Get mine info
     */
    getMineInfo(mineId) {
        return this.mines.get(mineId);
    }

    /**
     * Get all mines
     */
    getAllMines() {
        return Array.from(this.mines.values());
    }

    /**
     * Get current level info
     */
    getCurrentLevelInfo() {
        if (!this.currentMine) return null;

        return {
            mine: this.currentMine.name,
            level: this.currentLevel,
            maxLevel: this.currentMine.maxLevels,
            oreNodes: this.oreNodes.length,
            minedNodes: this.oreNodes.filter(n => n.mined).length,
            oxygen: this.oxygenLevel,
            radiation: this.radiationLevel
        };
    }

    /**
     * Upgrade tool
     */
    upgradeTool(tier) {
        if (tier < 1 || tier > this.tools.length) {
            console.error(`Invalid tool tier: ${tier}`);
            return false;
        }

        this.toolTier = tier;
        this.currentTool = this.tools[tier - 1];

        console.log(`⛏️ Upgraded to ${this.currentTool.name}`);

        this.showNotification({
            title: 'Tool Upgraded!',
            text: `⛏️ ${this.currentTool.name} - ${this.currentTool.speed}x speed`,
            icon: '✨'
        });

        return true;
    }

    /**
     * Update system
     */
    update(delta) {
        if (!this.currentMine) return;

        // Update hazards
        this.updateHazards(delta);

        // Update ore nodes
        // (visual updates if needed)
    }

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