import Long from './Long.js';
//const Long = require('./Long.js')
//import Long from '@/static/js/Long.js'

/**
 * short所占byte的最大位数
 */
const SHORT_MAX_LENGTH = 2;
/**
 * int所占byte的最大位数
 */
const INT_MAX_LENGTH = 4;

/**
 * float所占byte的最大位数
 */
const FLOAT_MAX_LENGTH = 4;

/**
 * long所占byte的最大位数
 */
const LONG_MAX_LENGTH = 8;


/**
 * 一位byte所能表示的最大无符号整数是255
 */
const MAX_ARRAY_LENGTH = 255;

/**
 * 两位byte所能表示的最大无符号整数是65535
 */
const MAX_LARGE_ARRAY_LENGTH = 65535;

const BigEndian = 0;

const LittleEndian = 1;


let int8 = new Int8Array(4);
let int32 = new Int32Array(int8.buffer, 0, 1);
let float32 = new Float32Array(int8.buffer, 0, 1);


function stringToChars(_s) {
    // _s = _s.replace(/(^\s*)|(\s*$)/g, "");
    let _r = [];
    for (let i = 0; i < _s.length; i++) {
        _r[i] = _s.charAt(i);
    }
    return _r;

}

/***
 * byte[] 转16进制字符串
 * @param src
 * @return
 */
function bytesToHexString(src) {

    let stringBuilder = "";
    if (src == null || src.length <= 0) {
        return null;
    }
    for (let i = 0; i < src.length; i++) {
        let v = src[i] & 0xFF;
        let hv = Number(v).toString(16);
        if (hv.length < 2) {
            stringBuilder += "0"
        }
        stringBuilder += hv;
    }
    return stringBuilder;
}

/***
 * byte[] 转16进制字符串[空格隔开]
 * @param src
 * @return
 */
function bytesToHex(src) {
    let stringBuilder = "";
    if (src == null || src.length <= 0) {
        return null;
    }
    for (let i = 0; i < src.length; i++) {
        let v = src[i] & 0xFF;
        let hv = Number(v).toString(16);
        if (hv.length < 2) {
            stringBuilder.concat(0);
        }
        stringBuilder.concat(hv).concat("");
    }
    return stringBuilder;
}

/**
 * hexString转byteArr
 *
 * @param hexString
 * @return
 */
function hexStringToBytes(hexString) {
    if (hexString == null || "" === hexString) {
        return null;
    }
    hexString = hexString.toUpperCase();
    let length = hexString.length / 2;
    let hexChars = stringToChars(hexString);
    let d = [length];
    for (let i = 0; i < length; i++) {
        let pos = i * 2;
        d[i] = (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
    }
    return d;
}

/**
 *  char to byte
 * @param c
 * @return
 */
function charToByte(c) {
    return "0123456789ABCDEF".indexOf(c);
}

/**
 * 一位byte转int【无符号】
 *
 * @param b
 * @return 【0 ~ 255】
 */
function byteToIntUnSigned(b) {
    return b & 0xFF;
}

/**
 * int 转 byte 4
 * @param n
 * @return
 */
function intToBytes(n) {
    let b = [];
    b[3] = (n & 0xff);
    b[2] = (n >> 8 & 0xff);
    b[1] = (n >> 16 & 0xff);
    b[0] = (n >> 24 & 0xff);
    return b;
}

/**
 * byte 4 转 byte 1
 * @param bytes
 * @return
 */
function byte4ToByte1(bytes) {
    let byte1 = [];
    byte1[0] = bytes[3];
    return byte1;
}

/**
 *
 * @param bytes
 * @return
 */
function bytesReverse(bytes) {
    let b = bytes[0];
    b = ~b;
    return b;
}



// ======================【通用方法】=====================================//

/**
 * 按照指定的存储方式来依次读取byte数据
 *
 * @param mode   存储方式
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @param length 长度
 * @return
 */
function readBytes(mode, src, offset, length) {
    let value = 0;
    //从低位开始读
    if (LittleEndian === mode) {
        for (let i = 0; i < length; i++) {
            value |= (src[offset + i] & 0xFF) << (8 * i);
        }
    } else {
        for (let i = 0; i < length; i++) {
            value |= (src[offset + length - i - 1] & 0xFF) << (8 * i);
        }
    }
    return value;
}

/**
 * 填充数值到byte数组中
 *
 * @param mode   存储方式
 * @param value  数值
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @param length 数值的长度
 */
function fillValueToBytes(mode, value, src, offset, length) {
    if (LittleEndian === mode) {
        for (let i = 0; i < length; i++) {
            src[offset + i] = ((value >> (i * 8)) & 0xFF);
        }
    } else {
        for (let i = 0; i < length; i++) {
            src[offset + length - i - 1] = ((value >> (i * 8)) & 0xFF);
        }
    }
}

/**
 * 将值转化为byte数组
 *
 * @param mode   存储方式
 * @param value  数值
 * @param length 数值的长度
 */
function valueToBytes(mode, value, length) {
    let bytes = [];
    if (LittleEndian === mode) {
        for (let i = 0; i < length; i++) {
            bytes[i] = ((value >> (i * 8)) & 0xFF);
        }
    } else {
        for (let i = 0; i < length; i++) {
            bytes[length - i - 1] = ((value >> (i * 8)) & 0xFF);
        }
    }
    return bytes;
}

// ======================【byte数组<-->（无符号）short】=====================================//

/**
 * byte数组中取short数值
 *
 * @param mode   存储方式
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @param length 长度
 * @return short 数值
 */
function bytesToShort(mode, src, offset, length) {
    if (length < 1 || length > SHORT_MAX_LENGTH) { //纠正错误的长度
        length = SHORT_MAX_LENGTH;
    }
    return readBytes(mode, src, offset, length);
}

/**
 * byte数组中取short数值
 *
 * @param mode   存储方式
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @return short 数值
 */
// function bytesToShort(mode, src, offset) {
//     return readBytes(mode, src, offset, SHORT_MAX_LENGTH);
// }

/**
 * 将short填充至byte数组中
 *
 * @param mode   存储方式
 * @param value  数值
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @param length 长度
 * @return short数值
 */
function fillShortToBytes(mode, value, src, offset, length) {
    if (length < 1 || length > SHORT_MAX_LENGTH) { //纠正错误的长度
        length = SHORT_MAX_LENGTH;
    }
    fillValueToBytes(mode, value, src, offset, length);
    return offset + length;
}

/**
 * 将short填充至byte数组中
 *
 * @param mode   存储方式
 * @param value  数值
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @return short数值
 */
// function fillShortToBytes(mode, value,  src, offset) {
//     fillValueToBytes(mode, value, src, offset, SHORT_MAX_LENGTH);
//     return offset + SHORT_MAX_LENGTH;
// }

// ======================【byte数组<-->（无符号）int】=====================================//

/**
 * byte数组中取int数值
 *
 * @param mode   存储方式
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @param length 长度
 * @return short数值
 */
function bytesToInt(mode, src, offset, length) {
    if (length < 1 || length > INT_MAX_LENGTH) {  //纠正错误的长度
        length = INT_MAX_LENGTH;
    }
    return readBytes(mode, src, offset, length);
}

/**
 * 将Int填充至byte数组中
 *
 * @param mode   存储方式
 * @param value  数值
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @param length 长度
 * @return short数值
 */
function fillIntToBytes(mode, value, src, offset, length) {
    if (length < 1 || length > INT_MAX_LENGTH) { //纠正错误的长度
        length = INT_MAX_LENGTH;
    }
    fillValueToBytes(mode, value, src, offset, length);
    return offset + length;
}


// ======================【byte数组<-->（无符号）long】=====================================//

/**
 * byte数组中取long数值
 *
 * @param mode   存储方式
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @param length 长度
 * @return short数值
 */
function bytesToLong(mode, src, offset, length) {
    if (length < 1 || length > LONG_MAX_LENGTH) {  //纠正错误的长度
        length = LONG_MAX_LENGTH;
    }


    let value = Long.fromNumber(0);
    let bt = []
    for (let i = 0; i < length; i++) {
        bt[i] = src[offset + i]
    }
    //从低位开始读
    if (LittleEndian === mode) {
        value = Long.fromBytesLE(bt).toNumber();
    } else {
        value = Long.fromBytesBE(bt).toNumber();
    }
    return value;
}


/**
 * 将long填充至byte数组中
 *
 * @param mode   存储方式
 * @param value  数值
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @param length 长度
 * @return short数值
 */
function fillLongToBytes(mode, value, src, offset, length) {
    if (length < 1 || length > LONG_MAX_LENGTH) { //纠正错误的长度
        length = LONG_MAX_LENGTH;
    }
    let bt = []
    if (LittleEndian === mode) {
        bt = Long.fromValue(value).toBytesLE()

    } else {
        bt = Long.fromValue(value).toBytesBE()
    }
    for (let i = 0; i < length; i++) {
        src[offset + i] = bt[i]
    }
    return offset + length;
}



// ======================【byte数组<--> String】=====================================//

/**
 * byte数组中取String数值
 *
 * @param mode   存储方式
 * @param src    byte数组
 * @param offset 从数组的第offset位开始
 * @param length 长度
 * @return String
 */
function bytesToString(src, offset, length) {
    let arr = []
    for (let i = 0; i < length; i++) {
        let value = src[offset + i];
        if (value !== 0) {
            arr[i] = value
        }
    }
    let str = '',
        _arr = arr;
    for (let i = 0; i < _arr.length; i++) {
        let one = _arr[i].toString(2),
            v = one.match(/^1+?(?=0)/);
        if (v && one.length === 8) {
            let bytesLength = v[0].length;
            let store = _arr[i].toString(2).slice(7 - bytesLength);
            for (let st = 1; st < bytesLength; st++) {
                store += _arr[st + i].toString(2).slice(2);
            }
            str += String.fromCharCode(parseInt(store, 2));
            i += bytesLength - 1;
        } else {
            str += String.fromCharCode(_arr[i]);
        }
    }
    return str.trim();
}

function fillStringToBytes(value, src, offset, length) {
    let bytes = [];
    let c;
    for (let i = 0; i < value.length; i++) {
        c = value.charCodeAt(i);
        if (c >= 0x010000 && c <= 0x10FFFF) {
            bytes.push(((c >> 18) & 0x07) | 0xF0);
            bytes.push(((c >> 12) & 0x3F) | 0x80);
            bytes.push(((c >> 6) & 0x3F) | 0x80);
            bytes.push((c & 0x3F) | 0x80);
        } else if (c >= 0x000800 && c <= 0x00FFFF) {
            bytes.push(((c >> 12) & 0x0F) | 0xE0);
            bytes.push(((c >> 6) & 0x3F) | 0x80);
            bytes.push((c & 0x3F) | 0x80);
        } else if (c >= 0x000080 && c <= 0x0007FF) {
            bytes.push(((c >> 6) & 0x1F) | 0xC0);
            bytes.push((c & 0x3F) | 0x80);
        } else {
            bytes.push(c & 0xFF);
        }
    }
    for (let i = 0; i < length; i++) {
        src[offset + i] = bytes[i]
    }
    return bytes;
}

// ======================【大小端转化】=====================================//

/**
 * 大端值转小端
 *
 * @param value
 * @param length
 * @return
 */
function bigEndianToLittleEndian(value, length) {
    let src = valueToBytes(BigEndian, value, length);
    return readBytes(LittleEndian, src, 0, length);
}

/**
 * 小端值转大端
 *
 * @param value
 * @param length
 * @return
 */
function littleEndianToBigEndian(value, length) {
    let src = valueToBytes(LittleEndian, value, length);
    return readBytes(BigEndian, src, 0, length);
}


/**
 * byte 转 hex
 * @param b
 * @return
 */
function byteToHex(b) {
    let hex = Integer.toHexString(b & 0xFF);
    if (hex.length() < 2) {
        hex = "0" + hex;
    }
    return hex;
}

function byteToBit(a) {
    let temp = new byte[8];
    for (let i = 7; i >= 0; i--) {
        temp[i] = ((a >> i) & 1);
    }
    return temp;
}



function bitToByte(a) {
    let temp = 0;
    for (let i = 0; i < a.length; i++) {
        temp = (temp | a[i] << i);
    }
    return temp;
}



function intBitsToFloat(i) {
    int32[0] = i;
    return float32[0];
}

function floatToIntBits(f) {
    float32[0] = f;
    return int32[0];
}





/////////////////////////////////////////////测试/////////////////////////////////////////////////////////
//测试 61850 静态图谱文件  小端模式
let hexStr = "";



// let bytes = hexStringToBytes(hexStr);

// normVersion = intBitsToFloat(bytesToInt(LittleEndian, bytes, 0, 4))
// fileVersion = intBitsToFloat(bytesToInt(LittleEndian, bytes, 4, 4))
// atlasType = bytesToShort(LittleEndian, bytes, 8, 2)
// atlasTime = bytesToLong(LittleEndian, bytes, 10, 8)
// testFileFlag = bytes[18]
// chName = bytesToString(bytes, 19, 32)
// dischargeType = bytes[51]
// alarmLevel = bytes[52]
// dischargeFlag = bytes[53]
// dischargeTypeBability = []
// for (let i = 0, offset = 54; i < 7; i++, offset += 4) {
//     dischargeTypeBability[i] = intBitsToFloat(bytesToInt(LittleEndian, bytes, offset, 4))
// }
// phase = bytesToInt(LittleEndian, bytes, 82, 4)
// amplitude = bytesToInt(LittleEndian, bytes, 86, 4)
// periodicity = bytesToInt(LittleEndian, bytes, 90, 4)
// correlation50Hz = bytesToInt(LittleEndian, bytes, 94, 4)
// correlation100Hz = bytesToInt(LittleEndian, bytes, 98, 4)
// atlasFlag = bytes[102]
// dBmUnit = bytes[103]
// dBmMin = intBitsToFloat(bytesToInt(LittleEndian, bytes, 104, 4))
// dBmMax = intBitsToFloat(bytesToInt(LittleEndian, bytes, 108, 4))
// decollator = bytesToString(bytes, 112, 4)
// dBmData = []
// for (let i = 0, offset = 116; i < 6400; i++, offset += 4) {
//     dBmData[i] = intBitsToFloat(bytesToInt(LittleEndian, bytes, offset, 4))
// }
// console.log(normVersion, fileVersion, atlasType, atlasTime, testFileFlag, chName, dischargeType, alarmLevel, dischargeFlag, dischargeTypeBability, phase
//     , amplitude, periodicity, correlation50Hz, correlation100Hz, atlasFlag, dBmUnit, dBmMin, dBmMax, decollator, dBmData)

// //转字节
// let data = []
// fillIntToBytes(LittleEndian , floatToIntBits(normVersion), data , 0 , 4)
// fillIntToBytes(LittleEndian , floatToIntBits(fileVersion), data , 4 , 4)
// fillShortToBytes(LittleEndian , atlasType , data, 8 , 2)
// fillLongToBytes(LittleEndian , atlasTime , data , 10 , 8)
// data[18] = testFileFlag
// fillStringToBytes(chName , data , 19,32)
// data[51] = dischargeType
// data[52] = alarmLevel
// data[53] = dischargeFlag
// for(let i = 0 , offset = 54 ; i< 7 ; i++ ,offset+=4 ){
//     fillIntToBytes(LittleEndian , floatToIntBits(dischargeTypeBability[i]), data , offset , 4)
// }
// fillIntToBytes(LittleEndian , phase , data , 82 , 4)
// fillIntToBytes(LittleEndian , amplitude , data , 86 , 4)
// fillIntToBytes(LittleEndian , periodicity , data , 90 , 4)
// fillIntToBytes(LittleEndian , correlation50Hz , data , 94 , 4)
// fillIntToBytes(LittleEndian , correlation100Hz , data , 98 , 4)
// data[102] = atlasFlag
// data[103] = dBmUnit
// fillIntToBytes(LittleEndian , floatToIntBits(dBmMin), data , 104 , 4)
// fillIntToBytes(LittleEndian , floatToIntBits(dBmMax), data , 108 , 4)
// fillStringToBytes(decollator , data , 112,4)
// for(let i = 0 , offset = 116 ; i< 6400 ; i++ ,offset+=4 ){
//     fillIntToBytes(LittleEndian , floatToIntBits(dBmData[i]), data , offset , 4)
// }
// console.log(bytesToHexString(data) === hexStr)

///测试大端模式

let bigHexStr = ""



// bytes = hexStringToBytes(bigHexStr);

// normVersion = intBitsToFloat(bytesToInt(BigEndian,bytes,0,4))
// fileVersion = intBitsToFloat(bytesToInt(BigEndian,bytes,4,4))
// atlasType = bytesToShort(BigEndian,bytes,8,2)
// atlasTime = bytesToLong(BigEndian , bytes , 10 , 8)
// testFileFlag = bytes[18]
// chName = bytesToString(bytes,19,32)
// dischargeType = bytes[51]
// alarmLevel = bytes[52]
// dischargeFlag = bytes[53]
// dischargeTypeBability = []
// for(let i = 0 , offset = 54 ; i< 7 ; i++ ,offset+=4 ){
//     dischargeTypeBability[i] = intBitsToFloat(bytesToInt(BigEndian,bytes,offset,4))
// }
// phase = bytesToInt(BigEndian , bytes , 82 , 4)
// amplitude = bytesToInt(BigEndian , bytes , 86 , 4)
// periodicity = bytesToInt(BigEndian , bytes , 90 , 4)
// correlation50Hz = bytesToInt(BigEndian , bytes , 94 , 4)
// correlation100Hz = bytesToInt(BigEndian , bytes , 98 , 4)
// atlasFlag = bytes[102]
// dBmUnit = bytes[103]
// dBmMin = intBitsToFloat(bytesToInt(BigEndian,bytes,104,4))
// dBmMax = intBitsToFloat(bytesToInt(BigEndian,bytes,108,4))
// decollator = bytesToString(bytes, 112 ,4)
// dBmData = []
// for(let i = 0 , offset = 116 ; i< 6400 ; i++ ,offset+=4 ){
//     dBmData[i] = intBitsToFloat(bytesToInt(BigEndian,bytes,offset,4))
// }
// console.log(normVersion,fileVersion,atlasType,atlasTime,testFileFlag,chName,dischargeType,alarmLevel,dischargeFlag,dischargeTypeBability,phase
//     ,amplitude,periodicity,correlation50Hz,correlation100Hz,atlasFlag,dBmUnit,dBmMin,dBmMax,decollator,dBmData)

// //转字节
// fillIntToBytes(BigEndian , floatToIntBits(normVersion), data , 0 , 4)
// fillIntToBytes(BigEndian , floatToIntBits(fileVersion), data , 4 , 4)
// fillShortToBytes(BigEndian , atlasType , data, 8 , 2)
// fillLongToBytes(BigEndian , atlasTime , data , 10 , 8)
// data[18] = testFileFlag
// fillStringToBytes(chName , data , 19,32)
// data[51] = dischargeType
// data[52] = alarmLevel
// data[53] = dischargeFlag
// for(let i = 0 , offset = 54 ; i< 7 ; i++ ,offset+=4 ){
//     fillIntToBytes(BigEndian , floatToIntBits(dischargeTypeBability[i]), data , offset , 4)
// }
// fillIntToBytes(BigEndian , phase , data , 82 , 4)
// fillIntToBytes(BigEndian , amplitude , data , 86 , 4)
// fillIntToBytes(BigEndian , periodicity , data , 90 , 4)
// fillIntToBytes(BigEndian , correlation50Hz , data , 94 , 4)
// fillIntToBytes(BigEndian , correlation100Hz , data , 98 , 4)
// data[102] = atlasFlag
// data[103] = dBmUnit
// fillIntToBytes(BigEndian , floatToIntBits(dBmMin), data , 104 , 4)
// fillIntToBytes(BigEndian , floatToIntBits(dBmMax), data , 108 , 4)
// fillStringToBytes(decollator , data , 112,4)
// for(let i = 0 , offset = 116 ; i< 6400 ; i++ ,offset+=4 ){
//     fillIntToBytes(BigEndian , floatToIntBits(dBmData[i]), data , offset , 4)
// }

// console.log(bytesToHexString(data) === bigHexStr)



export {
    LittleEndian,
    BigEndian,
    hexStringToBytes,
    intBitsToFloat,
    bytesToShort,
    bytesToLong,
    bytesToInt,
    bytesToString,
    fillIntToBytes,
    fillShortToBytes,
    fillLongToBytes,
    fillStringToBytes,
    bytesToHexString,
}