// ============================================
// ❌ 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);