/**
 * @fileOverview 工具方法库
 * @module lib/util
 * @author qiqi.zhou@yoho.cn
 */

import config from '../config';
import log4js from 'log4js';
import _ from 'lodash';

log4js.loadAppender('file');
log4js.addAppender(log4js.appenders.file(config.log), 'log');

let loger = log4js.getLogger('log');
loger.setLevel(config.logLevel); //配置日志

/**
 * @mixes 日志记录对象
 * @exports util/log
 */
export let log = loger;

/**
 * @method 无符号转16进制
 * @exports util/tenToHex
 * @param {Number} number 十进制数
 * @return {Number} 16进制数字
 */
export let tenToHex = function (number) {
    return (parseInt(number, 10) >>> 0).toString(16);
};

/**
 * @method 无符号16进制转10进制
 * @exports util/hexToTen
 * @param {Number} number 十六机制数
 * @param {Boolean} minus true表示负数，false表示正数
 * @return {Number} 十进制数字
 */
export let hexToTen = function (number, minus) {
    if (minus) {
        return parseInt('FFFF' + number, 16) >> 0;
    } else {
        return parseInt(number, 16);
    }

};

/**
 * @method 转16进制
 * @exports util/toHex
 * @param {Buff} data 返回数据流
 * @return {Array} 转成16进制的数组
 */
export let toHex = function (data) {
    let arr = [];
    for (let i = 0; i < data.length; i++) {
        arr[i] = tenToHex(data.readUIntLE(i));
    }
    return arr;
};


/**
 * @method 处理返回码
 * @exports util/returnProc
 * @param {Array} data 指令结果
 * @param {Array} ip 读写器IP
 * @param {Object} output 标准输出的规格对象
 * @return {object} 标准输出
 */
export let returnProc = function (data, ip, output) {
    if (!_.isArray(data) || _.size(data) < 1) {
        return false;
    }

    let ret = data.join('');
    if (!output[ret]) {
        return false;
    }
    //log.info("读写器(" + ip + ")返回:" + output[ret].message + " 返回码:" + ret);
    output[ret].hex = data;
    return output[ret];
};

/**
 * @method 返回结果拆分
 * @exports util/spliteRet
 * @param {Array} mq 发起指令的数组集合
 * @param {String} data 得到的指令数据结果集
 * @return {Object} 返回拆分结果和拆分依据的指令头
 */
export let spliteRet = function (mq, data) {
    let indexes = [],
        rets = [],
        i,
        k,
        j,
        leftMq = [],
        prevIndex = -1;
    for (i = 0; i < mq.length; i++) { //按照顺序获取所有的指令的第一位标示位置
        prevIndex = _.indexOf(data, mq[i], prevIndex + 1);
        if (prevIndex < 0) {
            leftMq = mq.slice(i);
            break;
        }
        indexes.push(prevIndex);
    }
    for (k = 0; k < indexes.length; k++) { //拆分结果集
        if (indexes[k + 1]) {
            rets.push(data.slice(indexes[k], indexes[k + 1]));
        } else {
            rets.push(data.slice(indexes[k]));
            break;
        }
    }
    if (indexes.length < 2) { //如果是拆分点小于2的，直接返回结果集
        rets = [data];
    }

    let allRets = [];
    for (j = 0; j < rets.length; j++) {
        if (rets[j][0] == 'f1' || rets[j][1] != '2') { //对于盘点一次指令，多次返回，盘点特殊处理

            let length = hexToTen(rets[j][1]);
            let allLength = rets[j].length;
            if (allLength > length + 2) {
                allRets.push(rets[j].slice(0, length + 2));
                allRets.push(rets[j].slice(length + 2));
            } else {
                allRets.push(rets[j]);
            }
        } else {
            allRets.push(rets[j]);
        }
    }
    return {
        rets: allRets,
        mq: leftMq,
    };
};

/**
 * @method 定位指令名称
 * @exports util/spliteRet
 * @param {Array} orders 指令规格数组
 * @param {Array} data 返回的结果集 eg. ['f0','2','0','0']
 * @return {Object} 返回定位到的指令
 */
export let locateOrder = function (orders, data) {
    let orderRet = {};
    _.forIn(orders, function (val, key) {
        var order = val.input.toLowerCase();
        var prefix = data[0].toLowerCase();

        if (_.startsWith(order, prefix)) {
            orderRet.name = key;
            orderRet.val = val;
        }
    });
    return orderRet;
};