const isFunction = fn => typeof fn === 'function'

class Promise {
    constructor(handle) {
        // 1. 判断参数是不是函数
        if (!isFunction(handle)) {
            throw new Error()
        }
        // 2. 初始化私有属性
        this._state = 'pending'
        this._value = undefined
        this._resolvedQueue = []
        this._rejectedQueue = []
        // 3. 执行回调
        try {
            handle(this._resolve.bind(this), this._reject.bind(this))
        } catch(error) {
            this._reject(error)
        }
    }

    _reject(error) {
        // 1. 判断实例状态
        if (this._state !== 'pending') return 
        // 2. 修改私有属性，清空队列任务
        const run = () => {
            this._state = 'rejected'
            this._value = error
            let task
            while(task = this._rejectedQueue.shift()) {
                task(error)
            }
        }
        // 异步执行
        setTimeout(run, 0)
    }

    _resolve(value) {
        // 1. 判断实例状态
        if (this._state !== 'pending') return 
        // 2. 修改私有属性，清空队列任务
        const run = () => {
            const runResolved = value => {
                this._state = 'resolved'
                this._value = value
                let task
                while(task = this._resolvedQueue.shift()) {
                    task(value)
                }
            }
            const runRejected = error => {
                this._state = 'rejected'
                this._value = error
                let task
                while(task = this._rejectedQueue.shift()) {
                    task(error)
                }
            }
            // 2.0 判断参数是不是一个Promise实例
            if (value instanceof Promise) {
                value.then(runResolved, runRejected)
            } else {
                runResolved(value)
            }
        }
        // 3. 异步执行
        setTimeout(run, 0)
    }

    then(onResolved, onRejected) {
        // 1. 返回一个新的Promise实例
        const {_state, _value} = this
        return new Promise((resolve, reject) => {
            // 2。 执行回调 
            const resolved = value => {
                try {
                    // 2.1 判断参数是不是函数
                    if (!isFunction(onResolved)) {
                        resolve(value)
                    } else {
                        // 2.2 执行回调判断返回值是不是Promise实例
                        const result = onResolved(value)
                        if (result instanceof Promise) {
                            result.then(resolve, reject)
                        } else {
                            resolve(result)
                        }
                    }
                } catch(error) {
                    reject(error)
                }
            }
            const rejected = error => {
                try {
                    if (!isFunction(onRejected)) {
                        reject(error)
                    } else {
                        const result = onRejected(error)
                        if (result instanceof Promise) {
                            result.then(resolve, reject)
                        } else {
                            resolve(result)
                        }
                    }
                } catch(error) {
                    reject(error)
                }
            }
            // 3. 判断实例状态
            switch(_state) {
                case 'pending':
                    this._resolvedQueue.push(resolved)
                    this._rejectedQueue.push(rejected)
                    break
                case 'resolved':
                    resolved(_value)
                    break
                case 'rejected': 
                    rejected(_value)
            }
        })
    }

    catch(onRejected) {
        return this.then(undefined, onRejected)
    }

    finally(callback) {
        return this.then(value => {
            callback()
            return Promise.resolve(value)
        }, error => {
            callback()
            return Promise.reject(error)
        })
    }

    static resolve(value) {
        if (value instanceof Promise) return value
        return new Promise(resolve => resolve(value))
    }

    static reject(error) {
        return new Promise((resolve, reject) => reject(error))
    }

    static all(list) {
        return new Promise((resolve, reject) => {
            const values = []
            let count = 0
            list.forEach((p, i) => {
                this.resolve(p).then(value => {
                    values[i] = value
                    count++
                    if (count === list.length) {
                        resolve(values)
                    }
                }, reject)
            })
        })
    }

    static race(list) {
        return new Promise((resolve, reject) => {
            list.forEach(p => {
                this.resolve(p).then(resolve, reject)
            })
        })
    }
}

function foo() {
    console.log(a)
}
function bar() {
    var a = '动态作用域'
    foo()
}
var a = '词法作用域'
bar() // 调用栈为：bar -> foo

function foo() {
    var a = 2;
    function bar() {
        console.log(a);
    }
    return bar;
}
var baz = foo();
baz(); // 2

function setupBot(name, selector) {
    $(selector).click(function() {
        console.log('Activating: ' + name);
    })
}
setupBot('Closure Bot 1', '#bot_1');
setupBot('Closure Bot 2', '#bot_2');

var a = 2
function foo() {
    console.log(this.a)
}
foo() // 2

function bar() {
    'use strice'
    console.log(this)
}
bar() // undefined

var obj = {
    a: 2,
    foo: function() {
        console.log(this.a)
    }
}
var bar = obj.foo
var a = 'global'
bar() // 'global'
obj.foo() // 2

var myObject = {
    a: 2
}
Object.getOwnPropertyDescriptor(myObject, 'a')
/*  
 *  {
 *      value: 2, // 值
 *      writable: true, // 可写
 *      enumerable: true, // 可枚举
 *      configurable: true // 可配置
 *  }
 */ 

var obj = {}
Object.defineProperty(obj, 'a', {enumerable: true, value: 2})
Object.defineProperty(obj, 'b', {enumerable: false, value: 3})
obj.propertyIsEnumerable('a') // true
obj.propertyIsEnumerable('b') // false
Object.keys(obj) // ['a']
Object.getOwnPropertyNames(obj) // ['a', 'b']

// 字面量
var a = {
    get a() {}
    set a(val) ()
}
// 定义属性
Object.defineProperty(obj, 'prop', {
    get() {},
    set(val) {}
})

// 两种特殊情况
typeof null === 'object' // true
typeof function() {} === 'function' // true

42.toFixed( 3 ); // SyntaxError
// 42. 是一个合法的数字，等于 42.0，
42..toFixed( 3 ); // 合法
(42).toFixed( 3 ); // 合法

Number.isInteger(42) // true
Number.isSafeInteger(Number.MAX_SAFE_INTEGER) // true

var a = 2 / 'foo' // NaN
typeof a === 'number' // true

// NaN 和自身不相等
a == NaN // false
a === NaN // false

isNaN(a) // true
isNaN('foo') // true isNaN 只能检查参数是否不是NaN，也不是数字
Number.isNaN(a) // true 可靠
a !== a // true NaN 是 js 中唯一不等于自身的值

NaN === NaN // false
Object.is(NaN, NaN) // true

+0 === -0 // true
Object.is(+0, -0) // false

let date = new Date()
+date // 1568801394219
date.valueOf() // 1568801394219

Number.prototype.valueOf = function() {
    return 3;
};
new Number( 2 ) == 3; // true

var i = 2;
Number.prototype.valueOf = function() {
    return i++;
};
var a = new Number( 42 );
if (a == 2 && a == 3) {
    console.log( "Yep, this happened." );
}

"0" == null; // false
"0" == undefined; // false
"0" == false; // true -- 晕！ false => 0
"0" == NaN; // false
"0" == 0; // true
"0" == ""; // false
false == null; // false
false == undefined; // false
false == NaN; // false
false == 0; // true -- 晕！
false == ""; // true -- 晕！
false == []; // true -- 晕！ [] => '', false => 0, '' => 0
false == {}; // false
"" == null; // false
"" == undefined; // false
"" == NaN; // false
"" == 0; // true -- 晕！
"" == []; // true -- 晕！
"" == {}; // false
0 == null; // false
0 == undefined; // false
0 == NaN; // false
0 == []; // true -- 晕！  
0 == {}; // false

[] == ![] // true

2 == [2] // true
"" == [null] // true [null] => ''

// 特殊情况
var a = { b: 42 };
var b = { b: 43 };
a < b; // false [object Object] < [object Object]
a == b; // false
a > b; // false
a <= b; // true
a >= b; // true
// a <= b --> !(a > b)

[] + {} // '[object Object]'
{} + [] // 0  {} 被当作空代码块跳过

function Parent() {}
function Child() {}
Child.prototype = new Parent()
Child.prototype.constructor = Child

function Parent() {}
function Child() {
    Parent.call(this)
}

function Parent() {}
function Child() {
    Parent.call(this)
}
Child.prototype = new Parent()
Child.prototype.constructor = Child

function Parent() {}
function Child() {}
Child.prototype = Object.create(Parent.prototype)
Child.prototype.constructor = Child

function Parent() {}
function Child() {
    this.say = function() {}
}
Child.prototype = Object.create(Parent.prototype)
Child.prototype.constructor = Child

function Parent() {}
function Child() {
    Parent.call(this)
}
Child.prototype = Object.create(Parent.prototype)
Child.prototype.constructor = Child

function Vue () {
    this._init()
}
function VueComponent () {
    this._init()
}
VueComponent.prototype = Object.create(Vue.prototype)
VueComponent.prototype.constructor = VueComponent
VueComponent.extend = Vue.extend
// ...

async function async1(){
    console.log('async1 start')
    await async2()
    console.log('async1 end')
}
async function async2(){
    console.log('async2')
}
console.log('script start')
setTimeout(function(){
    console.log('setTimeout') 
},0)  
async1();
new Promise(function(resolve){
    console.log('promise1')
    resolve();
}).then(function(){
    console.log('promise2')
})
console.log('script end')

'script start'
'async1 start'
'async2'
'promise1'
'script end'
'promise2'
'async1 end'
'setTimeout'

function async2() {
    return new Promise((resolve, reject) => {
        console.log('async2')
        resolve()
    })
}
// chrome 71
function async1(){
    console.log('async1 start');
    const p = async2();
    return new Promise((resolve) => {
        Promise.resolve().then(() => {
            p.then(resolve)
        })
    }).then(() => {
        console.log('async1 end')
    });
}
// chrome 73
// 优化后 async 的执行更快，
// `async1 end` 能够在 `promise2` 之前输出
function async1(){
    console.log('async1 start');
    const p = async2();
    return Promise.resolve(p).then(() => {
        console.log('async1 end')
    });
}

// memoize() 函数接收两个参数：一个是需要增加缓存功能的函数，
// 一个是可选的缓存对象。
function memoize(fundamental, cache){
    cache = cache || {};
    let shell = (arg) => {
        if(!cache.hasOwnProperty(arg)){
            cache[arg] = fundamental(arg);
        }
        return cache[arg];
    };
    return shell;
}

var worker = new Worker('code.js);
worker.onmessage = function(event){
    alert(event.data);
};
worker.postMessage('Nicholas');

// code.js 内部代码
importScripts('file1.js', 'file2.js'); // 同步加载
self.onmessage = function(event){
    self.postMessage(`Hello, ${event.data}!`);
};

// npm run i18n export
// npm run i18n import
// "i18n": "npx babel-node --presets=@babel/preset-env  assets/locale/script.js"

import fs from 'fs'
import XLSX from 'xlsx'
import flatten from 'flat'
import consola from 'consola'
import languages from './index'

// const languages = {
//   'zh-CN': {},
//   'en-US': {},
//   'ko-KR': {}
// }

const json2excel = () => {
  const flattenLang = Object.keys(languages).reduce((flattenLang, key) => {
    flattenLang[key] = flatten(languages[key])
    return flattenLang
  }, {})
  const cn = flattenLang['zh-CN']
  const otherLangs = Object.keys(languages).filter(key => key !== 'zh-CN')
  const data = Object.entries(cn).map(
    ([key, cnValue]) => [key, cnValue, ...otherLangs.map(lang => flattenLang[lang][key] || '')]
  )
  data.unshift(['key', 'zh-CN', ...otherLangs])
  const worksheetName = 'sheet1'
  const workbook = XLSX.utils.book_new()
  const worksheet = XLSX.utils.aoa_to_sheet(data)
  XLSX.utils.book_append_sheet(workbook, worksheet, worksheetName)
  XLSX.writeFile(workbook, `${__dirname}/auction_locale.xlsx`)
}

const excel2json = () => {
  const langs = Object.keys(languages)
  const langFlattenData = fs.readdirSync(__dirname)
    .filter(name => /\.xlsx/i.test(name))
    .reduce((lang, name) => {
      const workbook = XLSX.readFile(`${__dirname}/${name}`)
      workbook.SheetNames.forEach(sheetName => {
        const worksheet = workbook.Sheets[sheetName]
        const data = XLSX.utils.sheet_to_json(worksheet)
        const flattenLang = data.reduce((flattenLang, o) => {
          langs.forEach(lang => {
            flattenLang[`${lang}.${o.key}`] = o[lang] || undefined
          })
          return flattenLang
        }, {})
        Object.assign(lang, flattenLang)
      })
      return lang
    }, {})

  const langData = flatten.unflatten(langFlattenData)
  consola.info(langFlattenData)
  const exportFile = (lang, fileName) => {
    const str = JSON.stringify(lang, null, 2)
    const file = fs.openSync(`${__dirname}/${fileName}.update.js`, 'w')
    fs.writeSync(file, 'export default ' + str)
    fs.closeSync(file)
  }
  langs.forEach(l => exportFile(langData[l], l))
}

const cmd = process.argv[2]
if (cmd === 'export') {
  json2excel()
} else if (cmd === 'import') {
  excel2json()
} else {
  consola.error('请输入正确指令')
  consola.info('导入: npm run i18n import')
  consola.info('导出: npm run i18n export')
}