// 传统回调写法 —— 套娃地狱（Callback Hell）
getUserInfo(userId, function(user) {
  getUserOrders(user.id, function(orders) {
    getOrderDetails(orders[0].id, function(details) {
      console.log(details);
    });
  });
});
 
// Promise 写法 —— 链式调用，清晰优雅
getUserInfo(userId)
  .then(user => getUserOrders(user.id))
  .then(orders => getOrderDetails(orders[0].id))
  .then(details => console.log(details))
  .catch(err => console.error(err));

// Promise 状态图
//
//   pending（进行中）──────┬──→ fulfilled（已成功）
//                          │
//                          └──→ rejected（已失败）
//
// 特点：
// 1. 状态只能改变一次，不能逆转
// 2. pending → fulfilled 或 pending → rejected
// 3. 一旦改变，就固定了（immutable）

// 创建 Promise
const promise = new Promise((resolve, reject) => {
  // resolve: 成功时调用，把结果传出去
  // reject:  失败时调用，把错误原因传出去
  
  // 模拟异步操作
  setTimeout(() => {
    const success = true;
    
    if (success) {
      resolve('操作成功！');  // 状态变为 fulfilled
    } else {
      reject('操作失败！');   // 状态变为 rejected
    }
  }, 1000);
});

// then 的完整签名
promise.then(
  onFulfilled,  // 成功回调，接收 resolve 的值
  onRejected    // 失败回调（可选），接收 reject 的原因
);
 
// 示例：基本用法
const p1 = Promise.resolve('成功数据');
 
p1.then(value => {
  console.log('收到:', value);  // 输出: 收到: 成功数据
  return '处理后的数据';         // 返回值会传给下一个 then
})
.then(value => {
  console.log('第二次收到:', value);  // 输出: 第二次收到: 处理后的数据
});
 
// 示例：then 返回新 Promise（链式调用的关键）
const p2 = new Promise(resolve => resolve(10));
 
p2.then(value => {
  console.log('第一次:', value);  // 10
  return value * 2;               // 返回普通值
})
.then(value => {
  console.log('第二次:', value);  // 20
  return new Promise(resolve => resolve(value + 5));  // 返回 Promise
})
.then(value => {
  console.log('第三次:', value);  // 25
});

// catch 基本用法
const pError = new Promise((resolve, reject) => {
  reject('出错了！');
});
 
pError
  .then(value => console.log('成功:', value))  // 不会执行
  .catch(error => console.log('失败:', error)); // 输出: 失败: 出错了！
 
// catch 捕获链式调用中的所有错误
getUserInfo(userId)
  .then(user => getUserOrders(user.id))   // 可能出错
  .then(orders => getOrderDetails(orders[0].id))  // 可能出错
  .catch(err => console.error('某一步出错了:', err));  // 统一捕获
 
// catch 后还能继续 then（错误"恢复"）
Promise.reject('失败了')
  .catch(err => {
    console.log('捕获到:', err);
    return '恢复后的值';  // catch 返回值可以继续传递
  })
  .then(value => {
    console.log('继续执行:', value);  // 输出: 继续执行: 恢复后的值
  });

// finally 基本用法
const p = new Promise((resolve, reject) => {
  setTimeout(() => resolve('数据'), 1000);
});
 
p
  .then(value => console.log('成功:', value))
  .catch(error => console.log('失败:', error))
  .finally(() => {
    console.log('无论成功失败，我都会执行！');
    // 常用于：关闭 loading、清理资源、记录日志
  });
 
// 实际场景：关闭 loading
function fetchWithLoading(url) {
  showLoading();  // 显示 loading
  
  return fetch(url)
    .then(res => res.json())
    .catch(err => {
      showError(err);
      throw err;  // 继续抛出，让外部也能捕获
    })
    .finally(() => {
      hideLoading();  // 无论成功失败，都关闭 loading
    });
}

// Promise.all 基本用法
const p1 = Promise.resolve(1);
const p2 = Promise.resolve(2);
const p3 = Promise.resolve(3);
 
Promise.all([p1, p2, p3])
  .then(values => {
    console.log(values);  // [1, 2, 3]
  })
  .catch(error => {
    console.log('有一个失败了:', error);
  });
 
// 实际场景：并行请求多个接口
function fetchAllData() {
  const userPromise = fetch('/api/user').then(r => r.json());
  const orderPromise = fetch('/api/orders').then(r => r.json());
  const productPromise = fetch('/api/products').then(r => r.json());
  
  return Promise.all([userPromise, orderPromise, productPromise])
    .then(([user, orders, products]) => {
      return { user, orders, products };  // 三个数据都有了
    });
}
 
// 失败场景：一个失败，整体失败
Promise.all([
  Promise.resolve('成功1'),
  Promise.reject('失败2'),
  Promise.resolve('成功3')
])
.catch(error => {
  console.log('整体失败:', error);  // 输出: 整体失败: 失败2
  // 注意：成功1 和 成功3 的结果丢失了！
});

// Promise.race 基本用法
const p1 = new Promise(resolve => setTimeout(() => resolve('慢'), 300));
const p2 = new Promise(resolve => setTimeout(() => resolve('快'), 100));
 
Promise.race([p1, p2])
  .then(value => console.log(value));  // 输出: 快
 
// 实际场景：请求超时控制
function fetchWithTimeout(url, timeout = 5000) {
  const fetchPromise = fetch(url).then(r => r.json());
  const timeoutPromise = new Promise((_, reject) => 
    setTimeout(() => reject(new Error('请求超时')), timeout)
  );
  
  return Promise.race([fetchPromise, timeoutPromise]);
}
 
// 使用
fetchWithTimeout('/api/data', 3000)
  .then(data => console.log(data))
  .catch(err => console.log(err.message));  // 可能输出: 请求超时
 
// race 也会捕获第一个失败
Promise.race([
  Promise.reject('立即失败'),
  Promise.resolve('稍后成功')
])
.catch(err => console.log(err));  // 输出: 立即失败

// Promise.allSettled 基本用法
const p1 = Promise.resolve('成功1');
const p2 = Promise.reject('失败2');
const p3 = Promise.resolve('成功3');
 
Promise.allSettled([p1, p2, p3])
  .then(results => {
    console.log(results);
    // [
    //   { status: 'fulfilled', value: '成功1' },
    //   { status: 'rejected', reason: '失败2' },
    //   { status: 'fulfilled', value: '成功3' }
    // ]
  });
 
// 实际场景：批量请求，想知道哪些成功哪些失败
function fetchMultipleUrls(urls) {
  const promises = urls.map(url => 
    fetch(url).then(r => r.json()).catch(err => ({ error: err.message }))
  );
  
  return Promise.allSettled(promises)
    .then(results => {
      const succeeded = results.filter(r => r.status === 'fulfilled');
      const failed = results.filter(r => r.status === 'rejected');
      
      console.log(`成功 ${succeeded.length} 个，失败 ${failed.length} 个`);
      return { succeeded, failed };
    });
}

// Promise.any 基本用法
const p1 = Promise.reject('失败1');
const p2 = Promise.resolve('成功2');
const p3 = Promise.reject('失败3');
 
Promise.any([p1, p2, p3])
  .then(value => console.log(value));  // 输出: 成功2
 
// 全部失败时
Promise.any([
  Promise.reject('失败1'),
  Promise.reject('失败2')
])
.catch(error => {
  console.log(error);  // AggregateError: All promises were rejected
  console.log(error.errors);  // ['失败1', '失败2']
});
 
// 实际场景：尝试多个镜像源，取最快成功的
function fetchFromMirrors(url) {
  const mirrors = [
    'https://mirror1.com',
    'https://mirror2.com',
    'https://mirror3.com'
  ];
  
  const promises = mirrors.map(mirror => 
    fetch(`${mirror}${url}`).then(r => r.json())
  );
  
  return Promise.any(promises)
    .then(data => data)
    .catch(err => {
      console.log('所有镜像都失败了:', err.errors);
    });
}

// Promise.resolve —— 创建一个立即成功的 Promise
const p1 = Promise.resolve('数据');
p1.then(value => console.log(value));  // 输出: 数据
 
// 等价于
const p2 = new Promise(resolve => resolve('数据'));
 
// Promise.reject —— 创建一个立即失败的 Promise
const p3 = Promise.reject('错误');
p3.catch(error => console.log(error));  // 输出: 错误
 
// 注意：resolve 如果传入 Promise，会"穿透"
const innerPromise = new Promise(resolve => resolve('内部数据'));
const outerPromise = Promise.resolve(innerPromise);
 
outerPromise.then(value => console.log(value));  // 输出: 内部数据
// 不是输出 innerPromise 对象！

class MyPromise {
  // 三种状态常量
  static PENDING = 'pending';
  static FULFILLED = 'fulfilled';
  static REJECTED = 'rejected';
  
  constructor(executor) {
    // 初始状态
    this.status = MyPromise.PENDING;
    this.value = undefined;      // 成功的值
    this.reason = undefined;     // 失败的原因
    
    // 回调队列（因为可能 then 在 resolve 之前调用）
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];
    
    // resolve 函数
    const resolve = (value) => {
      // 只能改变一次
      if (this.status === MyPromise.PENDING) {
        this.status = MyPromise.FULFILLED;
        this.value = value;
        
        // 执行所有成功回调
        this.onFulfilledCallbacks.forEach(cb => cb(this.value));
      }
    };
    
    // reject 函数
    const reject = (reason) => {
      if (this.status === MyPromise.PENDING) {
        this.status = MyPromise.REJECTED;
        this.reason = reason;
        
        // 执行所有失败回调
        this.onRejectedCallbacks.forEach(cb => cb(this.reason));
      }
    };
    
    // 立即执行 executor（可能抛出错误）
    try {
      executor(resolve, reject);
    } catch (error) {
      reject(error);
    }
  }
  
  // then 方法
  then(onFulfilled, onRejected) {
    // 参数校验：如果不是函数，就穿透传值
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
    onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };
    
    // 返回新 Promise（链式调用的关键）
    const promise2 = new MyPromise((resolve, reject) => {
      
      // 成功状态 —— 立即执行
      if (this.status === MyPromise.FULFILLED) {
        // 异步执行（模拟微任务）
        setTimeout(() => {
          try {
            const x = onFulfilled(this.value);
            // 处理返回值（可能是 Promise）
            this.resolvePromise(promise2, x, resolve, reject);
          } catch (error) {
            reject(error);
          }
        }, 0);
      }
      
      // 失败状态 —— 立即执行
      if (this.status === MyPromise.REJECTED) {
        setTimeout(() => {
          try {
            const x = onRejected(this.reason);
            this.resolvePromise(promise2, x, resolve, reject);
          } catch (error) {
            reject(error);
          }
        }, 0);
      }
      
      // pending 状态 —— 存入队列（异步执行时再调用）
      if (this.status === MyPromise.PENDING) {
        this.onFulfilledCallbacks.push((value) => {
          setTimeout(() => {
            try {
              const x = onFulfilled(value);
              this.resolvePromise(promise2, x, resolve, reject);
            } catch (error) {
              reject(error);
            }
          }, 0);
        });
        
        this.onRejectedCallbacks.push((reason) => {
          setTimeout(() => {
            try {
              const x = onRejected(reason);
              this.resolvePromise(promise2, x, resolve, reject);
            } catch (error) {
              reject(error);
            }
          }, 0);
        });
      }
    });
    
    return promise2;
  }
  
  // 处理返回值（Promise A+ 规范的核心）
  resolvePromise(promise2, x, resolve, reject) {
    // 循环引用检测
    if (promise2 === x) {
      return reject(new TypeError('循环引用'));
    }
    
    // x 是 Promise
    if (x instanceof MyPromise) {
      x.then(
        value => this.resolvePromise(promise2, value, resolve, reject),
        reject
      );
    }
    // x 是对象或函数（可能有 then 方法）
    else if (typeof x === 'object' && x !== null || typeof x === 'function') {
      let then;
      try {
        then = x.then;
      } catch (error) {
        return reject(error);
      }
      
      // 如果 then 是函数，认为是 Promise-like
      if (typeof then === 'function') {
        let called = false;  // 防止多次调用
        try {
          then.call(
            x,
            (y) => {
              if (called) return;
              called = true;
              this.resolvePromise(promise2, y, resolve, reject);
            },
            (r) => {
              if (called) return;
              called = true;
              reject(r);
            }
          );
        } catch (error) {
          if (called) return;
          reject(error);
        }
      } else {
        resolve(x);  // 普通对象
      }
    }
    // x 是普通值
    else {
      resolve(x);
    }
  }
  
  // catch 方法
  catch(onRejected) {
    return this.then(undefined, onRejected);
  }
  
  // finally 方法
  finally(onFinally) {
    return this.then(
      value => {
        onFinally();
        return value;
      },
      reason => {
        onFinally();
        throw reason;
      }
    );
  }
  
  // 静态方法：resolve
  static resolve(value) {
    // 如果已经是 Promise，直接返回
    if (value instanceof MyPromise) {
      return value;
    }
    return new MyPromise(resolve => resolve(value));
  }
  
  // 静态方法：reject
  static reject(reason) {
    return new MyPromise((_, reject) => reject(reason));
  }
}
 
// 测试 MyPromise
const p = new MyPromise((resolve, reject) => {
  setTimeout(() => resolve(10), 100);
});
 
p.then(value => {
  console.log('第一次:', value);  // 10
  return value * 2;
})
.then(value => {
  console.log('第二次:', value);  // 20
  return new MyPromise(resolve => resolve(value + 5));
})
.then(value => {
  console.log('第三次:', value);  // 25
})
.catch(err => {
  console.log('错误:', err);
});

// 手写 Promise.all
MyPromise.all = function(promises) {
  return new MyPromise((resolve, reject) => {
    // 输入校验
    if (!Array.isArray(promises)) {
      return reject(new TypeError('promises must be an array'));
    }
    
    const results = [];
    let completedCount = 0;
    const total = promises.length;
    
    // 空数组直接返回空数组
    if (total === 0) {
      return resolve(results);
    }
    
    promises.forEach((promise, index) => {
      // 确保每个元素都是 Promise
      MyPromise.resolve(promise).then(
        (value) => {
          results[index] = value;  // 保持顺序
          completedCount++;
          
          // 全部完成
          if (completedCount === total) {
            resolve(results);
          }
        },
        (reason) => {
          reject(reason);  // 一个失败，整体失败
        }
      );
    });
  });
};
 
// 测试
MyPromise.all([
  MyPromise.resolve(1),
  MyPromise.resolve(2),
  MyPromise.resolve(3)
])
.then(values => console.log('all 结果:', values));  // [1, 2, 3]

// 手写 Promise.race
MyPromise.race = function(promises) {
  return new MyPromise((resolve, reject) => {
    if (!Array.isArray(promises)) {
      return reject(new TypeError('promises must be an array'));
    }
    
    // 空数组永远 pending（标准行为）
    if (promises.length === 0) {
      return;  // 永不 resolve 或 reject
    }
    
    promises.forEach(promise => {
      MyPromise.resolve(promise).then(resolve, reject);  // 第一个完成就返回
    });
  });
};
 
// 测试
MyPromise.race([
  new MyPromise(resolve => setTimeout(() => resolve('慢'), 300)),
  new MyPromise(resolve => setTimeout(() => resolve('快'), 100))
])
.then(value => console.log('race 结果:', value));  // 快

// 手写 Promise.allSettled
MyPromise.allSettled = function(promises) {
  return new MyPromise((resolve) => {
    if (!Array.isArray(promises)) {
      return resolve([]);  // 按标准，返回空数组
    }
    
    const results = [];
    let settledCount = 0;
    const total = promises.length;
    
    if (total === 0) {
      return resolve(results);
    }
    
    promises.forEach((promise, index) => {
      MyPromise.resolve(promise).then(
        (value) => {
          results[index] = { status: 'fulfilled', value };
          settledCount++;
          if (settledCount === total) {
            resolve(results);
          }
        },
        (reason) => {
          results[index] = { status: 'rejected', reason };
          settledCount++;
          if (settledCount === total) {
            resolve(results);
          }
        }
      );
    });
  });
};
 
// 测试
MyPromise.allSettled([
  MyPromise.resolve('成功'),
  MyPromise.reject('失败')
])
.then(results => console.log('allSettled 结果:', results));
// [{ status: 'fulfilled', value: '成功' }, { status: 'rejected', reason: '失败' }]

// 手写 Promise.any
MyPromise.any = function(promises) {
  return new MyPromise((resolve, reject) => {
    if (!Array.isArray(promises)) {
      return reject(new TypeError('promises must be an array'));
    }
    
    const errors = [];
    let rejectedCount = 0;
    const total = promises.length;
    
    // 空数组直接 reject
    if (total === 0) {
      return reject(new AggregateError([], 'All promises were rejected'));
    }
    
    promises.forEach((promise, index) => {
      MyPromise.resolve(promise).then(
        resolve,  // 第一个成功就直接返回
        (reason) => {
          errors[index] = reason;
          rejectedCount++;
          
          // 全部失败
          if (rejectedCount === total) {
            reject(new AggregateError(errors, 'All promises were rejected'));
          }
        }
      );
    });
  });
};
 
// AggregateError 类（如果环境不支持）
class AggregateError extends Error {
  constructor(errors, message) {
    super(message);
    this.errors = errors;
    this.name = 'AggregateError';
  }
}
 
// 测试
MyPromise.any([
  MyPromise.reject('失败1'),
  MyPromise.resolve('成功2'),
  MyPromise.reject('失败3')
])
.then(value => console.log('any 结果:', value));  // 成功2

// then 总是返回一个新的 Promise
const p1 = new Promise(resolve => resolve(1));
const p2 = p1.then(value => value + 1);
 
console.log(p1 === p2);  // false，是两个不同的 Promise
 
// 这就是链式调用的原理
p1.then(v1 => v1 + 1)
  .then(v2 => v2 * 2)   // 这是新 Promise 的 then
  .then(v3 => console.log(v3));

// async/await 写法
async function fetchData() {
  try {
    const user = await getUserInfo(userId);
    const orders = await getUserOrders(user.id);
    return orders;
  } catch (error) {
    console.error(error);
  }
}
 
// 等价的 Promise 写法
function fetchData() {
  return getUserInfo(userId)
    .then(user => getUserOrders(user.id))
    .catch(error => console.error(error));
}
 
// async 函数返回 Promise
async function hello() {
  return 'hello';
}
hello().then(value => console.log(value));  // hello

// 未捕获的 Promise 错误不会中断程序，但会静默失败
const p = Promise.reject('错误');
// 没有 catch，程序继续运行，但会有警告
 
// 最佳实践：总是添加 catch
Promise.reject('错误')
  .catch(err => console.error(err));
 
// 或使用 unhandledrejection 事件（全局捕获）
window.addEventListener('unhandledrejection', event => {
  console.error('未捕获的 Promise 错误:', event.reason);
});

// Promise 本身不能取消，但可以用 race 模拟
function makeCancelable(promise) {
  let canceled = false;
  
  const cancelPromise = new Promise((_, reject) => {
    setTimeout(() => {
      if (canceled) {
        reject(new Error('已取消'));
      }
    }, 0);
  });
  
  return {
    promise: Promise.race([promise, cancelPromise]),
    cancel() {
      canceled = true;
    }
  };
}
 
// 使用
const { promise, cancel } = makeCancelable(fetch('/api/data'));
promise.then(data => console.log(data)).catch(err => console.log(err));
cancel();  // 手动取消

console.log('1. 同步开始');
 
const p = new Promise(resolve => {
  console.log('2. Promise executor（同步执行）');
  resolve();
});
 
p.then(() => {
  console.log('4. then 回调（微任务）');
});
 
console.log('3. 同步结束');
 
// 输出顺序：1 → 2 → 3 → 4
// executor 是同步执行的！then 回调是微任务（异步）

// test-promise.js
// 复制上述手写代码，运行测试
 
// 运行
node test-promise.js