:rocket: Advanced Operators and Expressions

// Let's start with a game score
let score = 100;

// The LONG way (boring! 😴)
score = score + 10;    // Add 10 points
score = score * 1.5;   // Multiply by 1.5

// The SMART way with compound operators (cool! 😎)
let playerScore = 100;

playerScore += 10;     // Same as: playerScore = playerScore + 10
                      // "Add 10 to my score"

playerScore *= 1.5;    // Same as: playerScore = playerScore * 1.5
                      // "Multiply my score by 1.5"

playerScore -= 5;      // Same as: playerScore = playerScore - 5
                      // "Subtract 5 from my score"

playerScore /= 2;      // Same as: playerScore = playerScore / 2
                      // "Divide my score by 2"

playerScore %= 3;      // Same as: playerScore = playerScore % 3
                      // "Keep only the remainder when divided by 3"

playerScore **= 2;     // Same as: playerScore = playerScore ** 2
                      // "Square my score (multiply by itself)"

console.log(playerScore);  // See the final score!

// 🔄 The Magic Variable Swap Trick!
let playerA = 5;
let playerB = 10;

// OLD way: Need a temporary variable (boring!)
// let temp = playerA;
// playerA = playerB;
// playerB = temp;

// NEW way: Magic swap in one line! ✨
[playerA, playerB] = [playerB, playerA];
console.log(playerA, playerB); // 10, 5 - They swapped places!

// 📦 Unpacking Objects - Like Opening a Backpack!
const gameCharacter = {
    name: 'Super Mario',
    health: 100,
    powerUps: ['mushroom', 'fire flower']
};

// Extract values from the object
const { name, health } = gameCharacter;
console.log(name);    // 'Super Mario'
console.log(health);  // 100

// 🪆 Nested Destructuring - Objects Inside Objects!
const gameData = {
    player: {
        info: {
            username: 'CoolGamer123',
            level: 42
        }
    }
};

// Reach deep inside to get what we need
const { 
    player: { 
        info: { username, level } 
    } 
} = gameData;

console.log(username); // 'CoolGamer123'
console.log(level);    // 42

let myFavoriteNumber = 7;
let yourFavoriteNumber = 13;
// Your code here to swap them!

// 📥 Rest Operator - Collecting Leftovers!
const scores = [95, 87, 92, 88, 79];

// Take the first two scores, collect the REST in a box
const [firstPlace, secondPlace, ...theRest] = scores;

console.log(firstPlace);   // 95
console.log(secondPlace);  // 87
console.log(theRest);      // [92, 88, 79] - All the rest in an array!

// 📤 Spread Operator - Spreading Things Out!
const primaryColors = ['red', 'blue', 'yellow'];
const secondaryColors = ['green', 'orange', 'purple'];

// Combine arrays using spread (like pouring two boxes into one!)
const allColors = [...primaryColors, ...secondaryColors];
console.log(allColors); 
// ['red', 'blue', 'yellow', 'green', 'orange', 'purple']

// 🎮 Real Example: Combining Game Items
const backpack = { sword: 1, potion: 3 };
const chest = { gold: 100, gem: 2 };

// Merge all items into inventory
const inventory = { 
    ...backpack,    // Spread backpack items
    ...chest,       // Spread chest items
    map: 1          // Add a new item too!
};
console.log(inventory); 
// { sword: 1, potion: 3, gold: 100, gem: 2, map: 1 }

// 🔒 Strict Equality (===) - The Picky Checker!
// It checks if things are EXACTLY the same (including type)
console.log(5 === 5);        // true ✅ (same number)
console.log(5 === "5");      // false ❌ (number vs string)
console.log("hello" === "hello"); // true ✅ (same string)

// 🔓 Loose Equality (==) - The Flexible Checker!
// It tries to convert types to match
console.log(5 == "5");       // true ✅ (converts string to number)
console.log(1 == true);      // true ✅ (true becomes 1)
console.log(0 == false);     // true ✅ (false becomes 0)

// 🎮 Game Example: Checking Player Scores
const playerScore = "100";   // Score from input (string)
const winningScore = 100;    // Target score (number)

// Using strict equality
if (playerScore === winningScore) {
    console.log("You win!");  // This won't run! ❌
}

// Using loose equality  
if (playerScore == winningScore) {
    console.log("You win!");  // This runs! ✅
}

// 💡 Best Practice: Convert first, then compare strictly!
if (Number(playerScore) === winningScore) {
    console.log("You win the right way!"); // This is better! 🌟
}

// 🎯 Short-Circuit Evaluation - Stop When You Know the Answer!
const player = { name: 'Alice', score: 100 };

// && (AND) - Continues only if the left side is truthy
const hasHighScore = player.score && player.score > 50;
// First checks if score exists, then checks if it's > 50

// || (OR) - The Default Value Hero!
// If the first value is falsy, use the second one
const playerName = player.name || 'Guest';
const playerTitle = player.title || 'Beginner'; // Uses 'Beginner' if no title

// 🆕 ?? (Nullish Coalescing) - The Smarter Default!
// Only uses the default for null or undefined (not 0 or "")
const lives = player.lives ?? 3;        // Default to 3 lives
const score = player.score ?? 0;        // Default to 0 score

// Example: Why ?? is better than ||
const player2 = { score: 0, coins: null };
console.log(player2.score || 100);     // 100 ❌ (Wrong! Score was 0)
console.log(player2.score ?? 100);     // 0 ✅ (Correct! Keep the 0)
console.log(player2.coins ?? 50);      // 50 ✅ (Use default for null)

// 🎮 Real Game Example
function getPlayerStatus(player) {
    // Check multiple things safely
    const name = player?.name ?? 'Anonymous';
    const level = player?.stats?.level ?? 1;
    const health = player?.stats?.health ?? 100;
    
    return `${name} - Level ${level} - Health: ${health}`;
}

function getHighScore(player) {
    // Return the high score, or 0 if it doesn't exist
    // Hint: Use ?? operator!
}

// 🏰 Let's explore a game character's data
const gameCharacter = {
    profile: {
        stats: {
            strength: 85,
            magic: 92
        },
        guild: {
            name: 'Dragon Slayers'
        }
    },
    getInventory() {
        return { weapons: ['sword', 'shield'] };
    }
};

// ❌ OLD WAY - The Dangerous Path!
// This could crash if any part is missing
// const guildName = gameCharacter.profile.guild.name;

// ✅ NEW WAY - The Safe Path with ?.
const guildName = gameCharacter?.profile?.guild?.name;
console.log(guildName); // 'Dragon Slayers'

// 🛡️ Safely Access Missing Data
const petName = gameCharacter?.pet?.name;
console.log(petName); // undefined (no error!)

// 🎯 Safe Method Calls
const weapons = gameCharacter?.getInventory?.()?.weapons;
console.log(weapons); // ['sword', 'shield']

// 📊 Safe Array Access
const firstWeapon = gameCharacter?.getInventory?.()?.weapons?.[0];
console.log(firstWeapon); // 'sword'

// 🎮 Real Example: Checking Player Achievements
function getAchievementTitle(player, achievementIndex) {
    // This won't crash even if player, achievements, or the index doesn't exist!
    return player?.achievements?.[achievementIndex]?.title ?? 'No Achievement';
}

const player1 = { achievements: [{ title: 'First Victory' }] };
const player2 = {};

console.log(getAchievementTitle(player1, 0)); // 'First Victory'
console.log(getAchievementTitle(player2, 0)); // 'No Achievement'

// 🎮 Game Permissions System
// Each permission is a power of 2 (like binary switches!)
const ABILITIES = {
    JUMP:     1,   // 001 in binary
    RUN:      2,   // 010 in binary  
    SWIM:     4,   // 100 in binary
    FLY:      8    // 1000 in binary
};

// 🔧 Combining Abilities with | (OR)
let playerAbilities = ABILITIES.JUMP | ABILITIES.RUN;
// This gives the player both JUMP and RUN abilities!
// Binary: 001 | 010 = 011 (which is 3 in decimal)

// ✅ Checking Abilities with & (AND)
const canJump = (playerAbilities & ABILITIES.JUMP) !== 0;  // true ✅
const canSwim = (playerAbilities & ABILITIES.SWIM) !== 0;  // false ❌
const canFly = (playerAbilities & ABILITIES.FLY) !== 0;    // false ❌

// 🚀 Super Fast Math Tricks!
const fastDouble = (num) => num << 1;    // Multiply by 2
const fastHalf = (num) => num >> 1;      // Divide by 2

console.log(fastDouble(5));   // 10 (5 × 2)
console.log(fastHalf(10));    // 5 (10 ÷ 2)

// 🎯 Check if a Number is Even or Odd
const isEven = (num) => (num & 1) === 0;
console.log(isEven(4));   // true (4 is even)
console.log(isEven(7));   // false (7 is odd)

// 🎨 Real Example: Color Mixing in Games
const RED = 0xFF0000;    // Red color in hex
const GREEN = 0x00FF00;  // Green color in hex
const BLUE = 0x0000FF;   // Blue color in hex

// Mix colors using OR
const YELLOW = RED | GREEN;     // Red + Green = Yellow!
const CYAN = GREEN | BLUE;      // Green + Blue = Cyan!
const WHITE = RED | GREEN | BLUE; // All colors = White!

// 🤔 Which operation happens first?
const mystery = 3 + 4 * 2;
console.log(mystery); // 11 (not 14!)
// Why? Multiplication (*) goes before addition (+)

// 📊 Order of Operations (PEMDAS for JavaScript!)
// 1. Parentheses ()
// 2. Exponents **
// 3. Multiplication * and Division /
// 4. Addition + and Subtraction -

// 🧮 Let's Break Down a Complex Expression
const result = 3 + 4 * 2 ** 3 / 2 - 1;

// Step by step:
// 1. 2 ** 3 = 8       (exponent first)
// 2. 4 * 8 = 32       (multiplication)
// 3. 32 / 2 = 16      (division)
// 4. 3 + 16 = 19      (addition)
// 5. 19 - 1 = 18      (subtraction)

console.log(result); // 18

// 🎨 Use Parentheses to Make It Clear!
const clearResult = 3 + ((4 * (2 ** 3)) / 2) - 1;
// Much easier to understand!

// 🎮 Game Score Calculation Example
function calculateBonus(baseScore, multiplier, timeBonus) {
    // Without parentheses - confusing!
    // return baseScore + multiplier * 100 + timeBonus / 2;
    
    // With parentheses - crystal clear!
    return baseScore + (multiplier * 100) + (timeBonus / 2);
}

const finalScore = calculateBonus(500, 3, 60);
console.log(finalScore); // 500 + 300 + 30 = 830

// 🎯 Simplify Complex Checks
function canPlayLevel(player) {
    // ❌ Hard to read
    // if (player && player.level && player.level >= 10 && 
    //     player.hasKey && player.lives > 0) {
    //     return true;
    // }
    // return false;
    
    // ✅ Clean and simple!
    return player?.level >= 10 && 
           player?.hasKey && 
           player?.lives > 0;
}

// 🏃‍♂️ Performance Tip: Check Fast Things First!
function canAccessSecretArea(player) {
    // Check simple things before complex ones
    return player.level > 50 &&              // Fast check
           player.hasSpecialItem &&          // Fast check
           calculatePlayerScore(player) > 1000; // Slow calculation last
}

// 💾 Smart Caching Pattern
const getPowerUp = (() => {
    const cache = new Map();
    
    return (itemId) => {
        // Return cached value OR calculate and cache it
        if (cache.has(itemId)) {
            return cache.get(itemId);
        }
        
        const powerUp = calculatePowerUp(itemId);
        cache.set(itemId, powerUp);
        return powerUp;
    };
})();

// 🎯 Smart Filtering - Check Easy Things First!
const players = [/* imagine 10,000 players here */];

// ✅ FAST: Check simple things first
const activeVeterans = players.filter(player => 
    player.isActive &&           // Super fast check! ⚡
    player.level > 50 &&         // Still fast! 🏃
    hasCompletedAllQuests(player) // Slower check last 🐢
);

// ❌ SLOW: Don't do expensive checks first!
// const badFilter = players.filter(player =>
//     hasCompletedAllQuests(player) && // Slow! 🐌
//     player.isActive                   // Fast but too late!
// );

// 💡 Cache Values You Use Multiple Times
function processHighScores(scores) {
    const length = scores.length; // Save the length once!
    let total = 0;
    
    // Use the cached length instead of checking scores.length each time
    for (let i = 0; i < length; i++) {
        total += scores[i];
    }
    
    return total / length; // Average score
}

// 🚀 Super Fast Math Tricks!
const speedyMath = {
    // Check if number is power of 2 (like 2, 4, 8, 16...)
    isPowerOfTwo: (n) => n > 0 && (n & (n - 1)) === 0,
    
    // Quick even/odd check
    isEven: (n) => (n & 1) === 0,
    
    // Fast multiply by 2
    double: (n) => n << 1,
    
    // Fast divide by 2
    half: (n) => n >> 1
};

console.log(speedyMath.isPowerOfTwo(16)); // true
console.log(speedyMath.isEven(7));        // false
console.log(speedyMath.double(5));        // 10

// 🎮 Safe Game Calculations
const safeGameMath = {
    // Safe division (no divide by zero errors!)
    divide: (damage, armor) => {
        if (armor === 0) return damage; // Full damage if no armor
        return damage / armor;
    },
    
    // Calculate percentage safely
    getHealthPercentage: (current, max) => {
        if (max <= 0) return 0; // Avoid division by zero
        return Math.round((current / max) * 100);
    },
    
    // Safe score calculation with defaults
    calculateFinalScore: (player) => {
        // Use ?? to provide safe defaults
        const baseScore = player?.score ?? 0;
        const multiplier = player?.combo ?? 1;
        const bonus = player?.treasures?.length ?? 0;
        
        // Always return at least 0
        return Math.max(0, (baseScore * multiplier) + (bonus * 100));
    }
};

// 🔍 Safe Comparisons
const safeChecks = {
    // Check if two players have same score
    haveSameScore: (player1, player2) => {
        // Make sure both exist and have scores
        return player1?.score === player2?.score;
    },
    
    // Check if player can afford item
    canAfford: (player, itemCost) => {
        // Check types first, then compare
        return typeof player?.gold === 'number' && 
               typeof itemCost === 'number' && 
               player.gold >= itemCost;
    },
    
    // Validate player name
    isValidName: (name) => {
        return typeof name === 'string' && 
               name.length >= 3 && 
               name.length <= 20;
    }
};

// Example usage
const player = { score: 100, gold: 50 };
console.log(safeGameMath.calculateFinalScore(player)); // 100
console.log(safeChecks.canAfford(player, 30));        // true

function calculateDamage(attackPower, defenseRating) {
    // Make sure defenseRating doesn't make damage negative
    // Hint: Use Math.max() and check for valid numbers!
}

// Your challenge: Complete this character system!
const gameCharacter = {
    name: 'Hero',
    stats: { health: 100, mana: 50, level: 1 },
    inventory: ['sword', 'potion']
};

function levelUp(character) {
    // Use compound operators to:
    // - Increase level by 1
    // - Increase health by 20
    // - Double the mana
    // Your code here!
}

function calculateDamage(attacker, defender) {
    // Use optional chaining and nullish coalescing to:
    // - Safely get attack power (default: 10)
    // - Safely get defense rating (default: 5)
    // - Return damage (attack - defense, minimum 0)
    // Your code here!
}

// Test your functions!
levelUp(gameCharacter);
console.log(gameCharacter);