// 自定义迭代器
let range = {
  from: 1,
  to: 5,
  
  [Symbol.iterator]() {
    let current = this.from;
    return {
      next: () => {
        if (current <= this.to) {
          return {value: current++, done: false};
        } else {
          return {done: true};
        }
      }
    };
  }
};

for (let num of range) {
  console.log(num);  // 1, 2, 3, 4, 5
}

// 手动使用迭代器
let iterator = range[Symbol.iterator]();
console.log(iterator.next());  // {value: 1, done: false}
console.log(iterator.next());  // {value: 2, done: false}

// 可迭代对象的应用
let arr = [1, 2, 3];
let str = "hello";
let set = new Set([1, 2, 3]);
let map = new Map([["a", 1], ["b", 2]]);

// 都可以用for...of遍历
for (let item of arr) console.log(item);
for (let char of str) console.log(char);
for (let item of set) console.log(item);
for (let [key, value] of map) console.log(key, value);

// 展开运算符也使用迭代器
console.log([...range]);  // [1, 2, 3, 4, 5]

// 生成器函数
function* fibonacci() {
  let a = 0, b = 1;
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

let fib = fibonacci();
for (let i = 0; i < 10; i++) {
  console.log(fib.next().value);
}

// 有限生成器
function* countDown(start) {
  while (start > 0) {
    console.log(`Counting: ${start}`);
    yield start--;
  }
  console.log("Done!");
}

let counter = countDown(5);
counter.next();  // Counting: 5, {value: 5, done: false}
counter.next();  // Counting: 4, {value: 4, done: false}

// 生成器作为迭代器
function* range(start, end) {
  for (let i = start; i <= end; i++) {
    yield i;
  }
}

console.log([...range(1, 5)]);  // [1, 2, 3, 4, 5]

function* gen1() {
  yield 1;
  yield 2;
}

function* gen2() {
  yield* gen1();  // 委托给另一个生成器
  yield 3;
  yield 4;
}

for (let value of gen2()) {
  console.log(value);  // 1, 2, 3, 4
}

// yield*与字符串
function* chars(str) {
  yield* str;
}

console.log([...chars("hello")]);  // ["h", "e", "l", "l", "o"]

// 递归生成器
function* tree(node) {
  if (node.value) yield node.value;
  if (node.left) yield* tree(node.left);
  if (node.right) yield* tree(node.right);
}

let treeNode = {
  value: 1,
  left: {value: 2, left: {value: 4}, right: {value: 5}},
  right: {value: 3}
};

console.log([...tree(treeNode)]);  // [1, 2, 4, 5, 3]

// 向生成器传值
function* calculator() {
  let result = 0;
  while (true) {
    let operation = yield result;
    switch (operation) {
      case 'add': result += yield; break;
      case 'subtract': result -= yield; break;
      case 'multiply': result *= yield; break;
      case 'reset': result = 0; break;
    }
  }
}

let calc = calculator();
console.log(calc.next().value);     // 0
console.log(calc.next('add').value); // 0
console.log(calc.next(5).value);     // 5
console.log(calc.next('multiply').value); // 5
console.log(calc.next(3).value);     // 15

// 生成器的return
function* gen() {
  yield 1;
  yield 2;
  return 3;  // return的值不会在for...of中出现
}

let g = gen();
console.log(g.next());  // {value: 1, done: false}
console.log(g.next());  // {value: 2, done: false}
console.log(g.next());  // {value: 3, done: true}

// 生成器的throw
function* errorHandler() {
  try {
    yield 1;
    yield 2;
  } catch (e) {
    console.log("Error caught:", e);
    yield "error handled";
  }
}

let eh = errorHandler();
console.log(eh.next().value);    // 1
console.log(eh.throw("oops"));   // Error caught: oops, "error handled"

// 异步生成器
async function* fetchPages(url) {
  let page = 1;
  while (true) {
    const response = await fetch(`${url}?page=${page}`);
    const data = await response.json();
    if (data.length === 0) break;
    yield data;
    page++;
  }
}

// 使用异步迭代器
async function loadAllData() {
  for await (const page of fetchPages('/api/items')) {
    console.log(`Loaded page with ${page.length} items`);
    processItems(page);
  }
}

// 异步生成器实现轮询
async function* poll(interval, fn) {
  while (true) {
    const result = await fn();
    yield result;
    await new Promise(resolve => setTimeout(resolve, interval));
  }
}

// 使用
async function monitor() {
  for await (const status of poll(1000, checkServerStatus)) {
    console.log(`Server status: ${status}`);
    if (status === 'down') break;
  }
}