⚡ JavaScript Async Programming

// Cách tạo Promise với constructor
function layThongTinNguoiDung(userId) {
    // Trả về một Promise mới
    return new Promise((resolve, reject) => {
        // resolve: hàm gọi khi thành công
        // reject: hàm gọi khi thất bại
        
        console.log(`🔍 Bắt đầu lấy thông tin user ${userId}...`);
        
        // Mô phỏng tác vụ bất đồng bộ với setTimeout
        setTimeout(() => {
            // Giả lập điều kiện thành công/thất bại
            if (userId > 0) {
                // ✅ Trường hợp THÀNH CÔNG
                const thongTinUser = {
                    id: userId,
                    ten: 'Lê Văn C',
                    email: 'levanc@example.com',
                    tuoi: 28,
                    diaChi: 'TP.HCM',
                    soDienThoai: '0987654321'
                };
                
                // Gọi resolve() để báo hiệu thành công
                // Dữ liệu truyền vào resolve sẽ được truyền cho .then()
                resolve(thongTinUser);
                
            } else {
                // ❌ Trường hợp THẤT BẠI
                const loi = new Error(`User ID không hợp lệ: ${userId}. ID phải là số dương.`);
                
                // Gọi reject() để báo hiệu thất bại
                // Error truyền vào reject sẽ được truyền cho .catch()
                reject(loi);
            }
        }, 1500); // Delay 1.5 giây
    });
}

// Cách sử dụng Promise với .then() và .catch()
console.log('🚀 Bắt đầu process...');

layThongTinNguoiDung(123)
    .then(function(thongTinUser) {
        // .then() nhận kết quả từ resolve()
        console.log('✅ Thành công! Nhận được thông tin user:');
        console.log(`   👤 Tên: ${thongTinUser.ten}`);
        console.log(`   📧 Email: ${thongTinUser.email}`);
        console.log(`   🎂 Tuổi: ${thongTinUser.tuoi}`);
        console.log(`   🏠 Địa chỉ: ${thongTinUser.diaChi}`);
        
        // Giá trị return từ .then() sẽ được truyền cho .then() tiếp theo
        return `Xin chào ${thongTinUser.ten}!`;
    })
    .then(function(loiChao) {
        // .then() thứ hai nhận giá trị return từ .then() đầu tiên
        console.log('👋', loiChao);
        console.log('🎉 Đã hiển thị thông tin thành công!');
    })
    .catch(function(loi) {
        // .catch() nhận error từ reject() hoặc lỗi trong .then()
        console.error('❌ Có lỗi xảy ra:', loi.message);
        console.log('🔄 Có thể thử lại với user ID khác');
    })
    .finally(function() {
        // .finally() luôn chạy, dù thành công hay thất bại
        console.log('🔄 Quá trình xử lý hoàn tất (cleanup code)');
        console.log('📝 Ghi log, đóng kết nối, etc...');
    });

console.log('💡 Dòng này chạy ngay lập tức, không bị chặn!');

// Thử với user ID không hợp lệ
layThongTinNguoiDung(-1)
    .then(user => console.log('Không bao giờ chạy'))
    .catch(error => console.error('💥 Lỗi với user ID âm:', error.message));

// ✅ SỬ DỤNG PROMISE CHAINING - Giải quyết Callback Hell
// Cùng tình huống E-commerce nhưng với Promise

// Các hàm helper trả về Promise
function layThongTinNguoiDung(userId) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (userId > 0) {
                resolve({ id: userId, ten: 'Nguyễn Văn D', email: 'user@example.com' });
            } else {
                reject(new Error('User ID không hợp lệ'));
            }
        }, 1000);
    });
}

function layLichSuDonHang(userId) {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve([
                { id: 'DH001', tongTien: 500000, trangThai: 'hoàn thành' },
                { id: 'DH002', tongTien: 750000, trangThai: 'đang giao' }
            ]);
        }, 800);
    });
}

function layChiTietDonHang(donHangId) {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve({
                id: donHangId,
                sanPham: [
                    { ten: 'Laptop Dell', gia: 15000000, soLuong: 1 },
                    { ten: 'Chuột không dây', gia: 200000, soLuong: 2 }
                ],
                phiVanChuyen: 50000,
                vanChuyenId: 'VC123'
            });
        }, 600);
    });
}

function tinhTongChiPhi(chiTietDonHang) {
    return new Promise((resolve) => {
        setTimeout(() => {
            let tongTienSanPham = chiTietDonHang.sanPham.reduce((tong, sp) => {
                return tong + (sp.gia * sp.soLuong);
            }, 0);
            
            let tongChiPhi = tongTienSanPham + chiTietDonHang.phiVanChuyen;
            resolve(tongChiPhi);
        }, 400);
    });
}

// Sử dụng Promise Chaining thay vì Callback Hell
console.log('🚀 Bắt đầu xử lý đơn hàng với Promise...');

layThongTinNguoiDung(123)
    .then(nguoiDung => {
        console.log('✅ Bước 1: Lấy thông tin user thành công');
        console.log(`   👤 Tên: ${nguoiDung.ten}`);
        
        // Return Promise cho bước tiếp theo

        return layLichSuDonHang(nguoiDung.id);
    })
    .then(danhSachDonHang => {
        console.log('✅ Bước 2: Lấy lịch sử đơn hàng thành công');
        console.log(`   📦 Có ${danhSachDonHang.length} đơn hàng`);
        
        if (danhSachDonHang.length === 0) {
            throw new Error('Người dùng chưa có đơn hàng nào');
        }
        
        // Return Promise cho bước tiếp theo
        return layChiTietDonHang(danhSachDonHang[0].id);
    })
    .then(chiTietDonHang => {
        console.log('✅ Bước 3: Lấy chi tiết đơn hàng thành công');
        console.log(`   🛍️ Có ${chiTietDonHang.sanPham.length} sản phẩm`);
        
        // Return Promise cho bước tiếp theo
        return tinhTongChiPhi(chiTietDonHang);
    })
    .then(tongChiPhi => {
        console.log('✅ Bước 4: Tính tổng chi phí thành công');
        console.log(`💰 Tổng tiền: ${tongChiPhi.toLocaleString('vi-VN')} VNĐ`);
        
        return `Xử lý đơn hàng hoàn tất với tổng tiền ${tongChiPhi.toLocaleString('vi-VN')} VNĐ`;
    })
    .then(ketQua => {
        console.log('🎉', ketQua);
    })
    .catch(loi => {
        // MỘT .catch() duy nhất xử lý TẤT CẢ lỗi trong chuỗi
        console.error('❌ Có lỗi xảy ra trong quá trình xử lý:', loi.message);
        console.log('🔄 Có thể thử lại hoặc thông báo cho user');
    })
    .finally(() => {
        console.log('🔄 Hoàn tất quá trình xử lý đơn hàng');
    });

console.log('💡 Code này chạy ngay, không bị chặn!');

// ✨ LỢI ÍCH CỦA PROMISE CHAINING:
// 1. Code phẳng, không lồng sâu
// 2. Dễ đọc từ trên xuống dưới
// 3. Error handling đơn giản với một .catch()
// 4. Dễ thêm/bớt bước trong chuỗi
// 5. Có thể tái sử dụng từng hàm

// 1. CÚ PHÁP CƠ BẢN

// Khai báo async function
async function tenHam() {
    // Từ khóa 'async' trước 'function' 
    // → Function này luôn trả về Promise
}

// Sử dụng await (chỉ dùng được trong async function)
async function hamBatDongBo() {
    // await chỉ sử dụng được trong async function
    const ketQua = await promiseNaoDay();
    //     ↑           ↑
    //   tạm dừng   Promise object
    return ketQua;
}

// 2. CÁC CÁCH KHAI BÁO ASYNC FUNCTION

// Function declaration
async function myFunction() {
    return "Hello";
}

// Function expression
const myFunction2 = async function() {
    return "Hello";
};

// Arrow function
const myFunction3 = async () => {
    return "Hello";
};

// Method trong object
const obj = {
    async myMethod() {
        return "Hello";
    }
};

// Method trong class
class MyClass {
    async myMethod() {
        return "Hello";
    }
}

// 3. HIỂU SÂU VỀ ASYNC

// Hàm bình thường
function hamBinhThuong() {
    return "Hello World";
}

// Hàm async (tự động wrap trong Promise)
async function hamAsync() {
    return "Hello World"; // Tự động thành Promise.resolve("Hello World")
}

console.log(hamBinhThuong()); // "Hello World" (string)
console.log(hamAsync());      // Promise {: "Hello World"}

// Cách sử dụng kết quả của async function
hamAsync().then(result => console.log(result)); // "Hello World"

// Hoặc sử dụng await
async function main() {
    const result = await hamAsync();
    console.log(result); // "Hello World"
}

// 4. HIỂU SÂU VỀ AWAIT

async function demo() {
    console.log('1. Bắt đầu');
    
    // await làm function TẠM DỪNG tại đây
    // Chờ Promise resolve, sau đó tiếp tục
    const data = await fetch('/api/data'); // Dừng ở đây cho đến khi fetch xong
    
    console.log('2. Fetch hoàn thành');
    const json = await data.json(); // Lại dừng ở đây
    
    console.log('3. Parse JSON xong');
    return json;
}

// 5. QUY TẮC QUAN TRỌNG

// ❌ SAI: await chỉ dùng được trong async function
function hamSai() {
    const data = await fetch('/api'); // SyntaxError!
}

// ✅ ĐÚNG: await trong async function
async function hamDung() {
    const data = await fetch('/api'); // OK!
}

// ❌ SAI: async function vẫn cần await để lấy kết quả
async function layDuLieu() {
    return "Dữ liệu";
}

function main() {
    const data = layDuLieu(); // data là Promise, không phải "Dữ liệu"
    console.log(data); // Promise {: "Dữ liệu"}
}

// ✅ ĐÚNG: Sử dụng await hoặc .then()
async function mainDung() {
    const data = await layDuLieu(); // "Dữ liệu"
    console.log(data); // "Dữ liệu"
}

// DEMO: Hiểu cơ chế hoạt động của async/await

// Tạo Promise để demo
function taoPromise(value, delay) {
    return new Promise((resolve) => {
        console.log(`   🟡 Bắt đầu Promise: "${value}" (${delay}ms)`);
        setTimeout(() => {
            console.log(`   🟢 Hoàn thành Promise: "${value}"`);
            resolve(value);
        }, delay);
    });
}

// Function với async/await
async function demoAsyncAwait() {
    console.log('🚀 Bắt đầu async function');
    
    console.log('1️⃣ Trước await đầu tiên');
    const ketQua1 = await taoPromise("Bước 1", 1000);
    console.log(`✅ Nhận được: ${ketQua1}`);
    
    console.log('2️⃣ Trước await thứ hai');
    const ketQua2 = await taoPromise("Bước 2", 800);
    console.log(`✅ Nhận được: ${ketQua2}`);
    
    console.log('3️⃣ Trước await thứ ba');
    const ketQua3 = await taoPromise("Bước 3", 600);
    console.log(`✅ Nhận được: ${ketQua3}`);
    
    console.log('🎉 Kết thúc async function');
    return `Hoàn thành với: ${ketQua1}, ${ketQua2}, ${ketQua3}`;
}

// Gọi function và quan sát
console.log('🎬 === BẮT ĐẦU DEMO ===');
console.log('📍 Trước khi gọi demoAsyncAwait()');

const promise = demoAsyncAwait();
console.log('📍 Sau khi gọi demoAsyncAwait() (không chặn!)');
console.log('💡 promise object:', promise);

promise.then(ketQua => {
    console.log('🏁 Kết quả cuối cùng:', ketQua);
});

console.log('📍 Code này chạy ngay lập tức, không bị chặn!');

// KẾT QUẢ IN RA:
// 🎬 === BẮT ĐẦU DEMO ===
// 📍 Trước khi gọi demoAsyncAwait()
// 🚀 Bắt đầu async function
// 1️⃣ Trước await đầu tiên
//    🟡 Bắt đầu Promise: "Bước 1" (1000ms)
// 📍 Sau khi gọi demoAsyncAwait() (không chặn!)
// 💡 promise object: Promise {}
// 📍 Code này chạy ngay lập tức, không bị chặn!
// (sau 1000ms)
//    🟢 Hoàn thành Promise: "Bước 1"
// ✅ Nhận được: Bước 1
// 2️⃣ Trước await thứ hai
//    🟡 Bắt đầu Promise: "Bước 2" (800ms)
// (sau 800ms)
//    🟢 Hoàn thành Promise: "Bước 2"
// ✅ Nhận được: Bước 2
// 3️⃣ Trước await thứ ba
//    🟡 Bắt đầu Promise: "Bước 3" (600ms)
// (sau 600ms)
//    🟢 Hoàn thành Promise: "Bước 3"
// ✅ Nhận được: Bước 3
// 🎉 Kết thúc async function
// 🏁 Kết quả cuối cùng: Hoàn thành với: Bước 1, Bước 2, Bước 3

// TÌNH HUỐNG: Lấy thông tin user → Lấy posts → Hiển thị

// ❌ CÁCH 1: CALLBACKS (Callback Hell)
function layThongTinVoiCallback(userId, callback) {
    layUser(userId, function(error, user) {
        if (error) {
            callback(error, null);
            return;
        }
        
        layPosts(user.id, function(error, posts) {
            if (error) {
                callback(error, null);
                return;
            }
            
            layComments(posts[0].id, function(error, comments) {
                if (error) {
                    callback(error, null);
                    return;
                }
                
                // Callback hell - lồng 3 tầng!
                callback(null, { user, posts, comments });
            });
        });
    });
}

// ✅ CÁCH 2: PROMISES (Promise Chaining)  
function layThongTinVoiPromiseFlat(userId) {
    let userData = {};
    
    return layUserPromise(userId)
        .then(user => {
            userData.user = user;
            return layPostsPromise(user.id);
        })
        .then(posts => {
            userData.posts = posts;
            return layCommentsPromise(posts[0].id);
        })
        .then(comments => {
            userData.comments = comments;
            return userData; // { user, posts, comments }
        })
        .catch(error => {
            console.error('Lỗi:', error);
            throw error;
        });
}

// 🚀 CÁCH 3: ASYNC/AWAIT (Hiện đại nhất)
async function layThongTinVoiAsyncAwait(userId) {
    try {
        // Code trông như đồng bộ, nhưng vẫn bất đồng bộ!
        const user = await layUserPromise(userId);
        const posts = await layPostsPromise(user.id);
        const comments = await layCommentsPromise(posts[0].id);
        
        return { user, posts, comments };
        
    } catch (error) {
        console.error('Lỗi:', error);
        throw error;
    }
}

// SO SÁNH ĐỘ DÀI:
// Callbacks:    ~15 dòng với nhiều lồng nhau
// Promises:     ~12 dòng với chaining
// Async/Await:  ~8 dòng, đọc như code bình thường

// SO SÁNH ERROR HANDLING:
// Callbacks:    Phải check error ở mỗi tầng
// Promises:     Một .catch() cuối cùng
// Async/Await:  try/catch như code đồng bộ

// SO SÁNH DEBUGGING:
// Callbacks:    Khó debug vì nhiều tầng
// Promises:     Khó đặt breakpoint trong .then()
// Async/Await:  Dễ debug như code bình thường

// Demo functions
async function task1() {
    console.log('🟡 Task 1 bắt đầu');
    await new Promise(resolve => setTimeout(resolve, 2000));
    console.log('🟢 Task 1 hoàn thành');
    return 'Kết quả 1';
}

async function task2() {
    console.log('🟡 Task 2 bắt đầu');
    await new Promise(resolve => setTimeout(resolve, 1500));
    console.log('🟢 Task 2 hoàn thành');
    return 'Kết quả 2';
}

async function task3() {
    console.log('🟡 Task 3 bắt đầu');
    await new Promise(resolve => setTimeout(resolve, 1000));
    console.log('🟢 Task 3 hoàn thành');
    return 'Kết quả 3';
}

// ❌ SEQUENTIAL - Chạy tuần tự (chậm)
async function chayTuanTu() {
    console.log('📚 === CHẠY TUẦN TỰ ===');
    const start = Date.now();
    
    const result1 = await task1(); // Chờ 2 giây
    const result2 = await task2(); // Chờ thêm 1.5 giây
    const result3 = await task3(); // Chờ thêm 1 giây
    // Tổng: ~4.5 giây
    
    const end = Date.now();
    console.log(`⏱️ Tổng thời gian: ${end - start}ms`);
    console.log('📋 Kết quả:', [result1, result2, result3]);
}

// ✅ PARALLEL - Chạy song song (nhanh)
async function chaySongSong() {
    console.log('🚀 === CHẠY SONG SONG ===');
    const start = Date.now();
    
    // Khởi động tất cả tasks cùng lúc (không await ngay)
    const promise1 = task1(); // Bắt đầu ngay
    const promise2 = task2(); // Bắt đầu ngay
    const promise3 = task3(); // Bắt đầu ngay
    
    // Chờ tất cả hoàn thành
    const results = await Promise.all([promise1, promise2, promise3]);
    // Tổng thời gian = task chậm nhất = 2 giây
    
    const end = Date.now();
    console.log(`⏱️ Tổng thời gian: ${end - start}ms`);
    console.log('📋 Kết quả:', results);
}

// ✅ HYBRID - Kết hợp linh hoạt
async function chayKetHop() {
    console.log('🎯 === CHẠY KẾT HỢP ===');
    const start = Date.now();
    
    // Bước 1: Chạy song song task1 và task2
    const [result1, result2] = await Promise.all([task1(), task2()]);
    
    // Bước 2: Chỉ chạy task3 sau khi có kết quả từ task1, task2
    const result3 = await task3();
    
    const end = Date.now();
    console.log(`⏱️ Tổng thời gian: ${end - start}ms`);
    console.log('📋 Kết quả:', [result1, result2, result3]);
}

// Test performance
async function testPerformance() {
    await chayTuanTu();     // ~4.5 giây
    console.log('');
    await chaySongSong();   // ~2 giây  
    console.log('');
    await chayKetHop();     // ~3 giây
}

testPerformance();

// 1. CƠ BẢN: Try/Catch với Async/Await

async function basicErrorHandling() {
    try {
        // Tất cả errors (Promise rejections) sẽ được catch ở đây
        const response = await fetch('/api/user/123');
        const user = await response.json();
        
        if (!response.ok) {
            throw new Error(`HTTP Error: ${response.status}`);
        }
        
        return user;
        
    } catch (error) {
        // Bắt TẤT CẢ errors từ bất kỳ await nào ở trên
        console.error('🚨 Lỗi:', error.message);
        
        // Có thể re-throw hoặc trả về default value
        throw error; // Re-throw để caller handle
        // return null; // Hoặc trả về default value
    }
}

// 2. MULTIPLE TRY/CATCH - Xử lý lỗi riêng biệt

async function multipleTryCatch(userId) {
    let user = null;
    let posts = [];
    let comments = [];
    
    // Bước 1: Lấy user info (critical - phải có)
    try {
        const response = await fetch(`/api/users/${userId}`);
        if (!response.ok) throw new Error('User not found');
        user = await response.json();
        console.log('✅ User loaded successfully');
    } catch (error) {
        console.error('❌ Failed to load user:', error.message);
        throw error; // User là critical, không thể tiếp tục
    }
    
    // Bước 2: Lấy posts (optional - có thể fail)
    try {
        const response = await fetch(`/api/users/${userId}/posts`);
        if (response.ok) {
            posts = await response.json();
            console.log(`✅ Loaded ${posts.length} posts`);
        }
    } catch (error) {
        console.warn('⚠️ Could not load posts:', error.message);
        // Không throw - posts không critical
    }
    
    // Bước 3: Lấy comments (optional)
    try {
        if (posts.length > 0) {
            const response = await fetch(`/api/posts/${posts[0].id}/comments`);
            if (response.ok) {
                comments = await response.json();
                console.log(`✅ Loaded ${comments.length} comments`);
            }
        }
    } catch (error) {
        console.warn('⚠️ Could not load comments:', error.message);
        // Không throw
    }
    
    return { user, posts, comments };
}

// 3. NESTED TRY/CATCH - Xử lý phức tạp

async function nestedErrorHandling() {
    try {
        // Outer try - bắt errors tổng quát
        const userData = await fetchUserData();
        
        try {
            // Inner try - specific error handling
            const enrichedData = await enrichUserData(userData);
            return enrichedData;
            
        } catch (enrichError) {
            console.warn('⚠️ Could not enrich data:', enrichError.message);
            // Fallback: trả về basic data
            return userData;
        }
        
    } catch (mainError) {
        console.error('❌ Critical error:', mainError.message);
        
        // Retry logic
        if (mainError.code === 'NETWORK_ERROR') {
            console.log('🔄 Retrying...');
            await new Promise(resolve => setTimeout(resolve, 1000));
            return nestedErrorHandling(); // Recursive retry
        }
        
        throw mainError;
    }
}

// 4. PROMISE.ALL() VỚI ERROR HANDLING

async function parallelWithErrorHandling() {
    try {
        // Tất cả promises phải thành công
        const [users, posts, categories] = await Promise.all([
            fetch('/api/users').then(r => r.json()),
            fetch('/api/posts').then(r => r.json()),
            fetch('/api/categories').then(r => r.json())
        ]);
        
        return { users, posts, categories };
        
    } catch (error) {
        console.error('❌ One or more requests failed:', error);
        
        // Fallback: load individually với error handling
        return await loadIndividually();
    }
}

async function loadIndividually() {
    const result = { users: [], posts: [], categories: [] };
    
    // Load từng cái một, bỏ qua errors
    try {
        const response = await fetch('/api/users');
        if (response.ok) result.users = await response.json();
    } catch (e) { console.warn('Could not load users'); }
    
    try {
        const response = await fetch('/api/posts');
        if (response.ok) result.posts = await response.json();
    } catch (e) { console.warn('Could not load posts'); }
    
    try {
        const response = await fetch('/api/categories');
        if (response.ok) result.categories = await response.json();
    } catch (e) { console.warn('Could not load categories'); }
    
    return result;
}