/**
 * Created by hoopoe8 on 2017/1/8.
 */
import Base64 from 'base64-js';
import UTF8 from 'utf-8';

class EngineUtils {
  static isEmptyObject(O) {
    for (var x in O) {
      return false;
    }
    return true;
  }

  static arrayToJsonString(_param) {
    try {
      return JSON.stringify(_param);
    } catch (err) {
      console.warn("数组转JSON失败->ERROR:" + err.message);
    }
    return "";
  }

  static arrayFromJsonString(_param) {
    try {
      return JSON.parse(_param);
    } catch (err) {
      console.warn("JSON转数组失败->ERROR:" + err.message);
    }
    return [];
  }

  /*
   * 生成随机数   _part 段数 默认3段;   splitStr分隔符
   * */
  static creatRandomNum(_part = 3, splitStr = "") {
    let randNumStr = "";
    for (let i = 0; i < _part; i++) {
      if(i==0){
        randNumStr += ""+parseInt(Math.random() * 1000);
      }else{
        randNumStr +=splitStr+parseInt(Math.random() * 1000);
      }
    }
    return randNumStr;
  }

  /*
   * 生成随机数   randomLen随机数范围;   minLen 随机数的最小长度
   * */
  static getRandomInt(randomLen, minLen) {
    let randNumStr = "";
    randNumStr=""+parseInt(Math.random() * randomLen);
    let distance=minLen-randNumStr.length;
    if(distance>0){
      for (let i = 0; i < distance; i++) {
        randNumStr="0"+randNumStr;
      }
    }
    return randNumStr;
  }


  //生成时间戳后9位 保证唯一
  static creatSoleNumberFromTimestamp() {
    let time = new Date().getTime();
    let timestamp = time % 1000000000;//time后9位
    return timestamp;
  }
  //生成时间戳毫秒
  static creatNowTime() {
    let time = new Date().getTime();
    return time;
  }
  //生成时间戳秒
  static creatTimestamp() {
    let time = parseInt(new Date().getTime() / 1000);//精确到秒
    return time;
  }

  //生成时间戳 string
  static creatTimestampStr() {
    let curTime = new Date();
    let timeStr = "" + curTime.getFullYear() + "-";
    timeStr += (curTime.getMonth() + 1) + "-";
    timeStr += curTime.getDate() + "-";
    timeStr += curTime.getHours() + "-";
    timeStr += curTime.getMinutes() + "-";
    timeStr += curTime.getSeconds();
    return timeStr;
  }

  //根据时间戳字符串转换为时间戳  2017-10-27-15-38-15
  static getTimestampFromStr(_timeStr) {
    if (!_timeStr) return this.creatTimestamp();
    let timeArr = _timeStr.split("_");
    if (timeArr && timeArr.length == 6) {
      return parseInt(new Date(timeArr[0], parseInt(timeArr[1]) - 1, timeArr[2], timeArr[3], timeArr[4], timeArr[5]).getTime() / 1000);
    }
    return this.creatTimestamp();
  }

  //生成时间戳  格式:"20170209"
  static creatTimestampYMD() {
    let curTime = new Date();
    let year = "" + curTime.getFullYear();
    let month = "" + (curTime.getMonth() + 1);
    let day = "" + curTime.getDate();

    if (month.length < 2) {
      month = "0" + month;
    }
    if (day.length < 2) {
      day = "0" + day;
    }
    return year + month + day;
  }

  static objectToBase64(_object) {
    try {
      let _objectStr = JSON.stringify(_object);
      //console.log("objectToBase64------1----------")
      let byte = UTF8.setBytesFromString(_objectStr);
      //console.log("objectToBase64------2----------")
      let _objectBase64 = Base64.fromByteArray(byte);
      return _objectBase64
    } catch (err) {
      console.log("objectToBase64 err:" + err.message);
      return "";
    }
    return ""
  }

  static objectFromBase64(_objectBase64) {
    try {
      let byte = Base64.toByteArray(_objectBase64);
      let _objectStr = UTF8.getStringFromBytes(byte);
      let _object = JSON.parse(_objectStr);
      return _object
    } catch (err) {
      console.log("objectFromBase64 err:" + err.message);
      return null;
    }
    return null;
  }

  //优化压缩坐标点数组，去除一些连续重复坐标的点，返回一个数组
  static compressPoint(_arr) {
    if (!_arr) {
      return [];
    }
    if (_arr.length < 5) {
      //点，直线，矩形 坐标点小于5不需要处理
      return _arr;
    }
    let tempPointArr = _arr;
    let newPointArr = [];
    newPointArr.push(tempPointArr[0]);
    let lastW = tempPointArr[0].w;
    let continueNum = 0;//坐标相同的连续次数
    //先筛除水平方向的连续重复坐标点
    let len = tempPointArr.length - 1;
    for (let i = 1; i < len; i++) {
      let item = tempPointArr[i];
      if (item && item.w != lastW) {
        lastW = item.w;
        if (continueNum > 0) {
          newPointArr.push(tempPointArr[i - 1]);
        }
        newPointArr.push(item);
        continueNum = 0;
      } else {
        continueNum++;
      }
    }
    //如果最终的坐标点数量小于2,需要把最后一个坐标点添加
    if (tempPointArr[len]) {
      newPointArr.push(tempPointArr[len]);
    }
    //如果坐标点已经小于等于2不需要继续检测
    if (newPointArr.length <= 2) {
      return newPointArr;
    }

    //筛除水垂直向的连续重复坐标点
    let finalPointArr = [];
    finalPointArr.push(newPointArr[0]);
    let lastH = newPointArr[0].h;
    continueNum = 0;
    len = newPointArr.length - 1;
    for (let k = 1; k < len; k++) {
      let item = newPointArr[k];
      if (item && item.h != lastH) {
        lastH = item.h;
        if (continueNum > 0) {
          finalPointArr.push(newPointArr[k - 1]);
        }
        finalPointArr.push(item);
        continueNum = 0;
      } else {
        continueNum++;
      }
    }
    if (newPointArr[len]) {
      finalPointArr.push(newPointArr[len]);
    }
    return finalPointArr;
  }

  //压缩数据,把坐标点数组转换为字符串,返回字符串
  static optimizePoint(_pointGroup) {
    if (!_pointGroup) {
      return "";
    }
    let tempStr = "";
    try {
      tempStr = JSON.stringify(_pointGroup);
    } catch (err) {
      return "";
    }
    let regexp1 = /},{"w":/g;
    let regexp2 = /,"h":/g;
    tempStr = tempStr.replace(regexp1, "#");
    tempStr = tempStr.replace(regexp2, "&");
    //console.log("标注压缩后的字符长度->",tempStr.length);
    return tempStr;
  }

  //把字符串坐标点集合转换为数组,返回数组的JSON
  static unPackOptimizePoint(_str) {
    if (!_str) {
      return "";
    }
    let tempStr = _str;
    let regexp1 = /#/g;
    let regexp2 = /&/g;
    tempStr = tempStr.replace(regexp1, '},{"w":');
    tempStr = tempStr.replace(regexp2, ',"h":');

    let dataArr = [];
    try {
      dataArr = JSON.parse(tempStr);
    } catch (err) {

    }
    return dataArr;
  }
}
export  default EngineUtils;