var readerConfig = require('./readerConfig.js'),
    index = require('../index.js'),
    _ = require('lodash'),
    async = require('async'),
    r = require('./rfidRedis.js');

exports.connectedReaders = [];
/**
 * 连接所有读写器
 */
exports.connectAllReaders = function()
{
    var readers = readerConfig.getReaderConfig();
    for(var ip in readers)
    {
        var reader = readers[ip];
        var filter = {
            'on': '1',
            rssi: reader.rssi
        };

        // 初次连接最多连接5次
        async.retry(5, function(cb, results){
            connectReader(ip, 9761, filter, reader.frequency, reader.inventory_time, reader.stay_time, reader.ants, reader.group, cb);

        }, function(err, results){
            if(err){
                console.error(err);
            }
        });
    }
}

/**
 * 连接并获取读写器的数据，然后传递到客户端
 *
 * @param host 读写器的的IP
 * @param port 读写器的的端口
 * @param filter 读写器的RSSI过滤有关数据
 * @param frequency 读写器的定频有关数据
 * @param inventoryTime 盘点时间
 * @param antStayTime 天线驻留时间
 * @param power 各天线的功率
 * @param group 读写器所在组
 * @param cb 回调函数
 */
function connectReader(host, port, filter, frequency, inventoryTime, antStayTime, power, group, cb)
{
    index.start({
        host: host,
        port: port,
        filter: filter,
        frequency: frequency,
        inventoryTime: inventoryTime,
        antStayTime: antStayTime,
        power: power,
        group: group
    }, function (err, connected, onTags, goneTags) {

        var onEpcs = [],
            offEpcs = [];

        // 获取redis中指定组在架标签数据
        r.hget(group, 'on', function(err, epcs)
        {
            if (err)
            {
                console.error(err);
            }
            else
            {
                try
                {
                    var redisEpcs = JSON.parse(epcs);
                    // 处理在架标签
                    _.forEach(redisEpcs, function(item){
                        if(item.host != host && _.findWhere(onTags, {epc: item.epc}) === undefined){
                            onEpcs.push(item);
                        }
                    });
                    _.forEach(onTags, function(item){
                        onEpcs.push({
                            GroupID: item.group,
                            EPC: item.epc,
                            host: item.host,
                            speed: item.speed,
                            updateTime: item.updateTime
                        });
                    });

                    r.hset(group, 'on', JSON.stringify(onEpcs), function(){});

                    // 处理离架标签
                    _.forEach(goneTags, function(goneEpc){
                        if(!goneEpc || (_.findWhere(redisEpcs, {EPC: goneEpc.epc}) === undefined && _.findWhere(onTags, {epc: goneEpc.epc}) === undefined)){
                            offEpcs.push({
                                GroupID: goneEpc.group,
                                EPC: goneEpc.epc,
                                host: goneEpc.host,
                                speed: goneEpc.speed,
                                rssi: goneEpc.rssi,
                                updateTime: goneEpc.updateTime
                            });
                        }
                    });

                    r.hset(group, 'off', JSON.stringify(offEpcs), function(){});

                    if(connected){
                        var reader = _.findWhere(exports.connectedReaders, {name: host});
                        if(reader !== undefined)
                        {
                            reader.status = true;
                        }
                        else
                        {
                            exports.connectedReaders.push({
                                name: host,
                                status: true,
                                restartTimes: 0
                            });
                        }
                        cb(null, connected);
                    }else{
                        cb(new Error('连接读写器'+host+'错误'), connected);
                    }
                }
                catch(er)
                {
                    console.error('标签数据JSON格式错误：'+er);
                }
            }
        });

    });
}

exports.connectReader = connectReader;