import dayjs from 'dayjs';
export default {
  /**
   * 计算日期相差几天
   * @param：
   * @createTime:开始时间，结束时间
   * @returns：
   */
  getDaysDifference(startDate, endDate) {
    return dayjs(endDate).diff(startDate, 'day') + 1;
  },
  /**
   * 从分析数据数组中计算最小和大值 ,平均值，    在线率，有效率，超标率（后三个值为0~100取值）
   * @param：分析表中的数据
   * @returns：
   */
  calBillData(arr, beginTime, endTime) {
    let min = 65536;
    let max = -1;
    let avg = 0;
    let online = 0;
    let valid = 0;
    let exceeding = 0;

    let sumAvg = 0;
    let sumOnline = 0;
    let sumValid = 0;
    let sumExceeding = 0;

    // 计算选择的时间的相差的天数
    let begin = dayjs(beginTime).format('YYYY-MM-DD');
    let end = dayjs(endTime).format('YYYY-MM-DD');
    let dayDiff = this.getDaysDifference(begin, end);
    console.log('日期间隔', dayDiff);
    let obj = {};
    // 计算最小和大值
    arr.forEach((item) => {
      if (item.min < min) {
        min = item.min;
      }
      if (item.max > max) {
        max = item.max;
      }
      // 计算平均值，在线率，有效率，超标率
      sumAvg = sumAvg + item.dayAvg;
      sumOnline = sumOnline + Number(item.dayOnline.slice(0, -1));
      sumValid = sumValid + Number(item.dayValid.slice(0, -1));
      sumExceeding = sumExceeding + Number(item.dayExceeding.slice(0, -1));
    });
    // 计算均值
    avg = sumAvg / dayDiff;
    // console.log('sumavg:',sumAvg,dayDiff);
    online = sumOnline / dayDiff;
    valid = sumValid / dayDiff;
    exceeding = sumExceeding / dayDiff;
    obj['min'] = min.toFixed(3);
    obj['max'] = max.toFixed(3);

    obj['avg'] = avg.toFixed(2);
    obj['online'] = online.toFixed(2);
    obj['valid'] = valid.toFixed(2);
    obj['exceeding'] = exceeding.toFixed(2);

    return obj;
  },

  /**
   * 计算异常类型聚集度 异常复现率
   * @param： 异常数据数组
   * @returns：
   */
  calRecur(exceptionArr) {
    // 典型异常复现率
    let exceptionTyprRecurRate = 0;
    // 量级突变
    let mutationCount = 0;
    // 超标临近
    let exceedingNearCount = 0;
    // 超标次数临界
    let exceedindCriticalDegree = 0;

    // 保存出现的不同异常类型
    let exception = [];
    // 异常类型聚集度
    let exceptionTypeAggregation = 0;

    exceptionArr.forEach((item) => {
      // 异常复现率
      if (item.exceptionType == 4) {
        mutationCount++;
      } else if (item.exceptionType == 5) {
        exceedingNearCount++;
      } else if (item.exceptionType == 6) {
        exceedindCriticalDegree++;
      }

      // 异常类型聚集度
      if (exception.length == 0) {
        exception.push(item.exceptionType);
      }
      // 保存新的异常类型
      else if (exception.indexOf(item.exceptionType) == -1) {
        exception.push(item.exceptionType);
      }
    });

    let sum = 0;
    // 次数减1，该异常出现2次，算复现1次。出现3次，算复现2次...
    if (mutationCount > 1) {
      sum = sum + mutationCount - 1;
    }
    if (exceedingNearCount > 1) {
      sum = sum + exceedindCriticalDegree - 1;
    }
    if (exceedindCriticalDegree > 1) {
      sum = sum + exceedindCriticalDegree - 1;
    }
    // console.log('sum:', sum);
    // console.log('exception:', exception);
    // console.log(
    //   '其他',
    //   mutationCount,
    //   exceedindCriticalDegree,
    //   exceedindCriticalDegree
    // );
    switch (sum) {
      case 0:
        exceptionTyprRecurRate = sum / 3;
        break;
      case 1:
        exceptionTyprRecurRate = sum / 3;
        break;
      case 2:
      case sum >= 3:
        exceptionTyprRecurRate = 1;
        break;
      default:
        return 'error';
    }

    exceptionTypeAggregation = exception.length / 8;

    let obj = {};
    obj['exceptionRecurrence'] = exceptionTyprRecurRate;
    obj['exceptionTypeAggregation'] = exceptionTypeAggregation;

    return obj;
  }
};