/**
 * //转换为formData对象
 * @param {Object} msg 参数
 */
export const fomatFormData = (msg: any) => {
  let params = new URLSearchParams();
  for (let key in msg) {
    params.append(key, msg[key]);
  }
  return params;
};

/**
 *
 * @param {String[]} keysArr 键数组
 * @param {Any[]} dataSource 目标原数据数组
 * @param {String}key 指定键
 */
export const filterAssignArr = (
  keysArr: string[],
  dataSource: any[],
  key: string
) => {
  let arr: any[] = [];
  keysArr.forEach((item) => {
    dataSource.forEach((ele) => {
      if (item === ele[key]) {
        arr.push(ele);
      }
    });
  });
  return arr;
};

export const formatTreeData = (data: any) => {
  if (Array.isArray(data) && data.length > 0) {
    data.forEach((ele) => {
      ele.title = ele.name;
      ele.key = ele.id;
      if (ele.isPublic) {
        ele.disabled = true;
      }
      if (ele.children && ele.children.length > 0) {
        formatTreeData(ele.children);
      }
    });
  }
  return data;
};

export const formatStatusMap = (data: any[]) => {
  if (Array.isArray(data)) {
    if (data.length > 0) {
      let obj = {};
      data.forEach((ele) => {
        obj[+ele.dictValue] = ele.dictLabel;
      });
      return obj;
    } else {
      return {};
    }
  }
};

export const formatProTableValueEnum = (data: object) => {
  let obj: any = {};
  for (const key in data) {
    if (Object.prototype.hasOwnProperty.call(data, key)) {
      obj[key] = { text: data[key] };
    }
  }
  return obj;
};

/**
 *获取url特定的参数
 *
 * @export
 * @param {*} name
 * @returns
 */
export function getQueryVariable(name: string) {
  let reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
  let r = window.location.search.substr(1).match(reg);
  if (r != null) return unescape(r[2]);
  return "";
}

//复制
export const copyFun = (copyText) => {
  let tempinputDom = document.createElement("input");
  document.body.appendChild(tempinputDom);
  tempinputDom.value = copyText;
  tempinputDom.select();
  document.execCommand("copy");
  document.body.removeChild(tempinputDom);
};

type StorageType = "all" | "local" | "session";

export const setStorageData = (
  key: string,
  data: any,
  type: StorageType = "all"
) => {
  let formatData: any = data,
    dataType = Object.prototype.toString.call(data);
  if (dataType === "[object Object]" || dataType === "[object Array]") {
    formatData = JSON.stringify(data);
  }
  if (type === "session") {
    sessionStorage.setItem(key, formatData);
  } else if (type === "local") {
    localStorage.setItem(key, formatData);
  } else {
    sessionStorage.setItem(key, formatData);
    localStorage.setItem(key, formatData);
  }
};
type dataType = "object" | "array" | "string";
export const getStorageData = (key: string, type: dataType = "object") => {
  let data;
  if (
    sessionStorage.getItem(key) &&
    sessionStorage.getItem(key) !== "undefined"
  ) {
    data =
      type === "object" || type === "array"
        ? JSON.parse(sessionStorage.getItem(key) as any)
        : sessionStorage.getItem(key);
  } else {
    let emptyData = {
      string: "",
      object: {},
      array: [],
    };
    data = emptyData[type];
  }
  return data;
};

//对象数据并集
/**
 *
 * @param data1 对象数组1
 * @param data2 对象数组2
 * @param key 指定的key
 * @returns 并集后的对象数组
 */
export const unionData = (data1: any[], data2: any[], key: string) => {
  let mergeArr = [...data1, ...data2];
  let result = mergeArr.reduce(function (prev, cur, index, arr) {
    if (!prev.some((item: any) => item[key] === cur[key])) {
      prev.push(cur);
    }
    return prev;
  }, []);
  return result;
};

/**
   * 单维数组 求交集 并集 差集
   * @param arr1 
   * @param arr2 
   * @returns 
   * let arr1 = [3,4,5];
     let arr2 = [1, 3];
     return and: (4) [3, 4, 5, 1]
        diff: (3) [4, 5, 1]
        in: [3]
   */
export const inAndDiffHandle = (
  arr1: (string | number)[] = [],
  arr2: (string | number)[] = []
) => {
  let oS1 = new Set(arr1);
  let oS2 = new Set(arr2);
  return {
    in: [...oS1].filter((ele) => oS2.has(ele)),
    and: [...new Set([...arr1, ...arr2])],
    diff: [
      ...[...oS1].filter((ele) => !oS2.has(ele)),
      ...[...oS2].filter((ele) => !oS1.has(ele)),
    ],
  };
};
export const simpleUnique = (data: (string | number)[]) => {
  let lastArr: (string | number)[] = [];
  if (Array.isArray(data) && data.length > 0) {
    lastArr = Array.from(new Set([...data]));
  }
  return lastArr;
};

//对象如果有字段为空的话 就删除某个字段
export const filterObj = (paramsObj: object) => {
  for (const key in paramsObj) {
    if (Object.prototype.hasOwnProperty.call(paramsObj, key)) {
      if (paramsObj[key] === "" || paramsObj[key] === null)
        delete paramsObj[key];
    }
  }
};

/**
 * 把{name:'aaa',age:'',address:''}过滤为 {name:'aaa'}
 * @param paramsObj 需要过滤空字符串的对象
 * @returns 过滤后的对象
 */
export const filterTableRequestObj = (paramsObj: object) => {
  let _paramsObj = JSON.parse(JSON.stringify(paramsObj)) || {};
  for (const key in _paramsObj) {
    if (Object.prototype.hasOwnProperty.call(_paramsObj, key)) {
      if (_paramsObj[key] === "" || _paramsObj[key] === undefined) {
        delete _paramsObj[key];
      }
    }
  }
  return _paramsObj;
};

/**
 *  判断targetStr字符集合里面，是否全包含在穷举的集合（字符串或数组）里。
 * fuc([1,2,3,4],'34')return true; fuc([1,2,3,4],'45') return false;
 * @param allStr 需要过滤空字符串的对象
 * @param targetStr 需要过滤空字符串的对象
 * @returns 'true', 'false'
 */
export const allContain = (allStr: (string | number)[], targetStr: string) => {
  let flag = true;
  for (let i = 0; i < targetStr.length; i++) {
    if (allStr.indexOf(targetStr[i]) === -1) {
      flag = false;
      break;
    }
  }
  return flag;
};

export const getMenuDataOfLinearArray = (menuData: any[]) => {
  let arr: any = [];
  const _fun = (menu: any[]) => {
    for (const item of menu) {
      if (item.type !== 1 && item.routeUrl) {
        arr.push({
          id: item.id,
          name: item.name,
          parentId: item.parentId,
          path: item.routeUrl,
          pathname: item.routeUrl,
          type: item.type,
        });
      }

      item.children && _fun(item.children);
    }
  };
  _fun(menuData);
  return arr;
};

//节流函数
export function throttle(fun: Function, delay = 3000) {
  let last: number, deferTimer: any;
  return function (args: any) {
    let that = this;
    let _args = arguments;
    let now = +new Date();
    if (last && now < last + delay) {
      clearTimeout(deferTimer);
      deferTimer = setTimeout(function () {
        last = now;
        fun.apply(that, _args);
      }, delay);
    } else {
      last = now;
      fun.apply(that, _args);
    }
  };
}
interface IProTableParams {
  current?: number;
  pageSize?: number;
}
export const formatTableRequestParamsAndResponseData = {
  requestParams: (params: IProTableParams) => {
    let lastParams: any = {
      ...params,
      page: params.current,
      limit: params.pageSize,
    };
    delete lastParams.current;
    return filterTableRequestObj(lastParams);
  },
  responseData: (response: any) => {
    let lastData = {
      // ...response,
      data: response.data,
      page: response.currentPage,
      total: response.totalRecords,
      success: true,
    };
    return lastData;
  },
};

export function gethmTime(minute: number) {
  const h = Math.floor(minute / 60);
  const m = minute - h * 60;
  return {
    h,
    m,
  };
}
console.log(4444);