// 如果和包名相同且只有一个命令可以直接写路径字符串
{
  "bin": "./index.js",
}

// 对象形式可以自定义名称，也可以一次定义多个命令
{
  "bin": {
    "baka": "./baka.js",
    "senkun": "./senkun.js"
  },
}

// 第一个命令
main()

function main() {
  console.log('hello world!')
}

// 获取信息
const { name, version, description } = require('./package.json')

const appName = name.replace('-cli', '')

// app 支持的参数列表
const app = {
  'h': showHelp,
  'v': showVersion,
}

main()

// 修改 main 方法
function main() {
  // 获取参数
  // 有效参数从第三个开始，前两个是 node 和 index.js
  const args = process.argv.slice(2)

  // 获取操作符,去掉 '-'
  const operation = args[0].substr(1)

  // 执行程序
  app[operation]()
}

function showHelp() {
  const help = `${name} ${description}

usage: ${appName} [options] [arguments]

options:
  -h:     show help
  -v:     show version
`
  console.log(help)
}

function showVersion() {
  console.log(version)
}

const fs = require('fs')
const path = require('path')
const { name, version, description } = require('./package.json')
const todoList = require('./todo.json')

const appName = name.replace('-cli', '')

const app = {
  'c': create,
  'd': done,
  'r': remove,
  's': reset,
  'l': listAll,
  'h': showHelp,
  'v': showVersion,
}

main()

function main() {
  // 有效参数从第三个开始
  const args = process.argv.slice(2)

  // 默认输出列表
  if (!args.length) {
    listAll()
    return
  }

  // 获取操作符，支持简写和单词
  const operation = args[0].length === 2 ? args[0].substr(1) : args[0].substr(2, 1)

  // 参数错误则展示帮助
  if (!args[0].startsWith('-') || !operation || !Object.keys(app).includes(operation)) {
    showHelp()
    return
  }

  app[operation](args[1])
}

function create(job) {
  const index = todoList.todo.indexOf(job)
  const doneIndex = todoList.done.indexOf(job)
  if (index === -1 && doneIndex === -1) todoList.todo.push(job)

  save()
}

function done(job) {
  let index = todoList.todo.indexOf(job)
  if (index > -1) todoList.todo.splice(index, 1)

  index = todoList.done.indexOf(job)
  if (index === -1) todoList.done.push(job)

  save()
}

function remove(job) {
  let index = todoList.todo.indexOf(job)
  if (index > -1) todoList.todo.splice(index, 1)

  index = todoList.done.indexOf(job)
  if (index > -1) todoList.done.splice(index, 1)

  save()
}

function reset() {
  todoList.todo = []
  todoList.done = []

  save()
}

function listAll() {
  const todo = todoList.todo.length ? '☐ ' + todoList.todo.join('\n  ☐ ') : ''
  const done = todoList.done.length ? '✔ ' + todoList.done.join('\n  ✔ ') : ''
  const info = `Todo:
----------
  ${todo}

Done:
----------
  ${done}
  `

  console.log(info)
}

function showHelp() {
  const help = `${name} ${description}

usage: ${appName} [options] [arguments]

options:
  -c, --create:   create job
  -d, --done:     mark that the job is done
  -r, --remove:   remove job
  -s, --reset:    reset the list
  -l, --list:     list all job
  -h, --help:     show help
  -v, --version:  show version
`
  console.log(help)
}

function showVersion() {
  console.log(version)
}

function save() {
  const file = path.resolve(__dirname, './todo.json')
  const data = JSON.stringify(todoList)
  fs.writeFile(file, data, 'utf8', (err) => {
    if (err) {
      console.error(err)
    } else {
      listAll()
    }
  })
}

// 思路是判断数据是否已存在，不存在则新建元素。需要注意的是，每次要返回已创建或者找到的父元素
function convert(source) {
  const target = []

  // 生成基本的数据结构
  const createNode = (id, label) => ({ id, label })

  // 创建 root 对象
  const createRoot = (node, list) => {
    const isExistList = list.filter(item => item.id === node.id)
    if (!isExistList[0]) list.push(node)
    // 返回创建或已存在的数据
    return isExistList[0] || node
  }

  // 插入数据到父节点
  const insertNode = (node, parent) => {
    if (!parent.children) parent.children = []
    return createRoot(node, parent.children)
  }

  // 开始处理
  source.map(row => {
    const keys = Object.keys(row)
    let root
    // 每次 +2，跳过 label 列
    for (let i = 0; i < keys.length; i += 2) {
      // 创建本次遍历的数据
      const node = createNode(row[keys[i]], row[keys[i + 1]])

      if (i === 0) {
        root = createRoot(node, target)
      } else {
        root = insertNode(node, root)
      }
    }
  })

  return target
}

// 测试方法
console.log(JSON.stringify(convert(source), ' ', 4))

function convert(source) {
  const output = []
  
  source.forEach(row => {
    const keys = Object.keys(row)
    // 记录节点在节点树上的完整路径
    const path = [0]

    for (let i = 0; i < keys.length;) {
      const id = row[keys[i++]]
      const label = row[keys[i++]]
      
      const targetIndex = id
      path.push(targetIndex)
      path.reduce((parentNode, node, index) => {
        const isCurrentLastNode = path.length - 1 === index
        if (isCurrentLastNode) {
          if (!parentNode[node]) parentNode[node] = [ label, []]
        } 
        return parentNode[node][1]
      }, [[null, output]])
    }
  })

   // [string, arr] => {id: index, label: string, children: arr}
  const result = output.reduce(function mapper(acc, v, i) {
    if (v) {
      const [label, children] = v
      acc.push({
        id: i,
        label,
        children: children.reduce(mapper, [])
      })
    } 
    return acc
  }, [])
  // print(output, 1)
}

const o = {}

// --> true
Object.getPrototypeOf(o) === Object.prototype
Object.getPrototypeOf(Object.prototype) === null

o.__proto__ === Object.getPrototypeOf(o)
o.__proto__ === Object.prototype
o.__proto__ === o.constructor.prototype

o.__proto__.__proto__ === null

// o 这个对象继承了 Object.prototype 上面的所有属性
// 原型链如下:
// o ---> Object.prototype ---> null
var o = {a: 1};

// a ---> Array.prototype ---> Object.prototype ---> null
var a = ["yo", "whadup", "?"];

// f ---> Function.prototype ---> Object.prototype ---> null

function f(){
  return 1;
}

function Graph() {
  this.vertices = [];
  this.edges = [];
}

Graph.prototype = {
  addVertex: function(v){
    this.vertices.push(v);
  }
};

var g = new Graph();
// g 是生成的对象，他的自身属性有 'vertices' 和 'edges'。
// 在 g 被实例化时，g.[[Prototype]] 指向了 Graph.prototype。

function Employee(name, position, yearHired) {
  this.name = name;
  this.position = position;
  this.yearHired = yearHired;
};

const emp = new Employee("Marko Polo", "Software Developer", 2017);

var a = {a: 1}; 
// a ---> Object.prototype ---> null

var b = Object.create(a);
// b ---> a ---> Object.prototype ---> null
console.log(b.a); // 1 (继承而来)

var c = Object.create(b);
// c ---> b ---> a ---> Object.prototype ---> null

var d = Object.create(null);
// d ---> null
console.log(d.hasOwnProperty); // undefined, 因为d没有继承Object.prototype

class Foo {
  constructor(name) {
     this.name = name
  }
}

// 当执行
var o = new Foo();

// 实际上执行的是(或者类似这样)：
var o = new Object();
o.__proto__ = Foo.prototype;
Foo.call(o);

// 当执行 
o.someProp
// 它会检查 o 是否具有 someProp 属性。如果没有，它会查找 Object.getPrototypeOf(o).someProp
// 如果仍旧没有，它会继续查找 Object.getPrototypeOf(Object.getPrototypeOf(o)).someProp

function A(a){
  this.varA = a;
}

// 重点：类型被定义在 .prototype 中
A.prototype = {
  // A.prototype.varA 总是会被 this.varA 遮蔽，如果varA并不是在每个实例中都被初始化，那这样做将是有效果的
  varA : null,
  doSomething : function(){
    // ...
  }
}

function B(a, b){
  A.call(this, a);
  this.varB = b;
}
// 重点：用 Object.create() 来继承
B.prototype = Object.create(A.prototype, {
  varB : {
    value: null, 
    enumerable: true, 
    configurable: true, 
    writable: true 
  },
  doSomething : { 
    value: function(){ // override
      A.prototype.doSomething.apply(this, arguments); 
      // call super
      // ...
    },
    enumerable: true,
    configurable: true, 
    writable: true
  }
});
B.prototype.constructor = B;

var b = new B();
b.doSomething();

prototype 是用于类的，而 Object.getPrototypeOf() 是用于实例的（instances），两者功能一致.

Object.getPrototypeOf(fn) === fn.__proto__ ===  Function.prototype

// true
Object.prototype.__proto__ === null
Object.constructor.__proto__ === Object.constructor.prototype
Object.__proto__ === Object.constructor.prototype
({}).__proto__ === Object.prototype
Array.__proto__ === Object.constructor.prototype
Array.prototype.__proto__ === Object.prototype
Function.__proto__ === Object.constructor.prototype

console.log(Array.prototype)
// [constructor: ƒ, concat: ƒ, copyWithin: ƒ, fill: ƒ, find: ƒ, …]

Array.prototype.length === 0