const dayjs = function (date, c) {
  if (isDayjs(date)) {
    return date.clone()
  }

  const cfg = typeof c === 'object' ? c : {}
  cfg.date = date
  cfg.args = arguments
  return new Dayjs(cfg)
}

const isDayjs = d => d instanceof Dayjs

class Dayjs {
  constructor(cfg) {
    this.$L = parseLocale(cfg.locale, null, true)
    this.parse(cfg)
  }

   parse(cfg) {
      this.$d = parseDate(cfg)
      this.$x = cfg.x || {}
      this.init()
   }

   init() {
      const { $d } = this
      this.$y = $d.getFullYear()
      this.$M = $d.getMonth()
      this.$D = $d.getDate()
      this.$W = $d.getDay()
      this.$H = $d.getHours()
      this.$m = $d.getMinutes()
      this.$s = $d.getSeconds()
      this.$ms = $d.getMilliseconds()
   }
  // ...
}

import en from './locale/en'

let L = 'en' // global locale
const Ls = {} // global loaded locale
Ls[L] = en

const parseLocale = (preset, object, isLocal) => {
  let l
  if (!preset) return L
  if (typeof preset === 'string') {
    const presetLower = preset.toLowerCase()
    if (Ls[presetLower]) {
      l = presetLower
    }
    if (object) {
      Ls[presetLower] = object
      l = presetLower
    }
    // 存在'zh-cn'，'zh-hk'的情况，只取前面的zh作为属性
    const presetSplit = preset.split('-')
    if (!l && presetSplit.length > 1) {
      return parseLocale(presetSplit[0])
    }
  } else {
    const { name } = preset
    Ls[name] = preset
    l = name
  }
  if (!isLocal && l) L = l
  return l || (!isLocal && L)
}

const parseDate = (cfg) => {
  const {
    date,
    utc
  } = cfg
  if (date === null) return new Date(NaN) // null is invalid
  if (Utils.u(date)) return new Date() // today
  if (date instanceof Date) return new Date(date)
  if (typeof date === 'string' && !/Z$/i.test(date)) {
    const d = date.match(C.REGEX_PARSE)
    if (d) {
      const m = d[2] - 1 || 0
      const ms = (d[7] || '0').substring(0, 3)
      if (utc) {
        return new Date(Date.UTC(d[1], m, d[3]
          || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms))
      }
      return new Date(d[1], m, d[3]
        || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms)
    }
  }

  return new Date(date) // everything else
}

export const REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/

class Dayjs {
   // ...
   $set(units, int) { // private set
      const unit = Utils.p(units)
      const utcPad = `set${this.$u ? 'UTC' : ''}`
      const name = {
         [C.D]: `${utcPad}Date`,
         [C.DATE]: `${utcPad}Date`,
         [C.M]: `${utcPad}Month`,
         [C.Y]: `${utcPad}FullYear`,
         [C.H]: `${utcPad}Hours`,
         [C.MIN]: `${utcPad}Minutes`,
         [C.S]: `${utcPad}Seconds`,
         [C.MS]: `${utcPad}Milliseconds`
      }[unit]
      const arg = unit === C.D ? this.$D + (int - this.$W) : int

      if (unit === C.M || unit === C.Y) {
         // clone is for badMutable plugin
         const date = this.clone().set(C.DATE, 1)
         date.$d[name](arg)
         date.init()
         this.$d = date.set(C.DATE, Math.min(this.$D, date.daysInMonth())).$d
      } else if (name) this.$d[name](arg)

      this.init()
      return this
   }

   set(string, int) {
      return this.clone().$set(string, int)
   }
   // ...
}

const prettyUnit = (u) => {
   const special = {
      M: C.M,
      y: C.Y,
      w: C.W,
      d: C.D,
      D: C.DATE,
      h: C.H,
      m: C.MIN,
      s: C.S,
      ms: C.MS,
      Q: C.Q
   }
   return special[u] || String(u || '').toLowerCase().replace(/s$/, '')
}

class Dayjs {
    // ...
   get(unit) {
      return this[Utils.p(unit)]()
   }

   $g(input, get, set) {
      if (Utils.u(input)) return this[get]
      return this.set(set, input)
   }
   // ...
}

const proto = Dayjs.prototype
dayjs.prototype = proto;
[
   ['$ms', C.MS],
   ['$s', C.S],
   ['$m', C.MIN],
   ['$H', C.H],
   ['$W', C.D],
   ['$M', C.M],
   ['$y', C.Y],
   ['$D', C.DATE]
].forEach((g) => {
   proto[g[1]] = function (input) {
      return this.$g(input, g[0], g[1])
   }
})

class Dayjs {
   // ... 
   format(formatStr) {
      const locale = this.$locale()

      if (!this.isValid()) return locale.invalidDate || C.INVALID_DATE_STRING
      // export const FORMAT_DEFAULT = 'YYYY-MM-DDTHH:mm:ssZ'
      const str = formatStr || C.FORMAT_DEFAULT
      const zoneStr = Utils.z(this)
      const { $H, $m, $M } = this

      const {
         weekdays, months, meridiem
      } = locale

      // 获取字符串的短名称
      const getShort = (arr, index, full, length) => (
              (arr && (arr[index] || arr(this, str))) || full[index].slice(0, length)
      )
      
      // 格式化小时，是否需要带0
      const get$H = num => (
              Utils.s($H % 12 || 12, num, '0')
      )

      // 格式化小时是否为AM/PM/am/pm
      const meridiemFunc = meridiem || ((hour, minute, isLowercase) => {
         const m = (hour < 12 ? 'AM' : 'PM')
         return isLowercase ? m.toLowerCase() : m
      })

      const matches = {
         // 截取年份最后两位 2023 => 23 
         YY: String(this.$y).slice(-2),
         YYYY: this.$y,
         // 月份从0开始
         M: $M + 1,
         MM: Utils.s($M + 1, 2, '0'),
         // 获取月份缩写 september => sep
         MMM: getShort(locale.monthsShort, $M, months, 3),
         // 获取月份全称
         MMMM: getShort(months, $M),
         D: this.$D,
         DD: Utils.s(this.$D, 2, '0'),
         d: String(this.$W),
         // 获取星期缩写 monday => mo
         dd: getShort(locale.weekdaysMin, this.$W, weekdays, 2),
         // 获取星期缩写 monday => mon
         ddd: getShort(locale.weekdaysShort, this.$W, weekdays, 3),
         // 获取星期全称
         dddd: weekdays[this.$W],
         H: String($H),
         HH: Utils.s($H, 2, '0'),
         h: get$H(1),
         hh: get$H(2),
         // am/pm
         a: meridiemFunc($H, $m, true),
         // AM/PM
         A: meridiemFunc($H, $m, false),
         m: String($m),
         mm: Utils.s($m, 2, '0'),
         s: String(this.$s),
         ss: Utils.s(this.$s, 2, '0'),
         SSS: Utils.s(this.$ms, 3, '0'),
         // 当前地区的时差
         Z: zoneStr // 'ZZ' logic below
      }
      // export const REGEX_FORMAT = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g
      return str.replace(C.REGEX_FORMAT, (match, $1) => $1 || matches[match] || zoneStr.replace(':', '')) // 'ZZ'
   }
   // ...
}

// Utils.s
// 当字符串小于指定长度时可以拼接上需要拼接的字符
const padStart = (string, length, pad) => {
   const s = String(string)
   if (!s || s.length >= length) return string
   return `${Array((length + 1) - s.length).join(pad)}${string}`
}

class Dayjs {
   // ... 
   add(number, units) {
      number = Number(number) // eslint-disable-line no-param-reassign
      const unit = Utils.p(units)
      const instanceFactorySet = (n) => {
         const d = dayjs(this)
         return Utils.w(d.date(d.date() + Math.round(n * number)), this)
      }
      if (unit === C.M) {
         return this.set(C.M, this.$M + number)
      }
      if (unit === C.Y) {
         return this.set(C.Y, this.$y + number)
      }
      if (unit === C.D) {
         return instanceFactorySet(1)
      }
      if (unit === C.W) {
         return instanceFactorySet(7)
      }
      const step = {
         [C.MIN]: C.MILLISECONDS_A_MINUTE,
         [C.H]: C.MILLISECONDS_A_HOUR,
         [C.S]: C.MILLISECONDS_A_SECOND
      }[unit] || 1 // ms

      const nextTimeStamp = this.$d.getTime() + (number * step)
      return Utils.w(nextTimeStamp, this)
   }
   // ...
}

// Utils.w
const wrapper = (date, instance) =>
        dayjs(date, {
           locale: instance.$L,
           utc: instance.$u,
           x: instance.$x,
           $offset: instance.$offset // todo: refactor; do not use this.$offset in you code
        })