// 同步回调
[1, 2, 3].forEach(x => console.log(x));

// 异步回调
setTimeout(() => {
  console.log("This runs after 1 second");
}, 1000);

// 回调地狱
getUser(userId, (user) => {
  getOrders(user.id, (orders) => {
    getOrderDetails(orders[0].id, (details) => {
      getProductInfo(details.productId, (product) => {
        console.log(product);
        // 层层嵌套，难以维护
      });
    });
  });
});

// 创建Promise
function fetchData() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      let success = true;
      if (success) {
        resolve("Data loaded");
      } else {
        reject("Error occurred");
      }
    }, 1000);
  });
}

// 使用Promise
fetchData()
  .then(data => {
    console.log(data);
    return "processed";
  })
  .then(result => console.log(result))
  .catch(error => console.error(error))
  .finally(() => console.log("Done"));

// Promise组合
let p1 = Promise.resolve(1);
let p2 = Promise.resolve(2);
let p3 = Promise.resolve(3);

// Promise.all：所有都成功
Promise.all([p1, p2, p3]).then(values => {
  console.log(values);  // [1, 2, 3]
});

// Promise.race：最快的
Promise.race([p1, p2, p3]).then(value => {
  console.log(value);  // 1
});

// Promise.allSettled：等待所有完成
Promise.allSettled([
  Promise.resolve(1),
  Promise.reject("error"),
  Promise.resolve(3)
]).then(results => {
  console.log(results);
  // [{status: "fulfilled", value: 1}, 
  //  {status: "rejected", reason: "error"},
  //  {status: "fulfilled", value: 3}]
});

// Promise.any：第一个成功的
Promise.any([
  Promise.reject("error1"),
  Promise.resolve(2),
  Promise.resolve(3)
]).then(value => console.log(value));  // 2

// async函数总是返回Promise
async function getData() {
  return "data";  // 等价于 Promise.resolve("data")
}

getData().then(console.log);

// await等待Promise完成
async function loadData() {
  try {
    let data = await fetchData();
    console.log(data);
    
    let moreData = await fetchData();
    console.log(moreData);
  } catch (error) {
    console.error("Error:", error);
  }
}

// 并行执行
async function loadAll() {
  let [data1, data2, data3] = await Promise.all([
    fetchData(),
    fetchData(),
    fetchData()
  ]);
  console.log(data1, data2, data3);
}

// 顺序执行vs并行执行
async function sequential() {
  const start = Date.now();
  const a = await delay(1000);  // 1秒
  const b = await delay(1000);  // 又1秒
  console.log(`Sequential: ${Date.now() - start}ms`);  // ~2000ms
}

async function parallel() {
  const start = Date.now();
  const [a, b] = await Promise.all([
    delay(1000),
    delay(1000)
  ]);
  console.log(`Parallel: ${Date.now() - start}ms`);  // ~1000ms
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// 执行顺序
console.log("1");  // 同步

setTimeout(() => {
  console.log("2");  // 宏任务
}, 0);

Promise.resolve().then(() => {
  console.log("3");  // 微任务
});

console.log("4");  // 同步

// 输出顺序：1, 4, 3, 2

// 微任务：Promise.then, process.nextTick, MutationObserver
// 宏任务：setTimeout, setInterval, I/O, UI rendering

// 微任务在当前宏任务结束后立即执行
// 宏任务在下一个事件循环周期执行

// 实际例子
function processQueue() {
  const queue = [];
  
  return {
    add(task) {
      queue.push(task);
      // 使用微任务确保所有同步代码先执行
      Promise.resolve().then(() => {
        while (queue.length > 0) {
          const task = queue.shift();
          task();
        }
      });
    }
  };
}

async function fetchWithRetry(url, options = {}, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }
      return await response.json();
    } catch (error) {
      console.log(`Attempt ${attempt} failed: ${error.message}`);
      if (attempt === maxRetries) throw error;
      
      // 指数退避
      const delay = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

// 使用
async function loadUserData(userId) {
  try {
    const user = await fetchWithRetry(`/api/users/${userId}`);
    console.log(user);
  } catch (error) {
    console.error("Failed to load user after all retries:", error);
  }
}

// 带超时的Promise
function withTimeout(promise, ms) {
  const timeout = new Promise((_, reject) => {
    setTimeout(() => reject(new Error("Timeout")), ms);
  });
  return Promise.race([promise, timeout]);
}

// 使用
async function loadData() {
  try {
    const data = await withTimeout(fetchData(), 5000);
    console.log(data);
  } catch (error) {
    console.error(error.message);
  }
}