const btn = document.getElementById('modeBtn');
btn.addEventListener('click', e => {
    const body = document.body;
    if (e.target.innerHTML === 'light') {
        body.style.backgroundColor = 'black';
        body.style.color = 'white';
        e.target.innerHTML = 'dark';
    } else {
        body.style.backgroundColor = 'white';
        body.style.color = 'black';
        e.target.innerHTML = 'light';
    }
})

const btn = document.getElementById('modeBtn');
btn.addEventListener('click', e => {
    const body = document.body;
    if (body.className !== 'night') {
        body.className = 'night';
    } else {
        body.className = '';
    }
})

function once(fn) {
  return function (...args) {
        if (fn) {
            const result = fn.apply(this, args);
            fn = null;
            return result;
        }
    }
}

// 防抖
// 先开启一个定时任务执行，定时任务完成后则清空
// 当再调用时，如果定时任务仍存在则清空原来任务，创建新的定时任务
function debounce(fn, delay = 200) {
    let timer = null;
    return function () {
        if (timer) {
            clearTimeout(timer);
        }
        timer = setTimeout(() => {
            fn.apply(this, arguments);
        }, delay);
    }
}

// 节流
// 先开启一个定时任务执行，定时任务完成后则清空
// 当再调用时，如果定时任务仍存在则不执行任何操作，如果不存在就开启一个新的定时器
function throttle(fn, delay = 200) {
    let timer = null;
    return function () {
        if (!timer) {
            timer = setTimeout(() => {
                fn.apply(this, arguments);
                timer = null;
            }, delay);
        }
    }
}

const debounceFn = debounce(function () {
    console.log('我 resize 了');
}, 1000);

window.addEventListener('resize', debounceFn);

// 检验是否可迭代
const isIterable = obj => obj !== null
    && typeof obj[Symbol.iterator] === 'function';

function iterative(fn) {
    return function (subject, ...rest) {
        if (isIterable(subject)) {
            // 把所有的执行结果存储于 result 中并返回
            const result = [];
            for (const obj of subject) {
                result.push(fn.apply(this, [obj, ...rest]));
            }
            return result;
        }
        return fn.apply(this, [subject, ...rest]);
    }
}

const setColors = iterative(setColor);

const list = [1, 2, 3, 4];
const arr = [];

for (let i = 0; i < list.length; i++) {
    // 过程是给每个元素 × 2
    arr.push(list[i] * 2);
}

const list = [1, 2, 3, 4];

// 操作是每个元素 x 2
const double = x => x * 2;

const arr = list.map(double);

function toggle(...actions) {
    return function (...args) {
        // 先将第一个操作取出，然后再将其 push 到列表的末尾，因此可以实现循环
        const action = actions.shift();
        actions.push(action);
        return action.apply(this, args);
    }
}

button.addEventListener('click', toggle(
    e => {
        e.target.className = 'on';
        e.target.innerHTML = 'on';
    },
    e => {
        e.target.className = 'off';
        e.target.innerHTML = 'off';
    }
))

/**
 * @param {number[][]} matrix
 * @return {number}
 */
var minFallingPathSum = function(matrix) {
    const m = matrix.length, n = matrix[0].length;
    const dp = new Array(m).fill(0).map(() => new Array(n).fill(0));

    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            if (i === 0) {
                // 边界：第一行，最小路径和等于自己本身
                dp[i][j] = matrix[i][j];
            } else if (j === 0) {
                // 每行的最左边
                dp[i][j] = Math.min(dp[i - 1][j], dp[i - 1][j + 1]) + matrix[i][j];
            } else if (j === n - 1) {
                // 每行的最右边
                dp[i][j] = Math.min(dp[i - 1][j], dp[i - 1][j - 1]) + matrix[i][j];
            } else {
                dp[i][j] = Math.min(dp[i - 1][j], dp[i - 1][j - 1], dp[i - 1][j + 1]) + matrix[i][j];
            }
        }
    }

    return Math.min(...dp[m - 1]);
};

/**
 * @param {number[]} coins
 * @param {number} amount
 * @return {number}
 */
var coinChange = function(coins, amount) {
    const dp = new Array(amount + 1).fill(amount + 1);

    // base case
    dp[0] = 0;

    for (let i = 0; i <= amount; i++) {
        for (const coin of coins) {
            if (i - coin < 0) {
                continue;
            }
            // 状态转移
            dp[i] = Math.min(dp[i], dp[i - coin] + 1);
        }
    }

    return dp[amount] === amount + 1 ? -1 : dp[amount];
};

/**
 * @param {number[]} nums
 * @return {number}
 */
var lengthOfLIS = function(nums) {
    const len = nums.length;
    // 边界，要全部初始化为 1
    const dp = new Array(len).fill(1);

    for (let i = 0; i < len; i++) {
        for (let j = 0; j < i; j++) {
            // 判断是否满足递增要求
            if (nums[j] < nums[i]) {
                // 状态转移
                dp[i] = Math.max(dp[i], dp[j] + 1);
            }
        }
    }

    // 最终结果是 dp 中的最大值
    return Math.max(...dp);
};

/**
 * @param {number[]} nums
 * @return {number}
 */
var lengthOfLIS = function (nums) {
    const len = nums.length;
    // 记录所有的子序列
    const sequence = [];
    // 边界，要全部初始化为 1
    const dp = new Array(len).fill(1);
    // 边界，所有的 sequence[i] 设置为对应的 nums[i]
    for (let i = 0; i < len; i++) {
        sequence[i] = nums[i];
    }

    for (let i = 0; i < len; i++) {
        for (let j = 0; j < i; j++) {
            // 判断是否满足递增要求
            if (nums[j] < nums[i]) {
                if (dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                    sequence[i] = sequence[j] + ' ' + nums[i];
                }
            }
        }
    }

    // 找到序列对应的下标
    let maxLen = 0, maxIndex = 0;
    for (let i = 0; i < len; i++) {
        if (maxLen < dp[i]) {
            maxIndex = i;
        }
    }

    return sequence[maxIndex];
};

/**
 * @param {number[]} nums
 * @return {number}
 */
var lengthOfLIS = function(nums) {
    const len = nums.length;
    
    const ans = [];
    ans.push(nums[0]);

    for (let i = 1; i < len; i++) {
        // ans 中元素都比它小，将它插到最后
        if (nums[i] > ans[ans.length - 1]) {
            ans.push(nums[i]);
        } else {
            // 二分，查找最左边满足条件的值的下标
            let left = 0, right = ans.length - 1;
            let targetIndex;
            while (left <= right) {
                const mid = (left + right) >> 1;
                if (ans[mid] >= nums[i]) {
                    // 满足条件
                    // 因为查找的是最左的满足条件的元素，所以是收缩右边界
                    right = mid - 1;
                    targetIndex = mid;
                } else {
                    left = mid + 1;
                }
            }
            // 用它覆盖掉比它大的元素中最小的那个
            ans[targetIndex] = nums[i];
        }
    }

    return ans.length;
};

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {void} Do not return anything, modify root in-place instead.
 */
var flatten = function(root) {
    const list = [];
    preorderTraversal(root);

    for (let i = 1; i < list.length; i++) {
        const pre = list[i - 1], cur = list[i];
        pre.left = null;
        pre.right = cur;
    }

    function preorderTraversal(root) {
        if (!root) return;

        list.push(root);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
    }
};

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {void} Do not return anything, modify root in-place instead.
 */
var flatten = function(root) {
    if (!root) {
        return;
    }

    flatten(root.left);
    flatten(root.right);

    // 后序遍历，所以此时二叉树已经被拉平
    const leftTree = root.left, rightTree = root.right;

    // 将右子树换成左子树
    root.right = leftTree;
    root.left = null;

    //将原来的右子树接到当前右子树的后面
    let p = root;
    while (p.right) { // 查找最右节点
        p = p.right;
    }

    p.right = rightTree;
};

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} list1
 * @param {ListNode} list2
 * @return {ListNode}
 */
var mergeTwoLists = function(list1, list2) {
    let dummyHead = new ListNode(-1);
    let p1 = list1, p2 = list2;

    let p = dummyHead;
    while (p1 && p2) {
        if (p1.val > p2.val) {
            p.next = p2;
            p2 = p2.next;
        } else {
            p.next = p1;
            p1 = p1.next;
        }
        p = p.next;
    }

    p.next = p1 || p2;

    return dummyHead.next;
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
var getKthFromEnd = function(head, k) {
    let slow, fast;
    slow = fast = head;

    for (let i = 0; i < k; i++) {
        fast = fast.next;
    }

    while (fast) {
        fast = fast.next;
        slow = slow.next;
    }

    return slow;
};

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} n
 * @return {ListNode}
 */
var removeNthFromEnd = function(head, n) {
    const dummyHead = new ListNode(-1, head);
    // 要删除倒数第 n 个节点，则需要找到倒数第 n + 1 个节点
    const temp = getKthFromEnd(dummyHead, n + 1);
    temp.next = temp.next.next;

    return dummyHead.next;

    // 返回链表的倒数第 k 个节点
    function getKthFromEnd(head, k) {
        let slow, fast;
        slow = fast = head;
        for (let i = 0; i < k; i++) {
            fast = fast.next;
        }
        while (fast) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
};

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var middleNode = function(head) {
    let slow, fast;
    slow = fast = head;
    while (fast && fast.next) {
        fast = fast.next.next;
        slow = slow.next;
    }
    return slow;
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {boolean}
 */
var hasCycle = function(head) {
    let slow, fast;
    slow = fast = head;

    while (fast && fast.next) {
        fast = fast.next.next;
        slow = slow.next;

        if (fast === slow) {
            return true;
        }
    }

    return false;
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var detectCycle = function(head) {
    let slow, fast;
    slow = fast = head;

    let flag = false; // 标记是否有环
    while (fast && fast.next) {
        slow = slow.next;
        fast = fast.next.next;

        if (slow === fast) {
            flag = true;
            break;
        }
    }

    if (!flag) {
        return null;
    }

    slow = head;
    while (slow !== fast) {
        slow = slow.next;
        fast = fast.next;
    }

    return slow;
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} headA
 * @param {ListNode} headB
 * @return {ListNode}
 */
var getIntersectionNode = function(headA, headB) {
    let p1 = headA, p2 = headB;
    while (p1 !== p2) {
        p1 = p1 ? p1.next : headB;
        p2 = p2 ? p2.next : headA;
    } 
    return p1;
};

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    let prev = null, cur = head;
    while (cur) {
        const tmp = cur.next; // 存储 cur 的下一个节点
        cur.next = prev;
        // 移动指针，继续前进
        prev = cur;
        cur = tmp;
    }
    return prev; // prev 最后指向的就是头节点
};

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    // 若链表只有一个节点或根本没有节点，直接返回即可
    if (head === null || head.next === null) {
        return head;
    }

    const newList = reverseList(head.next);
    // 假设节点 head 为节点 1，节点 head 的下一个节点为节点 2
    const p2 = head.next; // 获取节点 2
    p2.next = head; // 节点 2 的 next 指向节点 1
    head.next = null; // 节点 1 的 next 设为空

    return newList;
};

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} left
 * @param {number} right
 * @return {ListNode}
 */
var reverseBetween = function(head, left, right) {
    let dummyHead = new ListNode(-1, head);

    let g = dummyHead, p = dummyHead.next;

    for (let i = 0; i < left - 1; i++) {
        g = g.next;
        p = p.next;
    }

    for (let i = 0; i < right - left; i++) {
        // 暂存删除节点
        let removed = p.next;
        // 删除节点
        p.next = p.next.next;
        // 插入刚才删除的节点
        removed.next = g.next;
        g.next = removed;
    }

    return dummyHead.next;
};

/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function (nums) {
    if (nums.length === 0) {
        return;
    }

    let slow, fast;
    slow = fast = 0;
    const len = nums.length;
    while (fast < len) {
        if (nums[fast] !== nums[slow]) {
            // 每次找到一个不重复的元素就告诉 slow 并让 slow 前进一步
            // 然后给 slow 赋值 fast 所在位置的值
            // 因为第一个元素必定不是重复元素，所以先移动 slow
            slow++;
            nums[slow] = nums[fast];
        }
        fast++;
    }

    return slow + 1;
};

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var deleteDuplicates = function(head) {
    if (!head) {
        return head;
    }
    let slow, fast;
    slow = fast = head;
    while (fast) {
        if (fast.val !== slow.val) {
            slow.next = fast;
            slow = slow.next;
        }
        fast = fast.next;
    }
    // 与后面断开连接
    slow.next = null;
    return head;
};

/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
var removeElement = function(nums, val) {
    let slow, fast;
    slow = fast = 0;
    while (fast < nums.length) {
        if (nums[fast] !== val) {
            // 第一个元素也可能等于 val，所以先赋值再移动 slow
            nums[slow] = nums[fast];
            slow++;
        }
        fast++;
    }
    return slow;
};

/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var moveZeroes = function(nums) {
    let slow, fast;
    slow = fast = 0;
    while (fast < nums.length) {
        if (nums[fast] !== 0) {
            [nums[slow], nums[fast]] = [nums[fast], nums[slow]];
            slow++;
        }
        fast++;
    }
};

module.exports = { extends: ['@commitlint/config-conventional'] }

const PENDING = 'pending';
const FULFILLED = 'fulfilled';
const REJECTED = 'rejected';

class Promise {
    constructor(executor) {
        this.state = PENDING;
        this.value = null;
        this.reason = null;
        this.onResolvedCallbacks = [];
        this.onRejectedCallbacks = [];

        const resolve = (value) => {
            // 避免多次 resolve 或 reject
            if (this.state === PENDING) {
                this.state = FULFILLED;
                this.value = value;
                // 一旦 resolve 执行，调用成功数组的函数
                this.onResolvedCallbacks.forEach(fn => fn());
            }
        }

        const reject = (reason) => {
            if (this.state === PENDING) {
                this.state = REJECTED;
                this.reason = reason;
                // 一旦 reject 执行，调用失败数组的函数
                this.onRejectedCallbacks.forEach(fn => fn());
            }
        }

        try {
            // executor 同步执行，用户可以选择调用 resolve 和 reject
            executor(resolve, reject);
        } catch (error) {
            reject(error);
        }
    }

    then(onFulfilled, onRejected) {
        if (typeof onFulfilled !== 'function') {
            // 当不是函数时，onFulfilled 返回一个普通的值，成功时直接等于 value
            onFulfilled = value => value;
        }
        if (typeof onRejected !== 'function') {
            // 当不是函数时，onRejected 直接抛出错误
            onRejected = reason => {
                throw new Error(reason instanceof Error ? reason.message : reason);
            }
        }

        // onFulfilled 和 onRejected 都必须异步调用，而且严格意义上应该是微任务
        // 此处只是使用 setTimeout 来模拟异步

        // 若 onFulfilled 或 onRejected 报错，则直接 reject
        const promise2 = new Promise((resolve, reject) => {
            if (this.state === FULFILLED) {
                setTimeout(() => {
                    try {
                        const x = onFulfilled(this.value);
                        // resolvePromise 函数，处理自己 return 的 promise 和默认的 promise2 的关系
                        this.resolvePromise(promise2, x, resolve, reject);
                    } catch (error) {
                        reject(error);
                    }
                }, 0);
            }
            if (this.state === REJECTED) {
                setTimeout(() => {
                    try {
                        const x = onRejected(this.reason);
                        this.resolvePromise(promise2, x, resolve, reject);
                    } catch (error) {
                        reject(error);
                    }
                }, 0);
            }
            if (this.state === PENDING) {
                this.onResolvedCallbacks.push(() => {
                    setTimeout(() => {
                        try {
                            const x = onFulfilled(this.value);
                            this.resolvePromise(promise2, x, resolve, reject);
                        } catch (error) {
                            reject(error);
                        }
                    }, 0);
                })
                this.onRejectedCallbacks.push(() => {
                    setTimeout(() => {
                        try {
                            const x = onRejected(this.reason);
                            this.resolvePromise(promise2, x, resolve, reject);
                        } catch (error) {
                            reject(error);
                        }
                    }, 0);
                });
            }
        })

        return promise2;
    }

    // 处理不同的 promise 套用
    resolvePromise(promise2, x, resolve, reject) {
        if (promise2 === x) {
            return reject('Chaining cycle detected for promise')
        }

        let called = false; // 成功和失败只能调用一个，此处防止多次调用
        if (x instanceof Object) {
            try {
                const then = x.then;
                if (typeof then === 'function') {
                    then.call(x, y => {
                        if (called) return;
                        called = true;
                        // resolve 的结果依旧是 promise 那就继续解析
                        this.resolvePromise(promise2, y, resolve, reject);
                    }, error => {
                        if (called) return;
                        called = true;
                        reject(error);
                    })
                } else {
                    resolve(x);
                }
            } catch (error) {
                if (called) return;
                called = true;
                reject(error);
            }
        } else {
            resolve(x);
        }
    }
};

Promise.defer = Promise.deferred = function () {
    let dfd = {}
    dfd.promise = new Promise((resolve,reject)=>{
        dfd.resolve = resolve;
        dfd.reject = reject;
    });
    return dfd;
}
module.exports = Promise;

Promise.resolve = function(value) {
    if (value instanceof Promise) {
        return value;
    } 
    return new Promise(resolve => resolve(value));
};

Promise.reject = function(reason) {
    return new Promise((resolve, reject) => reject(reason));
};

Promise.all = function(promiseArr) {
    let resolveCount = 0;
    const result = [];
    return new Promise((resolve, reject) => {
        promiseArr.forEach((promise, index) => {
            Promise.resolve(promise).then(val => {
                resolveCount++;
                result[index] = val;
                if (resolveCount === promiseArr.length) {
                    resolve(result);
                }
            }, error => {
                reject(error);
            })
        })
    })
};

Promise.allSettled = function(promiseArr) {
    const result = [];

    return new Promise((resolve, reject) => {
        promiseArr.forEach((promise) => {
            Promise.resolve(promise).then(val => {
                result.push({
                    state: FULFILLED,
                    value: val
                })
            }, err => {
                result.push({
                    state: REJECTED,
                    value: err
                })
            })
            if (result.length === promiseArr.length) {
                resolve(result);
            }
        })
    })
    
}

Promise.race = function(promiseArr) {
    return new Promise((resolve, reject) => {
        promiseArr.forEach(promise => {
            Promise.resolve(promise).then(val => {
                resolve(val);
            }, err => {
                reject(err);
            })
        })
    })
}

Promise.any = function(promiseArr) {
    let rejectCount = 0;
    return new Promise((resolve, reject) => {
        promiseArr.forEach((promise) => {
            Promise.resolve(promise).then(val => {
                resolve(val);
            }, err => {
                rejectCount++;
                if (rejectCount === promiseArr.length) {
                    throw new Error('All promises were rejected')
                }
            })
        })
    })
}

function myNew(fn, ...args) {
    // 创建一个新的对象
    const obj = {}
    // 把该对象的原型设置为 fn 的原型
    if (fn.prototype !== null) {
        Object.setPrototypeOf(obj, fn.prototype);
    }
    // 使用 apply，改变构造函数 this 的指向到新建的对象
    // 这样 obj 就可以访问到构造函数中的属性
    const result = fn.apply(obj, args);

    return result instanceof Object ? result : obj;
}

function Person(name, age) {
    this.name = name;
    this.age = age;
}

// const person = new Person('Jack', 12);
const person = myNew(Person, 'Jack', 12);
console.log(person);