const Koa = require('koa');
const app = new Koa();

const doSomething = time => {
 return new Promise(resolve => {
 setTimeout(() => {
 resolve('task done!')
 }, time)
 })
}

// 用來打印請求信息
app.use((ctx, next) => {
 console.log(`${ctx.method}:::${ctx.url}`)
 next()
})

app.use(async ctx => {
 const result = await doSomething(3000)
 console.log(result);
 ctx.body = result
})

app.listen(3000);

function compose (middleware) {
 return function (context, next) {
 // 這個index用來計數，防止next被多次調用
 let index = -1
 // 執行入口
 return dispatch(0)
 
 function dispatch (i) {
 // 如果next被多次調用，報異常
 if (i <= index) return Promise.reject(new Error('next() called multiple times'))
 index = i
 // 取出第一個middleware
 let fn = middleware[i]
 // 將最初傳入的next作為最后一個函數執行
 if (i === middleware.length) fn = next
 if (!fn) return Promise.resolve()
 try {
 /**
 這里就是關鍵了,Promise.resolve是什么意思呢？
 Promise.resolve方法有下面三種形式：
 
 Promise.resolve(value);
 Promise.resolve(promise);
 Promise.resolve(theanable);
 
 這三種形式都會產生一個新的Promise。其中：

 第一種形式提供了自定義Promise的值的能力，它與Promise.reject(reason)對應。兩者的不同，在于得到的Promise的狀態不同。

 第二種形式，提供了創建一個Promise的副本的能力。

 第三種形式，是將一個類似Promise的對象轉換成一個真正的Promise對象。它的一個重要作用是將一個其他實現的Promise對象封裝成一個當前實現的Promise對象。例如你正在用bluebird，但是現在有一個Q的Promise，那么你可以通過此方法把Q的Promise變成一個bluebird的Promise。第二種形式可以歸在第三種里面
 
 **/
 return Promise.resolve(fn(context, function next () {
 // 執行下一個middleware，返回結果也是一個Promise
 return dispatch(i + 1)
 }))
 } catch (err) {
 return Promise.reject(err)
 }
 }
 }
}

app.use(async (ctx, next) => {
 console.log(`${ctx.method}:::${ctx.url}`)
 await next()
})

app.use(async ctx => {
 const result = await doSomething(3000)
 console.log(result);
 ctx.body = result
})

app.use(async (ctx, next) => {
 try{
 await next()
 }catch(err){
 console.log(err)
 }
})

app.use(async (ctx)=>{
 throw new Error('something wrong!')
 ctx.body = 'Hello'
})