// 现代变量声明方式
let name = "张三";
const age = 25;
const isStudent = true;

// 模板字符串
const greeting = `你好，${name}！你今年${age}岁。`;

// 解构赋值
const [a, b, c] = [1, 2, 3];
const {name, age} = person;

// 箭头函数与普通函数的区别
const obj = {
    name: '张三',
    regularFunc: function() {
        console.log(this.name); // 张三
    },
    arrowFunc: () => {
        console.log(this.name); // undefined
    }
};

// 闭包与作用域
function createCounter() {
    let count = 0;
    return function() {
        return ++count;
    };
}

// Promise 链式调用
fetch('/api/data')
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error('Error:', error));

// async/await 语法
async function fetchData() {
    try {
        const response = await fetch('/api/data');
        const data = await response.json();
        return data;
    } catch (error) {
        console.error('Error:', error);
    }
}

// 并发处理
Promise.all([fetchData1(), fetchData2(), fetchData3()])
    .then(results => console.log(results));

// 原型链继承
function Animal(name) {
    this.name = name;
}
Animal.prototype.speak = function() {
    console.log(`${this.name} makes a sound`);
};

// ES6 Class 语法
class Dog extends Animal {
    constructor(name, breed) {
        super(name);
        this.breed = breed;
    }

    speak() {
        console.log(`${this.name} barks`);
    }
}

// 闭包实现私有变量
function createBankAccount(initialBalance) {
    let balance = initialBalance;

    return {
        deposit: function(amount) {
            balance += amount;
            return balance;
        },
        withdraw: function(amount) {
            if (balance >= amount) {
                balance -= amount;
                return balance;
            }
            throw new Error('Insufficient funds');
        },
        getBalance: function() {
            return balance;
        }
    };
}

// 高阶函数：函数组合
const compose = (f, g) => x => f(g(x));
const add1 = x => x + 1;
const multiply2 = x => x * 2;
const add1ThenMultiply2 = compose(multiply2, add1);

// 优化前的代码
function sumArray(arr) {
    let sum = 0;
    for (let i = 0; i < arr.length; i++) {
        sum += arr[i];
    }
    return sum;
}

// 优化后的代码（利用引擎优化）
function sumArrayOptimized(arr) {
    let sum = 0;
    const length = arr.length; // 缓存长度属性
    for (let i = 0; i < length; i++) {
        sum += arr[i]; // 单态调用优化
    }
    return sum;
}

// 隐藏类友好的对象创建
function Point(x, y) {
    this.x = x;
    this.y = y;
}

// 保持对象形状一致
const points = [];
for (let i = 0; i < 1000; i++) {
    points.push(new Point(i, i * 2));
}

// 避免在运行时删除属性（会破坏隐藏类）
// bad: delete point.x;
// good: point.x = undefined;

// 避免内存泄漏
class EventEmitter {
    constructor() {
        this.events = {};
        this.maxListeners = 10;
    }

    on(event, listener) {
        if (!this.events[event]) {
            this.events[event] = [];
        }
        this.events[event].push(listener);

        // 防止内存泄漏
        if (this.events[event].length > this.maxListeners) {
            console.warn(`Possible memory leak detected. ${this.events[event].length} ${event} listeners attached.`);
        }
    }

    // 记得在不需要时移除监听器
    off(event, listenerToRemove) {
        if (!this.events[event]) return;
        this.events[event] = this.events[event].filter(listener => listener !== listenerToRemove);
    }
}

// 主线程代码
const worker = new Worker('worker.js');

worker.postMessage({
    type: 'calculate',
    data: largeDataSet
});

worker.onmessage = function(event) {
    console.log('Worker result:', event.data);
};

// worker.js
self.onmessage = function(event) {
    if (event.data.type === 'calculate') {
        const result = heavyCalculation(event.data.data);
        self.postMessage(result);
    }
};

function heavyCalculation(data) {
    // CPU 密集型计算
    return data.map(item => complexOperation(item));
}

// 性能监控 API
const performance = {
    start: function(label) {
        performance.mark(`${label}-start`);
    },

    end: function(label) {
        performance.mark(`${label}-end`);
        performance.measure(label, `${label}-start`, `${label}-end`);
        const measures = performance.getEntriesByName(label);
        const duration = measures[0].duration;
        console.log(`${label}: ${duration.toFixed(2)}ms`);
        performance.clearMarks();
        performance.clearMeasures();
    }
};

// 使用示例
performance.start('data-processing');
// ... 执行代码
performance.end('data-processing');

// 数据验证 Proxy
const validationProxy = new Proxy({}, {
    set: function(target, property, value) {
        if (property === 'age' && typeof value !== 'number') {
            throw new Error('Age must be a number');
        }
        if (property === 'name' && typeof value !== 'string') {
            throw new Error('Name must be a string');
        }
        target[property] = value;
        return true;
    }
});

// API 请求拦截器
const apiProxy = new Proxy({}, {
    get: function(target, property) {
        return function(...args) {
            console.log(`API call: ${property}`, args);
            return fetch(`/api/${property}`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify(args[0])
            });
        };
    }
});

export class WordleGame {
    constructor(wordList = []) {
        this.wordList = wordList;
        this.targetWord = '';
        this.currentGuess = '';
        this.guesses = [];
        this.maxGuesses = 6;
        this.wordLength = 5;
        this.gameStatus = 'playing';
    }

    addLetter(letter) {
        if (this.currentGuess.length < this.wordLength) {
            this.currentGuess += letter.toUpperCase();
            return true;
        }
        return false;
    }

    submitGuess() {
        if (this.currentGuess.length === this.wordLength) {
            const result = this.evaluateGuess(this.currentGuess);
            this.guesses.push({ word: this.currentGuess, result });
            this.currentGuess = '';
            this.checkGameStatus();
            return true;
        }
        return false;
    }
}

export class WordValidator {
    constructor() {
        this.validWords = new Set();
        this.commonWords = new Set([
            'ABOUT', 'ABOVE', 'ABUSE', 'ACTOR', 'ACUTE', 'ADMIT', 'ADOPT', 'ADULT',
            'AFTER', 'AGAIN', 'AGENT', 'AGREE', 'AHEAD', 'ALARM', 'ALBUM', 'ALERT',
            // ... 500+ 常用英文单词
        ]);
        this.commonWords.forEach(word => this.validWords.add(word));
    }

    validateWord(word) {
        if (typeof word !== 'string') {
            return { valid: false, reason: '单词必须是字符串' };
        }

        if (word.length !== 5) {
            return { valid: false, reason: '单词必须是5个字母' };
        }

        if (!/^[A-Z]{5}$/.test(word)) {
            return { valid: false, reason: '单词只能包含字母' };
        }

        if (!this.validWords.has(word)) {
            return { valid: false, reason: '不是有效的英文单词' };
        }

        return { valid: true };
    }
}

export class GameStateManager {
    constructor() {
        this.state = {
            currentGame: null,
            gameHistory: [],
            statistics: {
                gamesPlayed: 0,
                gamesWon: 0,
                currentStreak: 0,
                maxStreak: 0,
                guessDistribution: [0, 0, 0, 0, 0, 0]
            },
            settings: {
                darkTheme: false,
                animations: true,
                hardMode: false
            },
            achievements: [],
            lastPlayed: null
        };
        this.loadState();
    }

    submitGuess(word) {
        const result = this.game.evaluateGuess(word, this.game.targetWord);
        this.game.guesses.push({ word, result });

        // 更新统计
        this.state.statistics.gamesPlayed++;
        this.state.statistics.guessDistribution[this.game.guesses.length - 1]++;

        if (this.game.gameStatus === 'won') {
            this.state.statistics.gamesWon++;
            this.state.statistics.currentStreak++;
            this.state.statistics.maxStreak = Math.max(
                this.state.statistics.maxStreak,
                this.state.statistics.currentStreak
            );
        } else {
            this.state.statistics.currentStreak = 0;
        }

        this.saveState();
        return result;
    }
}