// set today to December 24
let today = {
  month: 12,
  day: 24,
};

let tomorrow = {
  year: today.year,
  month: today.month,
  day: today.day + 1,
};

let dayAfterTomorrow = {
  year: tomorrow.year,
  month: tomorrow.month,
  day: tomorrow.day + 1 <= 31 ? tomorrow.day + 1 : 1,
};

class SimpleDate {
  constructor(year, month, day) {
    // Check that (year, month, day) is a valid date
    // ...

    // If it is, use it to initialize "this" date
    this._year = year;
    this._month = month;
    this._day = day;
  }

  addDays(nDays) {
    // Increase "this" date by n days
    // ...
  }

  getDay() {
    return this._day;
  }
}

// "today" is guaranteed to be valid and fully initialized
let today = new SimpleDate(2000, 2, 28);

// Manipulating data only through a fixed set of functions ensures we maintain valid state
today.addDays(1);

class SimpleDate {
  constructor(year, month, day) {
    // Check that (year, month, day) is a valid date
    // ...

    // If it is, use it to initialize "this" date's ordinary variables
    let _year = year;
    let _month = month;
    let _day = day;

    // Methods defined in the constructor capture variables in a closure
    this.addDays = function(nDays) {
      // Increase "this" date by n days
      // ...
    }

    this.getDay = function() {
      return _day;
    }
  }
}

let SimpleDate = (function() {
  let _yearKey = Symbol();
  let _monthKey = Symbol();
  let _dayKey = Symbol();

  class SimpleDate {
    constructor(year, month, day) {
      // Check that (year, month, day) is a valid date
      // ...

      // If it is, use it to initialize "this" date
      this[_yearKey] = year;
      this[_monthKey] = month;
      this[_dayKey] = day;
    }

    addDays(nDays) {
      // Increase "this" date by n days
      // ...
    }

    getDay() {
      return this[_dayKey];
    }
  }

  return SimpleDate;
}());

let SimpleDate = (function() {
  let _years = new WeakMap();
  let _months = new WeakMap();
  let _days = new WeakMap();

  class SimpleDate {
    constructor(year, month, day) {
      // Check that (year, month, day) is a valid date
      // ...

      // If it is, use it to initialize "this" date
      _years.set(this, year);
      _months.set(this, month);
      _days.set(this, day);
    }

    addDays(nDays) {
      // Increase "this" date by n days
      // ...
    }

    getDay() {
      return _days.get(this);
    }
  }

  return SimpleDate;
}());

// Get a reference to the "getDay" function
let getDay = SimpleDate.prototype.getDay;

getDay.call(today); // "this" will be "today"
getDay.call(tomorrow); // "this" will be "tomorrow"

tomorrow.getDay(); // same as last line, but "tomorrow" is passed implicitly

class SimpleDate {
  static setDefaultDate(year, month, day) {
    // A static property can be referred to without mentioning an instance
    // Instead, it's defined on the class
    SimpleDate._defaultDate = new SimpleDate(year, month, day);
  }

  constructor(year, month, day) {
    // If constructing without arguments,
    // then initialize "this" date by copying the static default date
    if (arguments.length === 0) {
      this._year = SimpleDate._defaultDate._year;
      this._month = SimpleDate._defaultDate._month;
      this._day = SimpleDate._defaultDate._day;

      return;
    }

    // Check that (year, month, day) is a valid date
    // ...

    // If it is, use it to initialize "this" date
    this._year = year;
    this._month = month;
    this._day = day;
  }

  addDays(nDays) {
    // Increase "this" date by n days
    // ...
  }

  getDay() {
    return this._day;
  }
}

SimpleDate.setDefaultDate(1970, 1, 1);

let defaultDate = new SimpleDate();

class Employee{
	constructor(firstName, familyName){
		this._firstName = firstName;
		this._familyName = familyName;
	}

	getFullName(){
		return `${this._firstName} ${this._familyName}`;
	}
}

class Manager{
	constructor(firstName, familyName){
		this._firstName = firstName;
		this._familyName = familyName;
		this._managedEmployees = [];
	}

	getFullName(){
		return `${this._firstName} ${this._familyName}`;
	}

	addEmployee(employee){
		this._managedEmployees.push(employee);
	}
}

class Employee{
	constructor(firstName, familyName){
		this._firstName = firstName;
		this._familyName = familyName;
	}

	getFullName(){
		return `${this._firstName} ${this._familyName}`;
	}
}

class Manager extends Employee{
	constructor(firstName, familyName){
		super(firstName, familyName);
		this._managedEmployees = [];
	}

	addEmployee(employee){
		this._managedEmployees.push(employee);
	}
}

class Rectangle{
  set width(w){
    this._width = w;
  }

  get width(){
    return this._width;
  }

  set height(h){
    this._height = h;
  }

  get height(){
    return this._height;
  }
}

function f(rectangle){
  rectangle.width = 5;
  rectangle.height = 4;

  if(rectangle.width * rectangle.height !== 20){
    throw new Error("expected the rectangle's area");
  }
}
// square 는(is-a) rectangle 이 올바른가요?
class Square extends Rectangle{
  set width(w){
    super.width = w;
    super.height = w;
  }

  set height(h){
    super.height = h;
    super.width = h;
  }
}
// square의 대체제로 rectangle을 할 수 있을까요?
f(new Square()); //error

class Employee{
  constructor(firstName, familyName){
    this._firstName = firstName;
    this._familyName = familyName;
  }

  getFullName(){
    return `${this._firstName} ${this._familyName}`;
  }
}

class Group{
  constructor(manager /* : Employee*/){
    this._manager = manager;
    this._managedEmployees = [];
  }

  addEmployee(employee){
    this._managedEmployees.push(employee);
  }
}

// 공통 슈퍼클래스
class Cache{
  get(key, defaultValue){
    let value = this._doGet(key);
    if(value === undefined || value === null){
      return defaultValue;
    }
  }

  set(key, value){
    if(key === undefined || key === null){
      throw new Error('invalid argument');
    }
    this._doSet(key, value);
  }

  // overriden
  // _doGet()
  // _doSet()
}

// 서브클래스는 새로운 public 메서드를 정의하지 않습니다.
// public 인터페이스는 슈퍼클래스에 정의되어있습니다.
class ArrayCache extends Cache{
  _doGet(){
    // ...
  }

  _doSet(){
   // ...
  }
}

class LocalStorageCache extends Cache{
  _doGet(){
    // ...
  }

  _doSet(){
    // ...
  }
}

class LocalStorageCache extends Cache{
  _doGet(){
    // ...
  }

  _doSet(){
    // ...
  }
}

//함수는 슈퍼클래스 인터페이스를 통하여 상호작용하여 모든 캐시에서 다형성으로 작동 할 수 있습니다.
function compute(cache){
  let cached = cache.get('result');
  if(!cached){
    let result = // ...
    cache.set('result', result);
  }

  // ...
}

compute(new ArrayCache());
compute(new LocalStorageCache());

//ES5
function B(){}
B.f = function(){};

function D(){}
D.prototype = Object.create(B.prototype);

D.f(); //error

//ES6
class B{
  static f(){}
}

class D extends B {}
D.f(); //ok

//es5
function D(){
  Array.apply(this, arguments);
}

D.prototype = Object.create(Array.prototype);

var d = new D();
d[0] = 42;

d.length; // 0 - bad, no array exotic behavior

//es6
class D extends Array{}
let d = new D();
d[0] = 42;
d.length; // 1 - good, array exotic behavior

let transmitter = {
  transmit(){}
};

let receiver = {
  receive(){}
};

// Create a proxy object that intercepts property accesses and forwards to each parent,
// returning the first defined value it finds
let inheritsFromMultiple = new Proxy([transmitter, receiver], {
  get: function(proxyTarget, propertyKey){
    const foundParent = proxyTarget.find(parent => parent[propertyKey] !== undefined);
    return foundParent && foundParent[propertyKey];
  }
});

inheritsFromMultiple.transmit();// works
inheritsFromMultiple.receive(); // works

function makeTransmitterClass(Superclass = Object){
  return class Transmitter extends Superclass{
    transmit(){}
  };
}

function makeReceiverClass(Superclass = Object){
  return class Receiver extends Superclass{
    receive(){}
  };
}

class InheritsFromMultiple extends makeTransmitterClass(makeReceiverClass()){}

let inheritsFromMultiple = new InheritsFromMultiple();

inheritsFromMultiple.transmit();// works
inheritsFromMultiple.receive(); // works