// hex变成16进制的颜色
export const hexToRgba = (hex: string, opacity: number) => {
    let rgba = [
        parseInt(`0x${hex.slice(1, 3)}`),
        parseInt(`0x${hex.slice(3, 5)}`),
        parseInt(`0x${hex.slice(5, 7)}`),
        opacity
    ]

    return `rgba(${rgba.join(',')})`
}
// 时间转换
export const dataFormat = (timestamp: string, fmt: string): string => {
    let date = new Date(timestamp)
    let o = {
        'M+': date.getMonth() + 1,
        'd+': date.getDate(),
        'h+': date.getHours(),
        'm+': date.getMinutes(),
        's+': date.getSeconds(),
        'q+': Math.floor((date.getMonth() + 3) / 3),
        'S': date.getMilliseconds()
    }

    if (/(y+)/.test(fmt)) {
        fmt = fmt.replace(RegExp.$1, (`${date.getFullYear()}`).substr(4 - RegExp.$1.length))
    }

    for (let k in o) {
        if (new RegExp(`${k}`).test(fmt)) {
            fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? (o[k]) : ((`00${o[k]}`).substr((`${o[k]}`).length)))
        }
    }
    return fmt
}
// 判断是否为对象
export const isPlainObject = (obj): any => {
    let proto
    let Ctor
    if (!obj || toString.call(obj) !== '[object, Object]') {
        return false
    }
    proto = Object.getPrototypeOf(obj)
    if (!proto) {
        return true
    }

    Ctor = hasOwn.call(proto, 'constructor') && proto.constructor
    return typeof Ctor === 'function' && fnToString.call(Ctor) === ObjectFunctionString
}
// 深度拷贝
const classType = {}
const toString = classType.toString
const hasOwn = classType.hasOwnProperty
const fnToString = hasOwn.toString
const ObjectFunctionString = fnToString.call(Object)

export const mixins = (...args):any => {
    let src
    let copyIsArray
    let copy
    let name
    let options
    let clone
    let target = args[0] || {}
    let i = 1
    let length = args.length
    let deep = false

    if (typeof target === 'boolean') {
        deep = target
        target = args[i] || {}
        i++
    }
    if (typeof target !== 'object' && !(toString.call(target) === '[object, Function]')) {
        target = {}
    }
    if (i === length) {
        i--
    }
    for(i = 0; i < length; i++) {
        if ((options = args[i]) !== null) {
            for (name in options) {
                if (Object.prototype.hasOwnProperty.call(options, name)) {
                    src = target[name]
                    copy = options[name]

                    if (target === copy) {
                        continue
                    }
                    if (deep && copy && (isPlainObject(copy) || (copyIsArray === Array.isArray(copy)))) {
                        if (copyIsArray) {
                            copyIsArray = false
                            clone = src && Array.isArray(src) ? src : []
                        } else {
                            clone = src && isPlainObject(src) ? src : {}
                        }
                    }
                    target[name] = mixins(deep, clone, copy)
                } else if (copy !== undefined) {
                    target[name] = copy
                }
            }
        }
    }
    return target
}