// 串行执行（顺序等待）
async function serialExecution() {
    console.log('开始串行执行');
    const start = Date.now();
    
    const result1 = await delay(1000, 'task1');
    console.log('任务1完成:', result1);
    
    const result2 = await delay(1000, 'task2');
    console.log('任务2完成:', result2);
    
    const result3 = await delay(1000, 'task3');
    console.log('任务3完成:', result3);
    
    console.log('串行总时间:', Date.now() - start, 'ms'); // 约3000ms
}

// 并行执行（同时开始）
async function parallelExecution() {
    console.log('开始并行执行');
    const start = Date.now();
    
    // 同时启动所有任务
    const promise1 = delay(1000, 'task1');
    const promise2 = delay(1000, 'task2');
    const promise3 = delay(1000, 'task3');
    
    // 等待所有任务完成
    const results = await Promise.all([promise1, promise2, promise3]);
    console.log('所有任务完成:', results);
    
    console.log('并行总时间:', Date.now() - start, 'ms'); // 约1000ms
}

// 使用Promise.allSettled处理可能失败的并行任务
async function parallelWithErrorHandling() {
    const tasks = [
        delay(500, 'success1'),
        delay(800, 'success2'),
        Promise.reject(new Error('task3 failed')),
        delay(300, 'success4')
    ];
    
    const results = await Promise.allSettled(tasks);
    
    results.forEach((result, index) => {
        if (result.status === 'fulfilled') {
            console.log(`任务${index + 1}成功:`, result.value);
        } else {
            console.log(`任务${index + 1}失败:`, result.reason.message);
        }
    });
}

// 辅助函数
function delay(ms, value) {
    return new Promise(resolve => setTimeout(() => resolve(value), ms));
}

// try-catch错误处理
async function errorHandlingExample() {
    try {
        const result = await riskyAsyncOperation();
        console.log('操作成功:', result);
    } catch (error) {
        console.error('捕获错误:', error.message);
        // 可以在这里处理错误或重新抛出
    } finally {
        console.log('清理操作');
    }
}

// 多个await的错误处理
async function multipleAwaitError() {
    try {
        const user = await fetchUser(123);
        const posts = await fetchPosts(user.id); // 如果这里出错
        const comments = await fetchComments(posts[0].id); // 这里不会执行
        
        return { user, posts, comments };
    } catch (error) {
        console.error('流程中断:', error.message);
        // 决定如何处理错误
        return null;
    }
}

// 部分错误处理
async function partialErrorHandling() {
    let user, posts, comments;
    
    try {
        user = await fetchUser(123);
    } catch (error) {
        console.error('获取用户失败:', error.message);
        return null;
    }
    
    try {
        posts = await fetchPosts(user.id);
    } catch (error) {
        console.error('获取文章失败，使用默认值');
        posts = [];
    }
    
    try {
        comments = posts.length > 0 ? await fetchComments(posts[0].id) : [];
    } catch (error) {
        console.error('获取评论失败，使用默认值');
        comments = [];
    }
    
    return { user, posts, comments };
}

// 错误重试机制
async function withRetry(asyncFn, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
        try {
            return await asyncFn();
        } catch (error) {
            console.log(`尝试 ${i + 1} 失败:`, error.message);
            if (i === maxRetries - 1) {
                throw error; // 最后一次重试失败，抛出错误
            }
            await delay(1000 * (i + 1)); // 延迟重试
        }
    }
}

function riskyAsyncOperation() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (Math.random() > 0.6) {
                resolve('操作成功');
            } else {
                reject(new Error('操作失败'));
            }
        }, 500);
    });
}

// 在循环中使用async/await
const urls = [
    '/api/users/1',
    '/api/users/2',
    '/api/users/3',
    '/api/users/4'
];

// 错误方式：forEach不等待async函数
async function wrongWay() {
    console.log('开始错误方式');
    urls.forEach(async (url) => {
        const data = await simulateAPICall(url);
        console.log('数据:', data);
    });
    console.log('错误方式结束'); // 这行会立即执行
}

// 正确方式1：使用for...of（串行）
async function serialLoop() {
    console.log('开始串行循环');
    for (const url of urls) {
        const data = await simulateAPICall(url);
        console.log('串行数据:', data);
    }
    console.log('串行循环结束');
}

// 正确方式2：使用Promise.all（并行）
async function parallelLoop() {
    console.log('开始并行循环');
    const promises = urls.map(url => simulateAPICall(url));
    const results = await Promise.all(promises);
    results.forEach((data, index) => {
        console.log(`并行数据${index + 1}:`, data);
    });
    console.log('并行循环结束');
}

// 正确方式3：使用传统for循环（串行）
async function traditionalLoop() {
    console.log('开始传统循环');
    for (let i = 0; i < urls.length; i++) {
        const data = await simulateAPICall(urls[i]);
        console.log(`传统循环数据${i + 1}:`, data);
    }
    console.log('传统循环结束');
}

// 限制并发数量
async function limitedConcurrency(urls, limit = 2) {
    const results = [];
    
    for (let i = 0; i < urls.length; i += limit) {
        const batch = urls.slice(i, i + limit);
        const batchPromises = batch.map(url => simulateAPICall(url));
        const batchResults = await Promise.all(batchPromises);
        results.push(...batchResults);
        console.log(`批次 ${Math.floor(i / limit) + 1} 完成`);
    }
    
    return results;
}

// reduce中使用async/await（串行处理）
async function reduceAsync() {
    const result = await urls.reduce(async (accPromise, url) => {
        const acc = await accPromise;
        const data = await simulateAPICall(url);
        return acc + data.length;
    }, Promise.resolve(0));
    
    console.log('reduce结果:', result);
    return result;
}

function simulateAPICall(url) {
    return new Promise(resolve => {
        setTimeout(() => {
            resolve(`Data from ${url}`);
        }, Math.random() * 1000 + 200);
    });
}