// 基本创建
const promise = new Promise((resolve, reject) => {
    // 模拟异步操作
    setTimeout(() => {
        const success = Math.random() > 0.5;
        if (success) {
            resolve('操作成功');    // → Fulfilled
        } else {
            reject(new Error('操作失败'));  // → Rejected
        }
    }, 1000);
});

// 使用
promise
    .then(value => console.log(value))
    .catch(err => console.error(err.message));

// 将 Node.js 回调风格转为 Promise
const { promisify } = require('util');
const fs = require('fs');

const readFile = promisify(fs.readFile);
const writeFile = promisify(fs.writeFile);

// 手动包装
function readFileManual(path, encoding) {
    return new Promise((resolve, reject) => {
        fs.readFile(path, encoding, (err, data) => {
            if (err) reject(err);
            else resolve(data);
        });
    });
}

// Node.js 16+ 内置的 promise API
const fsPromises = require('fs/promises');
await fsPromises.readFile('/path', 'utf8');

import asyncio

async def fetch_data():
    await asyncio.sleep(1)  # 模拟 I/O
    return {'status': 'ok', 'data': [1, 2, 3]}

# Python 的协程本身就是类似 Promise 的概念
result = asyncio.run(fetch_data())

// CompletableFuture 是 Java 的 Promise 实现
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 异步操作
    return fetchDataFromDB();
});

future
    .thenApply(data -> processData(data))      // 转换
    .thenAccept(result -> saveResult(result))   // 消费
    .exceptionally(err -> {                     // 错误处理
        log.error("Failed:", err);
        return null;
    });

use tokio;

#[tokio::main]
async fn main() {
    let result = fetch_data().await;
    println!("结果: {:?}", result);
}

async fn fetch_data() -> Result<String, reqwest::Error> {
    let resp = reqwest::get("https://api.example.com").await?;
    let body = resp.text().await?;
    Ok(body)
}

// ❌ 回调地狱
getUser(userId, (err, user) => {
    getProduct(productId, (err, product) => {
        createOrder(user, product, (err, order) => {
            sendNotification(user.email, order, (err) => {
                console.log('完成');
            });
        });
    });
});

// ✅ Promise 链式调用
getUser(userId)
    .then(user => getProduct(productId).then(product => ({ user, product })))
    .then(({ user, product }) => createOrder(user, product))
    .then(order => sendNotification(user.email, order))
    .then(() => console.log('完成'))
    .catch(err => console.error('失败:', err));

// 使用 async/await 是最直接的方式（第 5 章详述）
async function placeOrder(userId, productId) {
    const user = await getUser(userId);
    const product = await getProduct(productId);
    const order = await createOrder(user, product);
    await sendNotification(user.email, order);
    return order;
}

Promise.resolve('start')
    .then(value => {
        throw new Error('步骤 1 失败');
    })
    .then(value => {
        console.log('这不会执行');
    })
    .then(value => {
        console.log('这也不会执行');
    })
    .catch(err => {
        // 错误会一直冒泡，直到被某个 catch 捕获
        console.error('捕获到:', err.message);  // "步骤 1 失败"
    });

// 方式一：使用 .catch()
promise
    .then(onFulfilled)
    .catch(onRejected);  // 捕获前面所有步骤的错误

// 方式二：使用 .then() 的第二个参数
promise.then(onFulfilled, onRejected);  // 只捕获 promise 本身的错误

// 区别：catch 能捕获 onFulfilled 中抛出的错误
promise
    .then(value => {
        throw new Error('then 中的错误');
    })
    .catch(err => {
        console.error('能捕获:', err);  // ✅
    });

promise.then(
    value => { throw new Error('then 中的错误'); },
    err => {
        console.error('不能捕获:', err);  // ❌ 只捕获 promise 本身的错误
    }
);

// ⚠️ 忘记处理 rejection 会导致 unhandledRejection
const bad = Promise.reject(new Error('没有人处理我'));

// 正确做法：总是以 .catch() 结尾
const good = Promise.reject(new Error('我会被处理'))
    .catch(err => console.error('已处理:', err.message));

// Node.js 15+ 默认将 unhandledRejection 视为致命错误
process.on('unhandledRejection', (reason, promise) => {
    console.error('未处理的拒绝:', reason);
    // 建议记录日志后优雅退出
    process.exit(1);
});

// 等待所有 Promise 都成功，任一失败则立即失败
const results = await Promise.all([
    fetch('/api/users'),
    fetch('/api/products'),
    fetch('/api/orders'),
]);

// 等待所有 Promise 都结束（无论成功或失败）
const results = await Promise.allSettled([
    fetch('/api/users'),
    fetch('/api/products'),
    fetch('/api/orders'),
]);

// 每个结果对象：
// { status: 'fulfilled', value: ... }
// { status: 'rejected', reason: ... }

// 返回第一个完成的 Promise（无论成功或失败）
const fastest = await Promise.race([
    fetch('/api/fast-server'),
    fetch('/api/slow-server'),
    new Promise((_, reject) =>
        setTimeout(() => reject(new Error('超时')), 5000)
    ),
]);

// 返回第一个成功的 Promise，全部失败才拒绝
const result = await Promise.any([
    fetch('/api/server-1'),
    fetch('/api/server-2'),
    fetch('/api/server-3'),
]);

// 如果全部失败，抛出 AggregateError
try {
    const result = await Promise.any(failingPromises);
} catch (err) {
    console.error(err.errors);  // 所有错误的数组
}

function fetchData(url) {
    showLoadingSpinner();
    return fetch(url)
        .then(res => res.json())
        .catch(err => {
            showErrorNotification(err);
            throw err;  // 重新抛出，让调用方也知道失败了
        })
        .finally(() => {
            hideLoadingSpinner();  // 无论成功失败都隐藏加载动画
        });
}

const p = Promise.resolve(42);

p.finally(() => {
    console.log('finally 执行');
    // 1. 没有返回值 → 原始值 42 传递给下一个 then
    // 2. 返回一个普通值 → 同上，值被忽略
    // 3. 返回一个 Promise → 等待它完成，但值仍被忽略
    // 4. 抛出异常 → 新的 Rejected Promise
}).then(value => {
    console.log(value);  // 42
});

function withTimeout(promise, ms) {
    return Promise.race([
        promise,
        new Promise((_, reject) =>
            setTimeout(() => reject(new Error(`操作超时 (${ms}ms)`)), ms)
        ),
    ]);
}

// 使用
try {
    const data = await withTimeout(fetch('/api/slow'), 3000);
} catch (err) {
    console.error(err.message);  // "操作超时 (3000ms)"
}

async function withRetry(fn, retries = 3, delay = 1000) {
    for (let i = 0; i < retries; i++) {
        try {
            return await fn();
        } catch (err) {
            if (i === retries - 1) throw err;
            await new Promise(r => setTimeout(r, delay * Math.pow(2, i)));
        }
    }
}

// 使用
const data = await withRetry(() => fetch('/api/unreliable'), 3, 1000);

async function parallelLimit(tasks, limit) {
    const results = [];
    const executing = new Set();

    for (const [i, task] of tasks.entries()) {
        const p = task().then(result => {
            executing.delete(p);
            return result;
        });
        executing.add(p);
        results[i] = p;

        if (executing.size >= limit) {
            await Promise.race(executing);
        }
    }

    return Promise.all(results);
}

// 使用：最多同时 3 个请求
const tasks = urls.map(url => () => fetch(url));
const results = await parallelLimit(tasks, 3);

async function aggregateAPIs(requests) {
    const results = {};

    const settled = await Promise.allSettled(
        requests.map(async ({ key, url, timeout = 3000 }) => {
            const response = await withTimeout(fetch(url), timeout);
            const data = await response.json();
            return { key, data };
        })
    );

    for (const result of settled) {
        if (result.status === 'fulfilled') {
            results[result.value.key] = result.value.data;
        } else {
            console.warn(`API 失败:`, result.reason);
        }
    }

    return results;
}

// 使用
const data = await aggregateAPIs([
    { key: 'user',    url: '/api/user/123' },
    { key: 'orders',  url: '/api/orders?user=123' },
    { key: 'profile', url: '/api/profile/123' },
    { key: 'settings',url: '/api/settings/123' },
    { key: 'notifications', url: '/api/notifications/123', timeout: 5000 },
]);