// example 4.1
​
// Express는 node.js를 위한 가장 유명한 웹 프레임워크입니다.
const app = require("express")();
​
// Express는 promise를 반환하는 함수들을 처리할 수 있나요?
app.get("*", async function (req, res) {
  await new Promise((resolve) => setTimeout(resolve, 1000));
  res.send("Hello, World!");
});

// example 4.2
​
// superagent는 node.js를 위한 가장 유명한 HTTP client 라이브러리입니다.
const superagent = require("superagent");
run().catch((error) => console.error(error.stack));
​
async function run() {
  // superagent가 제공하는 get()는 thenables를 반환하나요? 
  const response = await superagent.get("http://google.com");
}

// example 4.3
​
const assert = require("assert");
​
describe("Array", function () {
  describe("#indexOf()", function () {
    it("should return -1 when the value is not present", function () {
      assert.equal([1, 2, 3].indexOf(4), -1);
    });
  });
});

// example 4.4
​
describe("async", function () {
  it("works", async function () {
    assert.equal(await Promise.resolve(42), 42);
  });
});

// example 4.5
​
const app = require('express')(); 
​
app.get('*', (req, res) => res.send('Hello, World!')); 
​
const server = app.listen(3000);

// example 4.6
​
const app = require('express')();
​
app.get('*', async (req, res) => res.send('Hello, World!')); 
​
const server = app.listen(3000);

// example 4.7
​
const app = require("express")(); 
​
// 프로그램은 오류가 나서 HTTP response도 보내지 않는 상황입니다.
app.get("*", async () => {
  throw Error("Oops!");
});
​
const server = app.listen(3000); 
​
// 이번 GET request는 오류도 'Oops!' error로 발생하지 않습니다.
const request = superagent.get("http://localhost:3000").end();

// example 4.8
​
app.get("*", wrap(async () => {
    throw Error("Oops!");
  })
);
​
const server = app.listen(3000);
​
try {
  await superagent.get("http://localhost:3000");
} catch (error) {
  // error.response.text === 'Oops!'
}
​
function wrap(fn) {
  return (req, res) =>
    fn(req, res).catch((error) => {
      if (res.headersSent) {
        // `headersSent` means Express has already started sending
        // an HTTP response, so we can't report the error via the
        // HTTP response. Depending on your app's needs, you may
        // choose to rethrow the error here, or ignore it.
        return;
      } 
      // Error occurred, set the response status to 500 (Internal
      // Server Error) and send the error message.
      res.status(500).send(error.message);
    });
}

// example 4.9
​
const { MongoClient } = require("mongodb");
const uri = "mongodb://localhost:27017/test";
const client = await MongoClient.connect(uri);
const db = client.db("test");
​
await db.collection("test").insertOne({ answer: 42 }); // Create
​
const doc = await db.collection("test").findOne(); // Read
​
console.log(doc.answer); // Prints "42"

// example 4.10
​
await db.collection("Movie").insertMany([
  { title: "Star Wars", year: 1977 },
  { title: "The Empire Strikes Back", year: 1980 },
  { title: "Return of the Jedi", year: 1983 },
]);
​
// find()는 커서를 반환합니다. 여기에 await은 하지 마세요.
const cursor = db.collection("Movie").find();
​
for (let v = await cursor.next(); v != null; v = await cursor.next()) {
  console.log(v.year); // Prints "1977", "1980", "1983"
}

// example 4.11
​
// _store_는 상태를 추적하고 _actions_을 여러분이 처리토록 합니다. 
const { createStore } = require("redux");
​
// _reducer_는 상태를 바꾸는 동기 함수입니다.
// Redux는 action 마다 reducer를 호출합니다.
const reducer = (state, action) => {
  switch (action.type ) 
  {
    case "INCREMENT":
      return state + 1;
    case "DECREMENT":
      return state - 1;
    default:
      return state;
  }
};
​
// 신규 store를 생성하고 상태변화를 수신할 모니터를 등록합니다.
const store = createStore(reducer, 0);
store.subscribe(() => console.log(store.getState()));
store.dispatch({ type: "INCREMENT" }); // Prints "1"
store.dispatch({ type: "INCREMENT" }); // Prints "2"
store.dispatch({ type: "DECREMENT" }); // Prints "1"

// example 4.12
​
store.subscribe(() => console.log(store.getState()));
​
run().catch((error) => console.log(error.stack));
​
async function run() {
  store.dispatch({ type: "INCREMENT" }); // Prints "1"
  await new Promise((resolve) => setImmediate(resolve));
  store.dispatch({ type: "INCREMENT" }); // Prints "2"
}

// example 4.13
​
const { createStore, applyMiddleware } = require("redux");
const thunk = require("redux-thunk").default;
​
// The 3rd arg to `createStore()` is composed Redux _middleware_
const store = createStore(reducer, 0, applyMiddleware(thunk));
store.subscribe(() => console.log(store.getState()));
​
// `redux-thunk` lets you dispatch _action creators_, which are
// potentially async functions that can `dispatch()` more actions
store.dispatch(async (dispatch) => {
  dispatch({ type: "INCREMENT" }); // Prints "1"
  await new Promise((resolve) => setImmediate(resolve));
  dispatch({ type: "INCREMENT" }); // Prints "2"
});

// example 4.14
​
const { renderToString } = require("react-dom/server");
const { createElement, Component } = require("react");
​
class MyComponent extends Component {
  render() {
    return createElement("h1", null, "Hello, World!");
  }
}
​
// <h1 data-reactroot="">Hello, World!</h1>
console.log(renderToString(createElement(MyComponent)));

// example 4.15
​
class MyComponent extends Component {
  componentWillMount() {
    this.setState({ v: "Hello, World!" });
  }
  render() {
    return createElement("h1", null, this.state.v);
  }
}
​
// <h1 data-reactroot="">Hello, World!</h1>
console.log(renderToString(createElement(MyComponent)));

// example 4.16
​
class MyComponent extends Component {
  async componentWillMount() {
    this.setState({ text: null });
    await new Promise((resolve) => setImmediate(resolve));
    this.setState({ text: "Hello, World!" });
  }
  render() {
    return createElement("h1", null, this.state.text);
  }
}
​
// <h1 data-reactroot=""></h1>
console.log(renderToString(createElement(MyComponent)));

// example 4.17
​
class MyComponent extends Component {
  async componentWillMount() {
    this.setState({ text: null });
    await new Promise((resolve) => setImmediate(resolve));
    
    // Unhandled promise rejection
    throw Error("Oops");
  }
  render() {
    return createElement("h1", null, this.state.text);
  }
}
​
// <h1 data-reactroot=""></h1>
console.log(renderToString(createElement(MyComponent)));

// example 4.18
​
const reducer = (state, action) => Object.assign({}, state, action);
const store = createStore(reducer, { v: "" }, applyMiddleware(thunk));
​
class MyComponent extends Component {
  componentWillMount() {
    this.setState(store.getState());
  }
  render() {
    return createElement("h1", null, this.state.v);
  }
}
​
store.dispatch(async (dispatch) => {
  await new Promise((resolve) => setTimeout(resolve, 250));
  dispatch({ type: "SET", v: "Hello, World!" });
});
​
setInterval(() => {
  // First 2 will print an empty <h1>, then "Hello, World!"
  console.log(renderToString(createElement(MyComponent)));
}, 100);

// example 4.19
​
const wrap = (fn) => (dispatch) => {
  fn(dispatch).catch((error) => dispatch({ type: "ERROR", error }));
};
​
store.dispatch(
  wrap(async (dispatch) => {
    await new Promise((resolve) => setTimeout(resolve, 250));
    dispatch({ type: "SET", v: "Hello, World!" });
  })
);

agenda.schedule('tomorrow at noon', 'printAnalyticsReport', {
 userCount: 100
});

agenda.schedule('tomorrow at noon', [
 'printAnalyticsReport',
 'sendNotifications',
 'updateUserRecords'
]);

const ws = new WebSocket('wss://echo.websocket.org/');
ws.onmessage = e => console.log('Got', e.data);

// Implement this function
function wrap(onmessage) {
 console.log('Not implemented')
}
​
// Do not modify the below code
const ws = new WebSocket('wss://echo.websocket.org/');
​
ws.onmessage = wrap(async function(e) {
 throw Error('Congratulations, you completed this exercise!');
});
​
ws.onopen = () => ws.send('Hello, World');
ws.onclose = () => console.log('disconnected');