// es6的语法可以用
module.exports = {
	a: '',
	b: '',
}
const { a, b } = require()

// get
const http = require('http')
const querystring = require('querystring')
const server = http.createServer((req, res) => {
	const { url, method } = req
	console.log('method:', method)
	console.log('url:', url)
	req.query = querystring.parse(url.split('?')[1])
	console.log('query:', req.query)
	res.end(JSON.stringify(req.query))
})
server.listen(8000)
// post
const server = http.createServer((req, res) => {
	const { url, method } = req
	if (method === 'post') {
		console.log(req.headers['content-type'])
		// 接受数据
		let postData = ''
		// 接收的数据太大的话会分开，然后拼接
		req.on('data', chunk => {
			postData += chunk.toString()
		})
		// 数据传输完触发该事件
		req.on('end', () => {
			console.log(postData)
			res.end('hi') // 是异步的数据所以写在这里
		})
	}
})

"scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    // cross-env兼容不同的环境，nodemon监控文件变化
    "dev": "cross-env NODE_ENV=dev nodemon ./bin/www.js"
},

const fs = require('fs')
const path = require('path')
const fullFileName = path.resolve(__dirname, 'files', 'a.json')
fs.readFile(fullFileName, (err, data) => {
	if (err) {
		console.error(err)
		return
	}
	console.log(data.toString())
})

// callback方式获取一个文件的内容
function getFileContent(fileName, callback) {
	const fullFileName = path.resolve(__dirname, 'files', fileName)
	fs.readFile(fullFileName, (err, data) => {
		if (err) {
			console.error(err)
			return
		}
		callback(JSON.parse(data.toString()))
	})
}

getFileContent('a.json', aData => {
	console.log(aDate)
})

// promise获取文件内容
function getFileContent(fileName) {
	const promise = new Promise((resolve, reject) => {
		const fullFileName = path.resolve(__dirname, 'files', fileName)
		fs.readFile(fullFileName, (err, data) => {
			if (err) {
				reject(err)
				return
			}
			resolve(JSON.parse(data.toString()))
		})
	})
}

getFileContent('a.json')
	.then(aData => {
		console.log(aData)
		return getFileContent(aData.next)
	})
	.then(bData => {
		console.log(bData)
	})

const redis = require('redis')
// 创建客户端
const redisClient = redis.createClient(6379, '127.0.0.1')
redisClient.on('error', err => {
	console.error(err)
})

// 测试
redisClient.set('name', 'aaa', redis.print)
redisClient.get('name', (err, val) => {
	if (err) {
		console.error(err)
		return
	}
	console.log('val', val)

	// 退出
	redisClient.quit()
})

const fs = require('fs')
const path = require('path') // 各个操作系统，文件路径不通，统一一下。

const fileName = path.resolve(__dirname, 'data.text') // 当前目录的data.text

// 读取文件
fs.readFile(fileName, (err, data) => {
	if (err) {
		console.error(err)
		return
	}
	// data是二进制类型，需要转化成字符串
	// 如果内容太多，data也是全部的内容，性能不好
	console.log(data.toString())
})

// 写入文件,如果内容太多，data也是全部的内容，性能不好
const content = '新的内容'
const opt = {
	flag: 'a', // 追加写入。覆盖用w
}
fs.writeFile(fileName, content, opt, err => {
	if (err) {
		console.error(err)
		return
	}
})

// 判断文件是否存在
fs.exists(fileName, exist => {
	console.log(exist) // true, false
})

// IO操作的性能瓶颈
IO：网络IO，文件IO
相比于cpu计算和内存读写，io就是慢
有限的硬件资源下提高io的效率

stream: 就是一个流，两个水桶中间插一个管子, 数据量太大，字符串拼接也是这个原理
标准输入输出，pipe就是管道
process.stdin 获取数据，直接通过管道传递给process.stdout
process.stdin.pipe(process.stdout)

http.createServer((req, res) => {
    if(req.method === 'POST') {
        req.pipe(res) // 一旦接收到请求就把参数返回出去
    }
})

// stream 读取文件, 把one.text中的数据拷贝到two.text
const = fileName1 = path.resolve(__dirname, 'one.text')
const = fileName2 = path.resolve(__dirname, 'two.text')

const readStream = fs.createReadStream(fileName1)
const writeStream = fs.createWriteStream(fileName2)

readStream.pie(writeStream)
readStream.on('data', (chunk) => {
    console.log(chunk.toString())
})
readStream.on('end', () => {
    console.log('copy done')
})

// http请求，返回一个文件内容
http.createServer((req, res) => {
    if(req.method === 'GET') {
        const = fileName1 = path.resolve(__dirname, 'one.text')
        fileName1.pie(res)
    }
})

const fs = require('fs')
const path = require('path')
const readline = require('readline')

// 文件名
const fileName = path.resolve(__dirname, 'data.text')
// 创建read Stream （源水桶）
const readStream = fs.createReadStream(filName)

// 创建readline对象
const rl = readline.createInterface({
	input: readStream,
})

let chromeNum = 0
let num = 0

// 逐行读区
rl.on('line', lineData => {
	if (!lineData) {
		return
	}
	// 记录总行数
	sum++
	const arr = lineData.split(' -- ')
	if (arr[2] && arr[2].indexOf('Chrome') > 0) {
		// 累加chrome的数量
		chromeNum++
	}
})

// 监听读取完成
rl.on('close', () => {
	console.log('chrome 的占比:' + chromeNum / sum)
})

const crypto = require('crypto')
// 密匙(随便写,但是要保密)
const SECRET_KEY = 'sdfW_98393#'
// md5 加密
function md5(content) {
	let md5 = crypto.createHash('md5')
	return mds.update(content).digest('hex')
}
// 加密函数
function genPassword(password) {
	const str = `password=${password}&key=${SECRET_KEY}`
}

// 测试
genPassword('123')

// app.use() next 参数
const express = require('express')

// 本次http请求的实例
const app = express()

// 如果没有第一个参数，默认执行该中间件，有的话，url命中才执行
// next() 会执行下一个app.use 或者app.get，但是app.post不会执行
app.use((req, res, next) => {
	console.log('aaa', req.method, req.url)
	next()
})

app.use((req, res, next) => {
	req.cookie = {
		userId: 'lyr',
	}
	next()
})

app.use((req, res, next) => {
	setTimeout(() => {
		req.body = {
			a: 100,
			b: 200,
		}
		next()
	})
})

app.use('/api', (req, res, next) => {
	console.log('use', req.method, req.url)
	next()
})

app.get('/api', (req, res, next) => {
	console.log('get', req.method, req.url)
	next()
})

// next不会执行
app.post('/api', (req, res, next) => {
	console.log('post', req.method, req.url)
	next()
})

// 其实这种写法就是中间件中套中间件
function loginCheck(req, res, next) {
	console.log('模拟登录成功')
	setTimeout(() => {
		next()
	})
}

app.get('/api/get-cookie', loginCheck, (req, res, next) => {
	console.log('/get-cookie', req.method, req.url)
	res.json({
		errno: 0,
		data: req.cookie,
	})
})

app.post('/api/get-post-data', (req, res, next) => {
	console.log('/get-post-data', req.method, req.url)
	res.json({
		errno: 0,
		data: req.body,
	})
})

app.use((req, res, next) => {
	console.log('404')
	res.json({
		errno: 0,
		data: 'not fund',
	})
})

app.listen(3000, () => {
	console.log('start')
})

const logger = require('morgan')
const app = express()
app.use(logger('dev'))
// 默认的第二个参数是(即默认输出到控制台上)
app.use(logger('dev'), {
	stream: process.stdout,
})
// 第一个参数的值
// 'dev': 日志的格式, 还有很多

// 线上环境，将日志写入文件
const logFileName = path.join(__dirname, 'logs', 'access.log')
const writeStream = fs.createWriteStream(logFileName, {
	flages: 'a',
})
app.use(
	logger('combined', {
		stream: writeStream,
	})
)

//
const http = require('http')
const slice = (Array = Array.prototype.slice)

class LikeExpress {
	constructor() {
		// 存放中间件的列表
		this.routes = {
			all: [], // 存储通过app.use()传人的中间件
			get: [],
			post: [],
		}
	}

	register(path) {
		const info = {}
		if (typeof path === 'string') {
			info.path = path
			// 从第二个参数开始，转换为数组，存入stack
			info.stack = slice.call(arguments, 1)
		} else {
			info.path = '/'
			// 从第一个参数开始，转换为数组，存入stack
			info.stack = slice.call(arguments, 0)
		}
		return info
	}
	use() {
		const info = this.register.apply(this, arguments)
		this.routes.all.push(info)
	}
	get() {
		const info = this.register.apply(this, arguments)
		this.routes.get.push(info)
	}
	post() {
		const info = this.register.apply(this, arguments)
		this.routes.post.push(info)
	}
	match(method, url) {
		let stack = []
		if (url === '/favicon.ico') {
			return stack
		}
		// 通过routes, 获取可用的中间件
		let curRoutes = []
		curRoutes = curRoutes.concat(this.routes.all)
		curRoutes = curRoutes.concat(this.routes[method])

		curRoutes.forEach(routeInfo => {
			// 通过路由匹配一层
			if (url.indexOf(routeInfo.path) === 0) {
				stack = stack.concat(routeInfo.stack)
			}
		})
		return stack
	}
	handle(req, res, stack) {
		const next = () => {
			// 拿到第一个匹配的中间件
			const middleware = stack.shift()
			if (middleware) {
				// 执行中间件函数
				middleware(req, res, next)
			}
		}
		next()
	}
	callback() {
		return (req, res) => {
			res.json = data => {
				res.setHeader('Constent-type', 'application/json')
				res.end(JSON.stringify(data))
			}
			const url = req.url
			const method = req.method.toLowerCase()

			// 匹配可用的中间件列表
			const resultList = this.match(method, url)
			// 执行中间件，处理next机制
			this.handle(req, res, resultList)
		}
	}
	listen(...args) {
		// 回调函数中处理请求头和返回数据等东西
		const server = http.createServer(this.callback())
		server.listen(...args)
	}
}

// 工厂函数
module.exports = () => {
	return new LikeExpress()
}

;(function(exports, require, modele, __filename, __dirname) {
	// code
})()