Bất đồng bộ: Callbacks, Promise, async/await

console.log('A');

setTimeout(() => console.log('B'), 0);

Promise.resolve().then(() => console.log('C'));

console.log('D');

// setTimeout là API callback đơn giản nhất
setTimeout(() => {
  console.log('1 giây sau');
}, 1000);

// Node.js style: error-first callback
fs.readFile('data.txt', 'utf8', (err, data) => {
  if (err) return console.error(err);
  console.log(data);
});

getUser(userId, (err, user) => {
  if (err) return handleError(err);
  getPosts(user.id, (err, posts) => {
    if (err) return handleError(err);
    getComments(posts[0].id, (err, comments) => {
      if (err) return handleError(err);
      getAuthor(comments[0].authorId, (err, author) => {
        if (err) return handleError(err);
        console.log(author);
        // thụt vào sâu, error xử lý lặp lại, khó debug
      });
    });
  });
});

const p = new Promise((resolve, reject) => {
  // Đây là "executor" — chạy đồng bộ ngay lập tức
  setTimeout(() => {
    const ok = Math.random() > 0.5;
    if (ok) resolve(42);            // → Fulfilled với value 42
    else   reject(new Error('Hỏng'));  // → Rejected với reason
  }, 1000);
});

// Helper tạo sẵn:
Promise.resolve(42);              // Fulfilled ngay với 42
Promise.reject(new Error('x'));  // Rejected ngay

p.then(
  (value) => console.log('OK:', value),  // onFulfilled
  (reason) => console.error('Lỗi:', reason) // onRejected
);

// Dạng phổ biến hơn: tách then/catch
p
  .then((value) => console.log('OK:', value))
  .catch((reason) => console.error('Lỗi:', reason))
  .finally(() => console.log('Xong, dù OK hay lỗi'));

getUser(userId)
  .then(user => getPosts(user.id))          // return Promise → flatten
  .then(posts => getComments(posts[0].id))
  .then(comments => getAuthor(comments[0].authorId))
  .then(author => console.log(author))
  .catch(handleError);  // 1 catch bắt mọi lỗi trong chain

// 1. Return value thường → Promise.resolve(value)
Promise.resolve(1)
  .then(x => x + 1)        // → Promise<2>
  .then(x => console.log(x));  // 2

// 2. Return Promise → auto flatten
Promise.resolve(1)
  .then(x => Promise.resolve(x + 10))
  .then(x => console.log(x));  // 11

// 3. Throw trong then → next .catch
Promise.resolve(1)
  .then(() => { throw new Error('oops'); })
  .then(() => console.log('skip'))    // bỏ qua
  .catch(err => console.error(err.message));  // 'oops'

const [user, posts, settings] = await Promise.all([
  fetchUser(id),
  fetchPosts(id),
  fetchSettings(id),
]);
// 3 request chạy song song, kết quả theo đúng thứ tự

// Cảnh báo: 1 lỗi → all reject, kết quả 2 cái kia bị mất
try {
  await Promise.all([ok1(), fail(), ok2()]);
} catch (e) {
  console.error(e);  // chỉ thấy lỗi của fail(), không biết ok1/ok2
}

const results = await Promise.allSettled([
  fetchUser(id),
  fetchPosts(id),
  fetchSettings(id),
]);

for (const r of results) {
  if (r.status === 'fulfilled') console.log('OK:', r.value);
  else                            console.error('Lỗi:', r.reason);
}
// Hữu ích cho: dashboard có nhiều widget độc lập,
// 1 widget lỗi không nên làm sập cả page.

// race: cái nào settle đầu (resolve hay reject) → kết quả đó
const result = await Promise.race([
  fetchData(),
  new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 3000)),
]);
// Pattern timeout: cái nào nhanh hơn thắng

// any: cái nào resolve đầu (bỏ qua reject)
try {
  const winner = await Promise.any([
    fetch('https://mirror1.example/data'),
    fetch('https://mirror2.example/data'),
    fetch('https://mirror3.example/data'),
  ]);
  // Lấy mirror nào trả lời thành công đầu tiên
} catch (e) {
  // AggregateError nếu TẤT CẢ đều reject
  console.error(e.errors);
}

async function loadProfile(userId) {
  const user = await fetchUser(userId);
  const posts = await fetchPosts(user.id);
  const author = await fetchAuthor(posts[0].authorId);
  return author;
}

// Tương đương Promise chain:
function loadProfile(userId) {
  return fetchUser(userId)
    .then(user => fetchPosts(user.id))
    .then(posts => fetchAuthor(posts[0].authorId));
}

// Async function trả Promise:
loadProfile(1).then(console.log);  // vẫn dùng .then được

// Mỗi await dừng function. 3 request chạy NỐI TIẾP nhau.
// Tổng thời gian = sum(t1, t2, t3) ≈ 3 giây nếu mỗi cái 1 giây.
async function loadAll() {
  const a = await fetch(url1);
  const b = await fetch(url2);
  const c = await fetch(url3);
  return [a, b, c];
}

// Khởi tạo 3 Promise NGAY, rồi await Promise.all.
// Tổng thời gian = max(t1, t2, t3) ≈ 1 giây.
async function loadAll() {
  const [a, b, c] = await Promise.all([
    fetch(url1),
    fetch(url2),
    fetch(url3),
  ]);
  return [a, b, c];
}

// Hoặc cách viết khác — cũng song song:
async function loadAll2() {
  const pa = fetch(url1);  // kick off ngay
  const pb = fetch(url2);
  const pc = fetch(url3);
  return [await pa, await pb, await pc];
}

async function main() {
  try {
    const data = await fetchData();
    return data;
  } catch (err) {
    console.error('Lỗi:', err);
    return null;
  } finally {
    cleanup();
  }
}

fetchData()
  .then(data => render(data))
  .catch(err => console.error(err));

// Tip: gắn .catch ở cuối mọi chain để bắt lỗi propagate

// Browser
window.addEventListener('unhandledrejection', event => {
  console.error('Unhandled:', event.reason);
  event.preventDefault();  // tránh log mặc định
});

// Node.js
process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled:', reason);
});

const controller = new AbortController();
const { signal } = controller;

fetch('https://example.com/big-file', { signal })
  .then(r => r.json())
  .then(console.log)
  .catch(err => {
    if (err.name === 'AbortError') {
      console.log('Đã huỷ');
    } else {
      console.error(err);
    }
  });

// 5 giây sau: huỷ
setTimeout(() => controller.abort(), 5000);

async function fetchWithTimeout(url, ms) {
  const ctrl = new AbortController();
  const timer = setTimeout(() => ctrl.abort(), ms);
  try {
    const res = await fetch(url, { signal: ctrl.signal });
    return await res.json();
  } finally {
    clearTimeout(timer);
  }
}

// ES2022: AbortSignal.timeout(ms) làm gọn hơn nữa
await fetch(url, { signal: AbortSignal.timeout(5000) });

console.log('1');

setTimeout(() => console.log('2'), 0);

Promise.resolve().then(() => {
  console.log('3');
  Promise.resolve().then(() => console.log('4'));
});

setTimeout(() => console.log('5'), 0);

Promise.resolve().then(() => console.log('6'));

console.log('7');

// Output: 1, 7, 3, 6, 4, 2, 5

async function heavy() {
  let sum = 0;
  for (let i = 0; i < 1e10; i++) sum += i;  // block 10+ giây
  return sum;
}

// Gọi heavy() trong browser → UI freeze hoàn toàn.
// async KHÔNG biến CPU-bound thành non-blocking.

// main.js
const worker = new Worker('./heavy-worker.js');
worker.postMessage({ start: 0, end: 1e10 });
worker.onmessage = (e) => console.log('kết quả', e.data);

// heavy-worker.js — chạy trên thread riêng
onmessage = (e) => {
  let sum = 0;
  for (let i = e.data.start; i < e.data.end; i++) sum += i;
  postMessage(sum);
};