const http = require('http')

const server = http.createServer((req, res) => {
// ÿһ´ÎÇëÇó´¦ÀíµÄ·½·¨
console.log(req.url)
res.writeHead(200, { 'Content-Type': 'text/plain' })
res.end('Hello NodeJS')
})

server.listen(8080)

// application.js
listen(...args) {
const server = http.createServer(this.callback());
return server.listen(...args);
}

callback() {
// ×éÖ¯Öмä¼þ
const fn = compose(this.middleware);

// δ¼àÌýÒì³£´¦Àí£¬Ôò²ÉÓÃĬÈϵÄÒì³£´¦Àí·½·¨
if (!this.listenerCount('error')) this.on('error', this.onerror);

const handleRequest = (req, res) => {
// Éú³ÉcontextÉÏÏÂÎĶÔÏó
const ctx = this.createContext(req, res);
return this.handleRequest(ctx, fn);
};

return handleRequest;
}

handleRequest(ctx, fnMiddleware) {
const res = ctx.res;
// ĬÈÏ״̬ÂëΪ404
res.statusCode = 404;
// Öмä¼þÖ´ÐÐÍê±ÏÖ®ºó ²ÉÓÃĬÈ쵀 ´íÎó Óë ³É¹¦ µÄ´¦Àí·½Ê½
const onerror = err => ctx.onerror(err);
const handleResponse = () => respond(ctx);
onFinished(res, onerror);
return fnMiddleware(ctx).then(handleResponse).catch(onerror);
}

Object.defineProperties(http.IncomingMessage.prototype, {
query: {
get () {
return querystring.parse(url.parse(this.url).query)
}
}
})

Object.defineProperties(http.ServerResponse.prototype, {
json: {
value: function (obj) {
if (typeof obj === 'object') {
obj = JSON.stringify(obj)
}
this.end(obj)
}
}
})

// application.js
createContext(req, res) {
const context = Object.create(this.context);
const request = context.request = Object.create(this.request);
const response = context.response = Object.create(this.response);
context.app = request.app = response.app = this;
context.req = request.req = response.req = req; // ±£´æÔ­Éúreq¶ÔÏó
context.res = request.res = response.res = res; // ±£´æÔ­Éúres¶ÔÏó
request.ctx = response.ctx = context;
request.response = response;
response.request = request;
context.originalUrl = request.originalUrl = req.url;
context.state = {};
// ×îÖÕ·µ»ØÍêÕûµÄcontextÉÏÏÂÎĶÔÏó
return context;
}

// request.js
get header() {
return this.req.headers;
},
set header(val) {
this.req.headers = val;
},

ctx.request.header

function access (proto, target, name) {
Object.defineProperty(proto, name, {
get () {
return target[name]
},
set (value) {
target[name] = value
}
})
}

access(context, request, 'header')

function method (proto, target, name) {
proto[name] = function () {
return target[name].apply(target, arguments)
}
}

function use(route, fn) {
var handle = fn;
var path = route;

// ²»´«ÈërouteÔòĬÈÏΪ'/'£¬ÕâÖÖ»ù±¾ÊÇ¿ò¼Ü´¦Àí²ÎÊýµÄÒ»ÖÖÌ×·
if (typeof route !== 'string') {
handle = route;
path = '/';
}

...
// ´æ´¢Öмä¼þ
this.stack.push({ route: path, handle: handle });

// ÒÔ±ãÁ´Ê½µ÷ÓÃ
return this;
}

function handle(req, res, out) {
var index = 0;
var stack = this.stack;
...
function next(err) {
...
// ÒÀ´ÎÈ¡³öÖмä¼þ
var layer = stack[index++]

// ÖÕÖ¹Ìõ¼þ
if (!layer) {
defer(done, err);
return;
}

var path = parseUrl(req).pathname || '/';
var route = layer.route;

// ·ÓÉÆ¥Åä¹æÔò
if (path.toLowerCase().substr(0, route.length) !== route.toLowerCase()) {
return next(err);
}
...
call(layer.handle, route, err, req, res, next);
}

next();
}

function call(handle, route, err, req, res, next) {
var arity = handle.length;
var error = err;
var hasError = Boolean(err);

try {
if (hasError && arity === 4) {
// ´íÎó´¦ÀíÖмä¼þ
handle(err, req, res, next);
return;
} else if (!hasError && arity < 4) {
// ÇëÇó´¦ÀíÖмä¼þ
handle(req, res, next);
return;
}
} catch (e) {
// ¼Ç¼´íÎó
error = e;
}

// ½«´íÎó´«µÝÏÂÈ¥
next(error);
}

use(fn) {
this.middleware.push(fn);
return this;
}

function compose (middleware) {
if (!Array.isArray(middleware)) throw new TypeError('Middleware stack must be an array!')
for (const fn of middleware) {
if (typeof fn !== 'function') throw new TypeError('Middleware must be composed of functions!')
}

/**
* @param {Object} context
* @return {Promise}
* @api public
*/

return function (context, next) {
let index = -1
return dispatch(0)
function dispatch (i) {
if (i <= index) return Promise.reject(new Error('next() called multiple times'))
index = i
let fn = middleware[i]
if (i === middleware.length) fn = next
if (!fn) return Promise.resolve()
try {
// µÝ¹éµ÷ÓÃÏÂÒ»¸öÖмä¼þ
return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
} catch (err) {
return Promise.reject(err)
}
}
}
}

this.app.emit('error', err, this);

// Ò²¿ÉÒÔÕâÑù×Ô¶¨Òå´íÎó´¦Àí
app.use(async (ctx, next) => {
try {
await next();
} catch (err) {
ctx.status = err.status || 500
ctx.body = err
}
})