// var - Function scoped (pre-ES6)
function oldWay() {
  var x = 1;
  if (true) {
    var x = 2;  // Same variable!
    console.log(x);  // 2
  }
  console.log(x);  // 2 - var leaked out
}

// let/const - Block scoped (ES6+)
function newWay() {
  let x = 1;
  if (true) {
    let x = 2;  // Different variable!
    console.log(x);  // 2
  }
  console.log(x);  // 1 - let stayed in block
}

let globalAge = 23; // Global variable

function printAge(age) {
  var varAge = 34; // Function scoped

  if (age > 0) {
    // Block-scoped variable
    const constAge = age * 2;
    console.log(constAge);  // Works!
  }

  // ERROR! constAge only exists in if block
  console.log(constAge);
}

printAge(globalAge);

// ERROR! varAge only exists in function
console.log(varAge);

function makeAdding(firstNumber) {
  // "first" is scoped within makeAdding
  const first = firstNumber;

  return function resulting(secondNumber) {
    // "second" is scoped within resulting
    const second = secondNumber;
    return first + second;  // Still access first!
  }
}

const add5 = makeAdding(5);
console.log(add5(2));  // 7
console.log(add5(10)); // 15

const name = "Bob";
const age = 28;
const color = "red";

// The old way (redundant)
const oldObject = { name: name, age: age, color: color };

// The new way (clean!)
const newObject = { name, age, color };

// Bonus: Great for console.log!
console.log(name, age, color);
// Bob 28 red (messy)

console.log({ name, age, color });
// { name: "Bob", age: 28, color: "red" }

// Object destructuring
const obj = { a: 1, b: 2 };
const { a, b } = obj;
// Creates variables a and b

// Array destructuring
const array = [1, 2, 3, 4, 5];
const [zerothEle, firstEle] = array;
// Creates variables for first two elements

// Destructuring in function parameters
function createPlayer({ name, level }) {
  return { name, level };
}
createPlayer({ name: "Link", level: 50 });

function createUser(name) {
  const discordName = "@" + name;

  // Private variable - not returned!
  let reputation = 0;

  // Methods using closure
  const getReputation = () => reputation;
  const giveReputation = () => reputation++;

  return { name, discordName,
           getReputation, giveReputation };
}

const josh = createUser("josh");
josh.giveReputation();
josh.giveReputation();

console.log(josh.reputation);      // undefined!
console.log(josh.getReputation()); // 2

// Base factory
function createUser(name) {
  const getReputation = () => reputation;
  const giveReputation = () => reputation++;
  let reputation = 0;

  return { name, getReputation, giveReputation };
}

// Extended factory
function createPlayer(name, level) {
  const { getReputation, giveReputation } = createUser(name);

  const increaseLevel = () => level++;

  return { name, getReputation, giveReputation,
           increaseLevel };
}

function createUser(name) {
  const getReputation = () => reputation;
  const giveReputation = () => reputation++;
  let reputation = 0;

  return { name, getReputation, giveReputation };
}

function createPlayer(name, level) {
  const user = createUser(name);

  const increaseLevel = () => level++;

  // Merge user properties with new ones
  return Object.assign({}, user, { increaseLevel });
}

const player = createPlayer("Link", 50);
player.giveReputation();
player.increaseLevel();

// Regular factory - can call multiple times
function createCalculator() {
  const add = (a, b) => a + b;
  const sub = (a, b) => a - b;
  return { add, sub };
}

// IIFE - runs once immediately
const calculator = (function() {
  const add = (a, b) => a + b;
  const sub = (a, b) => a - b;
  return { add, sub };
})();  // <-- Note the () at the end!

calculator.add(3, 5);  // 8

const calculator = (function() {
  // Private helper function
  const validate = (a, b) => {
    if (typeof a !== 'number' ||
        typeof b !== 'number') {
      throw new Error('Must be numbers');
    }
  };

  // Public API
  const add = (a, b) => {
    validate(a, b);
    return a + b;
  };

  const sub = (a, b) => {
    validate(a, b);
    return a - b;
  };

  return { add, sub };  // Only these exposed
})();

calculator.add(3, 5);      // 8
calculator.validate(1, 2); // undefined!

// Without namespacing - DISASTER!
function add(a, b) { return a + b; }
function add(a, b) { return String(a) + String(b); }
// Which add() are we calling?

// With namespacing - CLEAR!
const mathOps = (function() {
  const add = (a, b) => a + b;
  return { add };
})();

const stringOps = (function() {
  const add = (a, b) => String(a) + String(b);
  return { add };
})();

mathOps.add(2, 3);     // 5
stringOps.add(2, 3);   // "23"

// Module pattern for gameboard (only need one)
const Gameboard = (function() {
  const board = ['', '', '', '', '', '', '', '', ''];

  const getBoard = () => board;
  const setMark = (index, mark) => {
    board[index] = mark;
  };
  const reset = () => board.fill('');

  return { getBoard, setMark, reset };
})();

// Factory for players (need multiple)
const createPlayer = (name, mark) => {
  return { name, mark };
};

// Module pattern for game controller
const GameController = (function() {
  // Game logic here
})();