export type User = {
  name: string;
  email: string;
};

const user: User = {
  name: 'chinsung',
  email: 'chin_sung@naver.com',
};

// keyof User === 'name' | 'email'
const updateUser = (name: keyof User, value: string) => {
  return {
    ...user,
    [name]: value,
  };
};

updateUser(''); // wow 자동완성!!

function isValidPostAttributes(
  attributes: any
): attributes is PostMarkdownAttributes {
  return attributes?.title;
}

function isNumber(x: any): x is number {
  return typeof x === 'number';
}

function isString(x: any): x is string {
  return typeof x === 'string';
}

function hello(value: any) {
  if (isNumber(value)) {
    return value.toFixed();
  }
  if (isString(value)) {
    return value.length;
  }
  throw new Error(`hello error`);
}

enum TestStatus {
  PENDING,
  ACCEPTED,
  WRONG_ANSWER,
}
console.log(Object.values(TestStatus));
// [ 'PENDING', 'ACCEPTED', 'WRONG_ANSWER', 0, 1, 2 ]

export enum Actor {
  USER = 'USER',
  HOST = 'HOST',
  ADMIN = 'ADMIN',
}

console.log(Object.values(Actor));
// [ 'USER', 'HOST', 'ADMIN' ]

type Todo = {
  title: string;
  description: string;
};

const updateTodo = (todo: Todo, fieldsToUpdats: Partial<Todo>) => {
  return { ...todo, ...fieldsToUpdats };
};

const todo1: Todo = {
  title: 'be super',
  description: 'power overwhelming',
};

const todo2 = updateTodo(todo1, { description: 'show me the money' });

console.log(todo2);

type Todo = {
  title: string;
  description: string;
  time: string;
};

type Todo2 = Pick<Todo, 'title' | 'time'>;

class Dice {
  sto: ReturnType<typeof setTimeout>;

interface MyType {
  id: number;
  cover: string;
  outComes: Map<number, string>;
  questions: Map<number, Map<number, string>>;
}

const stringify = (object: any) => {
  for (const eachIdx in object) {
    if (object[eachIdx] instanceof Map) {
      object[eachIdx] = Array.from(object[eachIdx]);
      stringify(object);
    } else if (typeof object[eachIdx] == 'object') stringify(object[eachIdx]);
  }
  return JSON.stringify(object, null, 2);
};

const jsonString2ObjectWithMap = <ReturnType>(
  jsonString: string
): ReturnType => {
  const object = JSON.parse(jsonString);
  console.log(`-------------변환전`);
  console.log(object);

  const jsonstringToObject = (object) => {
    for (const eachIdx in object) {
      if (
        object[eachIdx] instanceof Array &&
        object[eachIdx].length > 0 &&
        object[eachIdx][0].constructor === Array
      ) {
        object[eachIdx] = new Map(object[eachIdx]);
        jsonstringToObject(object);
      } else if (typeof object[eachIdx] == 'object')
        jsonstringToObject(object[eachIdx]);
    }

    return object;
  };

  console.log(`-------------변환후`);
  const result = jsonstringToObject(object);

  console.log(result);

  return result;
};

const myObject: MyType = {
  id: 30,
  cover: 'cover',
  outComes: new Map([
    [0, 'o1'],
    [1, 'o2'],
  ]),
  questions: new Map([
    [
      0,
      new Map([
        [1, 'answer1'],
        [2, 'ansewr2'],
      ]),
    ],
    [
      1,
      new Map([
        [1, 'ansewr1'],
        [2, 'ansewr2'],
      ]),
    ],
    [2, new Map([])],
  ]),
};

console.log(`-----------------map을 포함한 오브젝트 json stringify`);
const rst = stringify(myObject);
console.log(rst);
console.log(typeof rst);

console.log(`-----------------다시 오브젝트화`);
const result = jsonString2ObjectWithMap<MyType>(rst);

-----------------map을 포함한 오브젝트 json stringify
{
  "id": 30,
  "cover": "cover",
  "outComes": [
    [
      0,
      "o1"
    ],
    [
      1,
      "o2"
    ]
  ],
  "questions": [
    [
      0,
      [
        [
          1,
          "answer1"
        ],
        [
          2,
          "ansewr2"
        ]
      ]
    ],
    [
      1,
      [
        [
          1,
          "ansewr1"
        ],
        [
          2,
          "ansewr2"
        ]
      ]
    ],
    [
      2,
      []
    ]
  ]
}
string
-----------------다시 오브젝트화
-------------변환전
{
  id: 30,
  cover: 'cover',
  outComes: [ [ 0, 'o1' ], [ 1, 'o2' ] ],
  questions: [ [ 0, [Array] ], [ 1, [Array] ], [ 2, [] ] ]
}
-------------변환후
{
  id: 30,
  cover: 'cover',
  outComes: Map { 0 => 'o1', 1 => 'o2' },
  questions: Map { 0 => [ [Array], [Array] ], 1 => [ [Array], [Array] ], 2 => [] }
}

const stringify = (object: any) => {
  for (const eachIdx in object) {
    if (object[eachIdx] instanceof Map) {
      object[eachIdx] = Array.from(object[eachIdx]);
      stringify(object);
    } else if (typeof object[eachIdx] == 'object') stringify(object[eachIdx]);
  }
  return JSON.stringify(object, null, 2);
};

interface myType {
  name: string;
  age: number;
}

const me: myType = {
  name: 'name',
  age: 99,
};

[1, 2, 3, 4, 5].forEach(function (this: myType, value, index) {
  console.log(this);
  console.log(value, index);
}, me);
// 0 1 { name: 'name', age: 11 }
// 1 2 { name: 'name', age: 11 }
// 2 3 { name: 'name', age: 11 }

class MyClass {
  me: Person;

  constructor(person: Person) {
    this.me = person;
  }

  someFunction() {
    [1, 2, 3].forEach(function (value) {
      console.log(value, this);
    });
  }

  someFunctionBindThis() {
    [1, 2, 3, 4].forEach(function (this: MyClass, value) {
      console.log(value, this);
    }, this);
  }

  someFunctionWithArrow() {
    [1, 2, 3].forEach((value) => {
      console.log(value, this);
    });
  }
}

const myclass = new MyClass(me);
myclass.someFunction();
// 1 undefined
// 2 undefined
// 3 undefined

myclass.someFunctionBindThis();
// 1 MyClass { me: { name: 'name', age: 11 } }
// 2 MyClass { me: { name: 'name', age: 11 } }
// 3 MyClass { me: { name: 'name', age: 11 } }

myclass.someFunctionWithArrow();
// 1 MyClass { me: { name: 'name', age: 11 } }
// 2 MyClass { me: { name: 'name', age: 11 } }
// 3 MyClass { me: { name: 'name', age: 11 } }