// ============================================
// ❌ JS 방식 — IDE 가 user, orders, items 의 타입을 모름
// ============================================

function fetchUser(id) {
  return new Promise((resolve) => {
    setTimeout(() => resolve({ id, name: '홍길동' }), 300);
  });
}

function fetchOrders(uid) {
  return new Promise((resolve) => {
    setTimeout(() => resolve([{ id: 1, item: '책' }]), 300);
  });
}

fetchUser(42)
  .then((user) => {
    // user.name?  user.id?  user.email?  IDE 자동완성 없음
    console.log(user);
    return fetchOrders(user.id);
  })
  .then((orders) => {
    // orders 가 배열인지 객체인지 IDE 가 모름
    // orders[0].item 오타 시 런타임에서야 발견
    console.log(orders);
  });

// 위험 포인트:
// - user.naem (오타) → 컴파일 통과, 실행 시 undefined
// - orders.item   (배열인데 객체처럼 접근) → 런타임 undefined
// - fetchUser('42') (id 에 문자열) → 컴파일 통과, 동작은 묘하게 어긋남

// ============================================
// ✅ TS 방식 — 타입이 명시되어 IDE 가 매 단계 도와줌
// 실행: tsx promise-demo.ts
// ============================================

// 예제 1: 가장 간단한 Promise
const 피자주문 = (): Promise<string> => {
  //              ↑ 반환 타입: Promise<string>
  return new Promise<string>((resolve) => {
    //                ↑ Promise 가 담을 값의 타입
    console.log('📞 주문 전화함');
    setTimeout(() => resolve('🍕'), 1000);
  });
};

피자주문().then((피자: string) => {
  //                ↑ 받는 값 타입
  console.log('받음:', 피자);
});

// 예제 2: 체이닝 (타입 추론 활용)
const 주문 = (음식: string, 시간: number): Promise<string> =>
  new Promise<string>((resolve) => setTimeout(() => resolve(음식), 시간));

주문('🍕 피자', 500)
  .then((음식) => {              // 자동 추론: string
    console.log('1️⃣ 받음:', 음식);
    return 주문('🥤 콜라', 500);
  })
  .then((음식) => {
    console.log('2️⃣ 받음:', 음식);
    return 주문('🍟 감튀', 500);
  })
  .then((음식) => console.log('3️⃣ 받음:', 음식));

// 예제 3: 실패 처리 (에러 타입 명시)
const 주문하기 = (성공할까: boolean): Promise<string> => {
  return new Promise<string>((resolve, reject) => {
    setTimeout(() => {
      if (성공할까) resolve('🍕 피자 도착!');
      else reject(new Error('😭 가게가 문 닫음'));
    }, 500);
  });
};

주문하기(false)
  .then((피자) => console.log('성공:', 피자))
  .catch((에러: Error) => console.log('❌ 실패:', 에러.message));

// 예제 4: 실무 코드 (interface 로 타입 정의)
interface User {
  id: number;
  name: string;
}
interface Order {
  id: number;
  item: string;
}

const wait = (ms: number): Promise<void> =>
  new Promise((r) => setTimeout(r, ms));

const fetchUser = (id: number): Promise<User> =>
  wait(300).then(() => ({ id, name: '홍길동' }));

const fetchOrders = (uid: number): Promise<Order[]> =>
  wait(300).then(() => [{ id: 1, item: '책' }]);

fetchUser(42)
  .then((user: User) => {
    // user.name?  user.id?  ← IDE 자동완성 OK
    // user.naem  ← 컴파일이 즉시 거부 (이 줄에 빨간 줄)
    return fetchOrders(user.id);
  })
  .then((orders: Order[]) => {
    // orders[0].item ← 추론됨
  });

// 예제 5: async/await (TS 추천 방식)
const 작업 = (이름: string, ms: number): Promise<string> =>
  new Promise((r) => setTimeout(() => r(이름), ms));

const 실행 = async (): Promise<void> => {
  const a: string = await 작업('A', 200);
  const b: string = await 작업('B', 200);
  const c: string = await 작업('C', 200);
  console.log(a, b, c);
};

// 예제 6: Promise.all — 튜플 타입으로 추론
const [피자, 콜라, 감튀]: [string, string, string] = await Promise.all([
  주문('🍕', 1000),
  주문('🥤', 1000),
  주문('🍟', 1000),
]);
// 👆 TS 는 위치별 타입을 보존 — 섞이면 [string, number, User] 처럼 정확히

// 예제 7: 제네릭 Promise 헬퍼 (어떤 타입이든 받음)
const delay = <T>(value: T, ms: number): Promise<T> =>
  new Promise((r) => setTimeout(() => r(value), ms));

const 숫자: number = await delay(42, 300);              // T = number
const 문자열: string = await delay('안녕', 300);          // T = string
const 객체: { name: string } = await delay({ name: '홍길동' }, 300);