/**
 * STEAM INTEGRATION SYSTEM
 * Handles Steam achievements and cloud saves
 * 
 * NOTE: Requires Steamworks SDK and Greenworks library
 * This is a placeholder/mock implementation for development
 */
class SteamIntegrationSystem {
    constructor() {
        this.steamAvailable = false;
        this.achievements = {};
        this.cloudSaveEnabled = false;

        // Mock achievement definitions
        this.achievementDefs = {
            'FIRST_HARVEST': { name: 'First Harvest', desc: 'Harvest your first crop' },
            'GOLD_RUSH': { name: 'Gold Rush', desc: 'Earn 1000 gold coins' },
            'ZOMBIE_SLAYER': { name: 'Zombie Slayer', desc: 'Kill 100 zombies' },
            'MASTER_FARMER': { name: 'Master Farmer', desc: 'Harvest 1000 crops' },
            'DAY_30': { name: 'Survivor', desc: 'Survive 30 days' },
            'GREENHOUSE': { name: 'Greenhouse Builder', desc: 'Build a greenhouse' },
            'TAMED_ZOMBIE': { name: 'Zombie Tamer', desc: 'Tame your first zombie' },
            'OCEAN_EXPLORER': { name: 'Ocean Explorer', desc: 'Discover 5 islands' }
        };

        this.init();
    }

    init() {
        // Check if Steamworks is available
        if (typeof greenworks !== 'undefined') {
            try {
                greenworks.init();
                this.steamAvailable = true;
                this.cloudSaveEnabled = greenworks.isCloudEnabled();
                console.log('✅ Steam Integration: Active');
                console.log(`☁️ Cloud Saves: ${this.cloudSaveEnabled ? 'Enabled' : 'Disabled'}`);
            } catch (e) {
                console.warn('⚠️ Steam Integration: Failed to initialize', e);
                this.steamAvailable = false;
            }
        } else {
            console.log('ℹ️ Steam Integration: Not available (running outside Steam)');
        }
    }

    /**
     * Unlock achievement
     */
    unlockAchievement(achievementId) {
        if (!this.achievementDefs[achievementId]) {
            console.error('Unknown achievement:', achievementId);
            return false;
        }

        const achievement = this.achievementDefs[achievementId];

        if (this.steamAvailable && typeof greenworks !== 'undefined') {
            try {
                greenworks.activateAchievement(achievementId, () => {
                    console.log(`🏆 Achievement Unlocked: ${achievement.name}`);
                }, (err) => {
                    console.error('Failed to unlock achievement:', err);
                });
            } catch (e) {
                console.error('Steam achievement error:', e);
            }
        } else {
            // Mock/local achievement
            if (!this.achievements[achievementId]) {
                this.achievements[achievementId] = true;
                console.log(`🏆 [MOCK] Achievement Unlocked: ${achievement.name}`);

                // Show notification
                if (this.scene && this.scene.events) {
                    this.scene.events.emit('show-floating-text', {
                        x: 320,
                        y: 100,
                        text: `🏆 ${achievement.name}`,
                        color: '#ffd700'
                    });
                }

                // Save to localStorage
                this.saveLocalAchievements();
                return true;
            }
        }
        return false;
    }

    /**
     * Save game to Steam Cloud
     */
    saveToCloud(saveData) {
        if (!this.cloudSaveEnabled) {
            console.log('☁️ Cloud saves not available, saving locally');
            localStorage.setItem('novafarma_save', JSON.stringify(saveData));
            return false;
        }

        try {
            const saveString = JSON.stringify(saveData);
            greenworks.saveTextToFile('novafarma_save.json', saveString, () => {
                console.log('☁️ Game saved to Steam Cloud');
            }, (err) => {
                console.error('Failed to save to cloud:', err);
                // Fallback to local
                localStorage.setItem('novafarma_save', saveString);
            });
            return true;
        } catch (e) {
            console.error('Cloud save error:', e);
            return false;
        }
    }

    /**
     * Load game from Steam Cloud
     */
    loadFromCloud(callback) {
        if (!this.cloudSaveEnabled) {
            console.log('☁️ Cloud saves not available, loading locally');
            const localSave = localStorage.getItem('novafarma_save');
            if (localSave && callback) {
                callback(JSON.parse(localSave));
            }
            return;
        }

        try {
            greenworks.readTextFromFile('novafarma_save.json', (data) => {
                console.log('☁️ Loaded from Steam Cloud');
                if (callback) callback(JSON.parse(data));
            }, (err) => {
                console.error('Failed to load from cloud:', err);
                // Fallback to local
                const localSave = localStorage.getItem('novafarma_save');
                if (localSave && callback) {
                    callback(JSON.parse(localSave));
                }
            });
        } catch (e) {
            console.error('Cloud load error:', e);
        }
    }

    /**
     * Get achievement status
     */
    getAchievementStatus(achievementId) {
        return this.achievements[achievementId] || false;
    }

    /**
     * Get all unlocked achievements
     */
    getUnlockedAchievements() {
        return Object.keys(this.achievements).filter(id => this.achievements[id]);
    }

    /**
     * Save achievements to localStorage (fallback)
     */
    saveLocalAchievements() {
        localStorage.setItem('novafarma_achievements', JSON.stringify(this.achievements));
    }

    /**
     * Load achievements from localStorage
     */
    loadLocalAchievements() {
        const saved = localStorage.getItem('novafarma_achievements');
        if (saved) {
            this.achievements = JSON.parse(saved);
        }
    }

    /**
     * Set overlay position (for Steam overlay)
     */
    activateOverlay(dialog = 'Friends') {
        if (this.steamAvailable && typeof greenworks !== 'undefined') {
            try {
                greenworks.activateGameOverlay(dialog);
            } catch (e) {
                console.error('Failed to activate Steam overlay:', e);
            }
        }
    }
}

// Global instance
window.SteamIntegration = SteamIntegrationSystem;