import dateFormat from "dateformat";
import settings from "@/settings";

/**
 * This is just a simple version of deep copy
 * Has a lot of edge cases bug
 * If you want to use a perfect deep copy, use lodash's _.cloneDeep
 * @param {Object} source
 * @returns {Object}
 */
export function deepClone(source) {
  if (!source && typeof source !== "object") {
    throw new Error("error arguments", "deepClone");
  }
  const targetObj = source.constructor === Array ? [] : {};
  Object.keys(source).forEach((keys) => {
    if (source[keys] && typeof source[keys] === "object") {
      targetObj[keys] = deepClone(source[keys]);
    } else {
      targetObj[keys] = source[keys];
    }
  });
  return targetObj;
}

/**
 * Parse the time to string
 * @param {(Object|string|number)} time
 * @param {string} cFormat
 * @returns {string | null}
 */
export function parseTime(time, cFormat) {
  if (arguments.length === 0) {
    return null;
  }
  const format = cFormat || "{y}-{m}-{d} {h}:{i}:{s}";
  let date;
  if (typeof time === "object") {
    date = time;
  } else {
    if (typeof time === "string" && /^[0-9]+$/.test(time)) {
      time = parseInt(time);
    }
    if (typeof time === "number" && time.toString().length === 10) {
      time = time * 1000;
    }
    date = new Date(time);
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay(),
  };
  const time_str = format.replace(/{([ymdhisa])+}/g, (result, key) => {
    const value = formatObj[key];
    // Note: getDay() returns 0 on Sunday
    if (key === "a") {
      return ["日", "一", "二", "三", "四", "五", "六"][value];
    }
    return value.toString().padStart(2, "0");
  });
  return time_str;
}

/**
 * @param {number} time
 * @param {string} option
 * @returns {string}
 */
export function formatTime(time, option) {
  if (("" + time).length === 10) {
    time = parseInt(time) * 1000;
  } else {
    time = +time;
  }
  const d = new Date(time);
  const now = Date.now();

  const diff = (now - d) / 1000;

  if (diff < 30) {
    return "刚刚";
  } else if (diff < 3600) {
    // less 1 hour
    return Math.ceil(diff / 60) + "分钟前";
  } else if (diff < 3600 * 24) {
    return Math.ceil(diff / 3600) + "小时前";
  } else if (diff < 3600 * 24 * 2) {
    return "1天前";
  }
  if (option) {
    return parseTime(time, option);
  } else {
    return (
      d.getMonth() +
      1 +
      "月" +
      d.getDate() +
      "日" +
      d.getHours() +
      "时" +
      d.getMinutes() +
      "分"
    );
  }
}

/**
 * @param {string} url
 * @returns {Object}
 */
export function param2Obj(url) {
  const search = url.split("?")[1];
  if (!search) {
    return {};
  }
  return JSON.parse(
    '{"' +
      decodeURIComponent(search)
        .replace(/"/g, '\\"')
        .replace(/&/g, '","')
        .replace(/=/g, '":"')
        .replace(/\+/g, " ") +
      '"}'
  );
}

/**
 * @param {Function} func
 * @param {number} wait
 * @param {boolean} immediate
 * @return {*}
 */
export function debounce(func, wait, immediate) {
  let timeout, args, context, timestamp, result;

  const later = function () {
    // 据上一次触发时间间隔
    const last = +new Date() - timestamp;

    // 上次被包装函数被调用时间间隔 last 小于设定时间间隔 wait
    if (last < wait && last > 0) {
      timeout = setTimeout(later, wait - last);
    } else {
      timeout = null;
      // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
      if (!immediate) {
        result = func.apply(context, args);
        if (!timeout) context = args = null;
      }
    }
  };

  return function (...args) {
    context = this;
    timestamp = +new Date();
    const callNow = immediate && !timeout;
    // 如果延时不存在，重新设定延时
    if (!timeout) timeout = setTimeout(later, wait);
    if (callNow) {
      result = func.apply(context, args);
      context = args = null;
    }

    return result;
  };
}

// timeStamp: MSecsSinceEpoch = Unix timestamp * 1000
export function parseTimeStamp(timeStamp) {
  return dateFormat(ts2Date(timeStamp), "yyyy-mm-dd HH:MM:ss");
}

function ts2Date(strTimestamp) {
  var timestamp = parseInt(strTimestamp);
  if (isNaN(timestamp)) {
    timestamp = 0;
  }
  return new Date(timestamp);
}

export function value2CheckedList(value, options, length) {
  if (value === undefined) {
    return;
  }
  var bits = value.toString(2);
  var bitsCount = bits.length;
  for (var i = 0; i < length - bitsCount; i++) {
    bits = "0" + bits;
  }
  bits = bits.split("").reverse().join("");
  var ret = [];
  for (i = 0; i < bits.length; i++) {
    if (bits[i] === "1") {
      ret.push(options[i]);
    }
  }
  return ret;
}

export function checkedList2Value(checkedList, options, length) {
  var bits = "";
  for (var i = 0; i < length; i++) {
    if (checkedList.indexOf(options[i]) != -1) {
      bits += "1";
    } else {
      bits += "0";
    }
  }

  bits = bits.split("").reverse().join("");
  return parseInt(bits, 2);
}

export function setCache(key, value) {
  localStorage.setItem(key, JSON.stringify(value));
}

export function getCache(key) {
  return JSON.parse(localStorage.getItem(key));
}

export function mapTrim(obj) {
  const t = {};
  Object.keys(obj).forEach((key) => {
    if (
      typeof obj[key] !== "undefined" &&
      obj[key] !== null &&
      obj[key] !== ""
    ) {
      if (typeof obj[key] === "string") t[key] = obj[key].trim();
      else t[key] = obj[key];
    }
  });
  return t;
}

export function strTrim(str) {
  str = str
    .replace(/^([\s\n\r]|<br>|<br\/>|&nbsp;)+/, "")
    .replace(/([\s\n\r]|<br>|<br\/>|&nbsp;)+$/, "");
  return str.replace(/(\r\n)|[\n\r]/g, "<br/>"); // 转换换行符
}

export function getUUID() {
  let s = [];
  const hexDigits = "0123456789abcdef";
  for (let i = 0; i < 36; i++) {
    s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
  }
  s[14] = "4"; // bits 12-15 of the time_hi_and_version field to 0010
  s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1); // bits 6-7 of the clock_seq_hi_and_reserved to 01
  s[8] = s[13] = s[18] = s[23] = "-";

  return s.join("");
}

export function getPageTitle(pageTitle) {
  const title = settings.name.zh || settings.name.en || "Web Creator Pro";
  if (pageTitle) {
    return `${pageTitle} - ${title}`;
  }
  return `${title}`;
}

export function compareObjectDiff(dest, sour) {
  const result = {};
  Object.keys(dest).filter((key) => {
    if (dest[key] != sour[key]) result[key] = dest[key];
  });
  return result;
}

export function formatBytes(bytes, decimals) {
  if (bytes == 0) return "0 Bytes";
  var k = 1024,
    dm = decimals + 1 || 3,
    sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"],
    i = Math.floor(Math.log(bytes) / Math.log(k));
  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
}

export function download(name, url) {
    return new Promise((resolve) => {
        var a = document.createElement("a");
        a.href = url;
        a.download = name;
        a.target = "_blank";
        a.click();
        resolve();
        // document.body.removeChild(a);
    });
}

export function checkURL(URL) {
    var str = URL,
        Expression = /http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?/,
        objExp = new RegExp(Expression);

    return objExp.test(str)
}