/**
 * 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 [];
    }

    //生成时间戳后9位 保证唯一
    static creatSoleNumberFromTimestamp(){
        let time   = new Date().getTime();
        let timestamp= time % 1000000000;//time后9位
        return timestamp;
    }

    //生成时间戳毫秒
    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;
    }

    //生成时间戳  格式:"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;