// example 3.1
​
const p = {
  then: (onFulfilled) => {
    // 다은은 "then(): function () { [native code] }"를 출력합니다.
    console.log("then():", onFulfilled.toString()); 
    
    // 오류 스택에는 한가지 엔트리면 나옵니다.
    // Error
    //     at Object.then (/examples/chapter3.test.js:8:21)
    console.log(new Error().stack);
    onFulfilled("Hello, World!");
  },
};
console.log(await p); // "Hello, World!"를 출력합니다.

// example 3.2
​
const startId = 0;
let currentId = 0;
​
process.nextTick(() => ++currentId);
​
const p = {
  then: (onFulfilled) => {
    console.log("then():", currentId - startId); // "then(): 1"
    onFulfilled("Hello, World!");
  },
};
​
console.log("Before:", currentId - startId); // "Before: 0"
await p;
console.log("After:", currentId - startId); // "After: 1"

// example 3.3
​
const startId = 0;
let currentId = 0;
​
process.nextTick(() => ++currentId);
​
const p = {
  then: (onFulfilled, onRejected) => {
    console.log("then():", currentId - startId); // "then(): 1
    return onRejected(Error("Oops!"));
  },
};
​
try {
  console.log("Before:", currentId - startId); // "Before: 0"
  await p;
  console.log("This does not print");
} catch (error) {
  console.log("After:", currentId - startId); // "After: 1"
}

// example 3.4
​
async function test() {
  try {
    return Promise.reject(new Error("Oops!"));
  } catch (error) {
    return "ok";
  }
} 
​
// "Oops!"가 출력됩니다.
test().then(
  (v) => console.log(v),
  (err) => console.log(err.message)
);

// example 3.5
​
async function test() {
  try {
    const v = await Promise.reject(new Error("Oops!"));
    return v;
  } catch (error) {
    return "ok";
  }
}
​
// Prints "ok"
test().then(
  (v) => console.log(v),
  (err) => console.log(err.message)
);

// example 3.6
​
async function test() {
  try {
    return await Promise.reject(new Error("Oops!"));
  } catch (error) {
    return "ok";
  }
}
​
// Prints "ok"
test().then(
  (v) => console.log(v),
  (err) => console.log(err.message)
);

// example 3.7
​
setImmediate(() => console.log("Hello, World!"));
​
// 다음은 무한 루프에 빠집니다. 그래서 이벤트 루프로 돌아가지 못하므로 
//   위 콜백의 console.log는 결코 작동하지 않습니다.
while (true) {}

// example 3.8
​
function foo() {
  let x = 0;
​
  // foo()를 마치고, bar()가 후에 실행되더라도 여전히 x를 이용할 수 있습니다.
  setImmediate(bar);
​
  // baz()가 마칠 때까지 foo() 실행이 중단됩니다
  baz();
​
  function bar() {
    ++x;
  }
  function baz() {
    ++x;
  }
}

// example 3.9
​
run().catch((error) => console.error(error.stack));
​
async function run() {
  // await 할 때마다 run()이 일시정지되기 때문에 아래 콜백이 수행됩니다.
  setImmediate(() => console.log("Hello, World!"));
​
  // 루프를 돌 때 마다, run() 함수가 일시정지 되고 다음 tick에 재개됩니다.
  while (true) {
    await new Promise((resolve) => setImmediate(resolve));
  }
}

// example 3.10
​
await Promise.all([fibonacci(50000), fibonacci(50000)]);
​
async function fibonacci(n) {
  let [prev2, prev1, cur] = [1, 1, 1];
​
  for (let i = 2; i < n; ++i) {
    // 다른 호출이 진행될 수 있도록 fibonacci()를 일시정지 시킵니다
    await new Promise((resolve) => setImmediate(resolve));
​
    // "Fib: 10000"
    // "Fib: 10000"
    // "Fib: 20000" ...
    if (i % 10000 === 0) console.log("Fib:", i);
    
    cur = prev1 + prev2;
    prev2 = prev1;
    prev1 = cur;
  }
  return cur;
}

// example 3.11
​
// The `function*`표현으로 일반함수를 generator() 함수로 만듭니다.
const generatorFunction = function* () {
  console.log("Step 1");
  yield 1;
  console.log("Step 2");
  yield 2;
  console.log("Done");
};
​
// generator 함수의 반환값은 generator 객체입니다.
// generator 함수는 여러분이 next()를 호출할 때 시작합니다.
const generatorObject = generatorFunction();
let yielded = generatorObject.next(); // Prints "Step 1"
​
console.log(yielded.value); // Prints "1"
yielded = generatorObject.next(); // Prints "Step 2"
​
console.log(yielded.value); // Prints "2"
generatorObject.next(); // Prints "Done"

// example 3.12
​
const co = require("co");
​
// co.wrap()은 generator를 async 함수처럼 만들어 줍니다.
const runCo = co.wrap(function* () {
  // 1초후 'Hello, World!'를 출력합니다.
  yield new Promise((resolve) => setTimeout(() => resolve(), 1000));
  console.log("Hello, World!");
});
​
// In particular, wrapped functions return a promise
runCo().catch((error) => console.log(error.stack));

// example 3.13
​
const runCo = co.wrap(function* () {
  const p1 = Promise.resolve("Hello");
  const p2 = Promise.resolve("World");
​
  // Co는 promise 배열이나 promise 속성을 갖는 객체들의 배열을 바꿀 수 있습니다. 
  // async/await 라면, promise 배열에 await을 하기 위해서는 
  //    Promise.all()을 사용해야만 했습니다.
  console.log(yield [p1, p2]); // [ 'Hello', 'World' ]
  console.log(yield { p1, p2 }); // { p1: 'Hello', p2: 'World' }
});

// example 3.14
​
const runCo = co.wrap(function* () {
  // 'TypeError: You may only yield a function, promise, generator,
  // array, or object but the following object was passed: "1"'
  yield 1;
});

// example 3.15
​
const runCo = co.wrap(function* () {
  yield new Promise((resolve) => setImmediate(resolve));
  throw new Error("Oops!");
});
​
// Error: Oops!
// at /test.js:3:9
// at Generator.next (<anonymous>)
// at onFulfilled (/node_modules/co/index.js:65:19)
// at <anonymous>
runCo().catch((error) => console.log(error.stack));

// example 3.16
​
async function runAsync() {
  await new Promise((resolve) => setImmediate(resolve));
  throw new Error("Oops!");
}
​
// Error: Oops!
// at runAsync (/home/val/test.js:5:9)
// at <anonymous>
runAsync().catch((error) => console.log(error.stack));

// example 3.17
​
async function findSubstr(arr, str) {
  // Don't do this! There's no reason for this function to be async
    // 이런거 하지 마세요. 이 함수가 비동기 함수여야할 이유가 없습니다.
  for (let i = await 0; i < arr.length; ++i) {
    if (await arr[i].includes(str)) return arr[i];
  }
}

// example 3.18
​
async function run() {
  const p1 = Promise.resolve(1);
  const p2 = Promise.resolve(2);
​
  // 'arr1'은 array이지 promise가 아닙니다. 따라서 동작하지 않습니.
  const arr1 = await [p1, p2];
​
  // arr1은 배열이기 때문에 promise를 반환하는 도우미 함수 Promise.all을 사용해야 한다.
  const arr2 = await Promise.all(arr1);
}

// example 3.19
​
async function fn1() {
  // 괜찮지만, example 3.4에서 보았듯이 try/catch 사용시 오류를 처리하지 못하는
  //   문제가 있습니다.
  return asyncFunction();
}
​
async function fn2() {
  // 몇 줄 더 들어가긴 하지만 문제 소지가 적습니다. 이 함수 내부에서 
  //  asyncFunction()의 오류들을 처리하고자 한다면 이 방법이 좋다.
  const ret = await asyncFunction();
  return ret;
}

// example 3.20
​
async function test() {
    const p1 = Promise.resolve(1);
    const p2 = Promise.resolve(2);
​
    // SyntaxError: Unexpected identifier
    [p1, p2].forEach(p => { await p; });
}

// example 3.21
​
async function test() {
  const p1 = Promise.resolve(1);
  const p2 = Promise.resolve(2);
​
  // 배열 개수 만큼, 2개의 async 함수를 준비했지만 test()를 일시 정지시키지는 않습니다.
  // await p로 정지되는 것은 test()가 아닌 화살표 함수입니다.
  [p1, p2].forEach(async (p) => {
    console.log(await p);
  });
​
  // '1', '2' 보다 먼저 'Done'이 출력됩니다. 왜내하면 await p는 test()가 아닌 
  //   화살표 함수를 일시정지 시키기 때문입니다.
  console.log("Done");
}

// example 3.22
​
async function fn1() {
  // p 가 rejeced 일 때, return p로 그 오류를 잡지 못합니다.
  try {
    /* Complex logic */
  } catch (err) {
    handleError(err);
  }
}
​
async function fn2() {
  /* Complex logic */
}
​
// 아주 좋습니다~~
fn2().catch(handleError);

// example 3.23
​
const wrap = (fn) =>
  function () {
    // 함수 호출이 오류 처리기를 갖도록 보장합니다.
    return fn.apply(null, arguments).catch((error) => console.log(error));
  };
​
const [fn1, fn2] = [
  async function () {
    throw Error("err1");
  },
  async function () {
    throw Error("err2");
  },
].map(wrap);
​
fn1(); // Prints "err1"
fn2(); // Prints "err2"

superagent.get(url).set('API-Key', 'test').end((err, res) => { /* Handle response */ });

class HTTPRequest {
  // 오직 아래 then() 만 수정하세요.
  static create() {
    return new HTTPRequest();
  }
  get(url) {
    this.method = "get";
    this.url = url;
    return this;
  }
  exec(callback) {
    fetch(this.url, this)
      .then((res) => res.json())
      .then((res) => callback(null, res))
      .catch(callback);
  }
  then(onFulfilled, onRejected) {
    throw new Error("Not Implemented"); // Implement this function
  }
}
​
// Don't modify the below code
run().catch((error) => console.error(error.stack));
async function run() {
  const url =
    "https://" + "us-central1-mastering-async-await.cloudfunctions.net/posts";
  const res = await HTTPRequest.create().get(url);
  console.log("Success", res[0].id === 51);
}

async function fn1() {
    // SyntaxError: await p는 async 함수 fn1에 있질 않습니다
    [1, 2].forEach(p => { 
        await p; 
    });
}
​
async function fn2() {
    [Promise.resolve(1), Promise.resolve(2)].forEach(async (p) => { 
            console.log(await p); 
        });
​
    // '1' & '2'에 앞서 'Done'이 출력됩니다. 왜냐하면, 
    //    위 await은 화살표 함수를 일시정지 시킵니다. fn2()가 아닙니다! 
    console.log('Done');
}

// 다음 함수를 구현하세요.
async function forEachAsync(arr, fn) {
  throw Error("Not Implemented!");
}
​
// Below is test code, don't modify this
run().catch((err) => console.log(err.stack));
​
async function run() {
  let i = 0;
  const arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
​
  async function fn1(n) {
    await new Promise((resolve) => setTimeout(resolve, 100 - n * 10));
    if (i++ !== n) throw Error("Make sure to `await` on `fn()`");
  }
​
  await forEachAsync(arr, fn1);
  if (i !== 10) throw Error("Call `fn()` on every array element");
  console.log("Success!");
}