// 원시 타입 변수에 대한 타입 검사
let firstname: string = "kim";
firstname = 10; // Type 'number' is not assignable to type 'string'

// 객체 타입 변수에 대한 타입 검사
let sportsCar: {
    name: string,
    isGasoline: boolean
} = {
    name: "Porshe",
    isGasoline: false,
};

// 함수 인자에 대한 타입 검사
function add(x: number, y: number) {
    return x + y;
}
add(10, 20); // 30
add(10, "인자"); // Argument of type 'string' is not assignable to parameter of type 'number'

// 함수 반환값에 대한 인자 타입
function test(x: number): number {
    return 10 + x;
}

let x = 3;
x = 30; // x: number

// 특정 타입에 대해 별칭을 붙여 사용할 수 있음
type Point = {
  x: number;
  y: number;
};
 
function printCoord(pt: Point) {
	console.log("좌표의 x값은 " + pt.x);
	console.log("좌표의 y값은" + pt.y);
}
 
printCoord({ x: 100, y: 100 });

interface Point = {
  x: number;
  y: number;
};
 
function printCoord(pt: Point) {
	console.log("좌표의 x값은 " + pt.x);
	console.log("좌표의 y값은" + pt.y);
}
 
printCoord({ x: 100, y: 100 });

// 인터페이스의 속성 추가
interface Window {
	title: string;
}

interface Window {
	ts: TypeScriptAPI;
}

const src = 'const a = "Hello World"';
window.ts.transpileModule(src, {});

// 타입 별칭의 속성 추가는 불가능
type Window = {
	title: string;
}

type Window = {
	ts: TypeScriptAPI;
}
 // Error: Duplicate identifier 'Window'

class Point {
	public x: number;
	private y: number;
	constructor(x: number, y: number) {
		// 클래스 프로퍼티수에 값을 할당
		this.x = x;
		this.y = y;
	}
	scale(n: number): void {
		this.x *= n;
		this.y *= n;
	}
}
 
const pt = new Point(10, 20);

interface Pingable {
	ping(): void;
}
 
class Sonar implements Pingable {
	ping() {
		console.log("ping!");
	}
}
 
class Ball implements Pingable {
	// 오류: Ball은 Pingable의 메서드인 ping을 구현하고 있지 않음
	// Class 'Ball' incorrectly implements interface 'Pingable'.
	// Property 'ping' is missing in type 'Ball' but required in type 'Pingable'.
	pong() {
		console.log("pong!");
	}
}

// CASE 1: 메서드 인자 이름을 바꾼 경우
interface Checkable {
	check(name: string): boolean;
}
 
class NameChecker implements Checkable {
	check(s: string) {
	// 인자 이름을 바꾸어도, 인자 갯수와 타입, 그리고 반환값은 동일하므로 
	// 별도의 에러 발생 X
		return s.toLowerCase() === "ok";
	}
}

// CASE 2: 실제 클래스에는 존재하지 않는 프로퍼티 참조하기
interface A {
	x: number;
	y?: number;
}
class C implements A {
	x = 0;
}
const c = new C();
c.y = 10; // ERROR: Property 'y' does not exist on type 'C'

// UP이 1로 초기화되어있으므로, 이어지는 멤버들은 모두 auto-increment의 형태로 증가함
// 또한 `= 1`을 생략할 수도 있는데, 이 경우 Up은 0으로 초기화됨
enum Direction {
	Up = 1,
	Down,
	Left,
	Right,
}

// 또는 아래와 같이 문자열 기반의 Enum도 가능함
// 이 경우 모든 멤버들은 문자열 리터럴이나 다른 문자열 Enum 멤버 값으로 초기화되어야 함
enum Direction {
	Up = "UP",
	Down = "DOWN",
	Left = "LEFT",
	Right = "RIGHT",
}

// 함수에서의 제네릭
function identity<Type>(arg: Type): Type {
  return arg;
}

// 1. 명시적으로 <>를 통해 타입 설정
let output = identity<string>("myString"); // output: string

// 2. 타입 추론을 통한 타입 설정(권장되진 않음)
let output = identity("myString"); // output: string

// 클래스에서의 제네릭
class GenericNumber<NumType> {
  zeroValue: NumType;
  add: (x: NumType, y: NumType) => NumType;
}
 
let myGenericNumber = new GenericNumber<number>();

// typeof
function printAll(strs: string | string[] | null) {
	if (typeof strs === "string") {
		// 이 시점에서 strs는 string
		console.log(strs);
	} else {
		// do nothing
	}
}

// 사용자 지정 타입 가드
function isFish(pet: Fish | Bird): pet is Fish {
	return (pet as Fish).swim !== undefined;
}

let pet = getSmallPet();
 
if (isFish(pet)) { 
	// 타입 가드를 통과했으므로 pet은 Fish
	pet.swim();
} else {
	// pet은 Fish | Bird 인데 Fish가 아니므로 Bird 일 수 밖에 없다는 것을 유추
	pet.fly();
}

function printId(id: number | string) {
	console.log("Your ID is: " + id);
	if(typeof id === "string") {
		// 이 지점에서 id는 string임
		console.log(id.toUpperCase());
	} else {
		// 이 지점에서 id는 number임
	}
}
// OK
printId(101);
// OK
printId("202");
// Error
printId({ myId: 22342 }); // Argument of type '{ myID: number; }' is not assignable to parameter of type 'string | number'.

function printName(obj: { first: string; last?: string }) {
	// last는 옵셔널 프로퍼티이므로 string | undefined로 추론됨
	// 따라서 'obj.last' is possibly 'undefined'. 라는 에러가 발생
	console.log(obj.last.toUpperCase());

	// 'obj.last' is possibly 'undefined'.
	if (obj.last !== undefined) {
		// 하지만 이렇게 타입 가드를 통해 타입을 좁히면 string 타입으로 추론
		console.log(obj.last.toUpperCase());
	}
	
	// 또는 최신 자바스크립트 문법인 옵셔널 체이닝 문법을 사용해 접근할 수도 있음
	// 다만 이 경우에는 정상적인 동작을 하지 않을 수도 있음
	console.log(obj.last?.toUpperCase());
}
// Both OK
printName({ first: "Bob" });
printName({ first: "Alice", last: "Alisson" });

function first() {
// 데코레이터 팩토리 함수
  console.log("first(): factory evaluated");
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
	// 이 부분이 실제 데코레이터
	console.log("first(): called");
  };
}
 
function second() {
  console.log("second(): factory evaluated");
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
	console.log("second(): called");
  };
}
 
class ExampleClass {
  @first()
  @second()
  method() {}
}
// 실행 순서
// first(): factory evaluated
// second(): factory evaluated
// second(): called
// first(): called