package com.ld.igds.oa.service;

import com.ld.igds.constant.RedisConst;
import com.ld.igds.models.OAGps;
import com.ld.igds.oa.dto.AssetData;
import com.ld.igds.oa.dto.GpsData;
import com.ld.igds.oa.dto.GpsLocationData;
import com.ld.igds.oa.mapper.GpsServiceMapper;
import com.ld.igds.oa.service.CoreGpsService;
import com.ld.igds.util.ContextUtil;
import com.ld.igds.util.RedisUtil;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.*;

@Slf4j
@Component
public class CoreGpsServiceImpl implements CoreGpsService {

    @Autowired
    private GpsServiceMapper gpsServiceMapper;

    @Autowired
    private RedisUtil redisUtil;

    @Override
    public void updateGps(GpsData data) {
        //更新设备信息
        int i = gpsServiceMapper.updateGps(data);

        //若i等于0说明此设备不存在，进行新增设备
        if (i == 0) {
            data.setId(ContextUtil.getCurTimeMillis());
            gpsServiceMapper.addGps(data);
        }
    }

    @Override
    public GpsData getGpsByPhone(String phone) {
        return gpsServiceMapper.getGpsByPhone(phone);
    }

    @Override
    public void updateGpsStatus(String address, Integer port, String status) {
        gpsServiceMapper.updateGpsStatus(address, port, status);
    }

    @Override
    public Map<String, GpsData> updateCacheListGpsData(GpsData data) {

        Map<String, GpsData> mapList = this.cacheListGpsData(data
                .getCompanyId());

        if (null == mapList) {
            mapList = new HashMap<String, GpsData>();
        }
        mapList.put(data.getPhone(), data);
        String key = RedisConst.buildKey(data.getCompanyId(),
                "KEY_GPS_DATA");

        redisUtil.set(key, mapList);
        return mapList;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Map<String, GpsData> cacheListGpsData(String companyId) {
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getDefaultCompanyId();
        }
        String key = RedisConst.buildKey(companyId,
                "KEY_GPS_DATA");
        Map<String, GpsData> result = (Map<String, GpsData>) redisUtil.get(key);
        if (null == result) {
            log.error("当前KEY={}没有获取到数据！", key);
        }
        return result;
    }

    @Override
    public Map<String, GpsLocationData> updateCacheLocationData(GpsLocationData data) {
        if (StringUtils.isEmpty(data.getCompanyId())) {
            data.setCompanyId(ContextUtil.getDefaultCompanyId());
        }
        Map<String, GpsLocationData> mapList = this.cacheListLocationData(data
                .getCompanyId());

        if (null == mapList) {
            mapList = new HashMap<String, GpsLocationData>();
        }
        mapList.put(data.getPhone(), data);
        String key = RedisConst.buildKey(data.getCompanyId(),
                "KEY_GPS_LOCATION_DATA");
        redisUtil.set(key, mapList);
        return mapList;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Map<String, GpsLocationData> cacheListLocationData(String companyId) {
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getDefaultCompanyId();
        }
        String key = RedisConst.buildKey(companyId,
                "KEY_GPS_LOCATION_DATA");
        Map<String, GpsLocationData> result = (Map<String, GpsLocationData>) redisUtil.get(key);
        if (null == result) {
            log.error("当前KEY={}没有获取到数据！", key);
        }
        return result;
    }

    @Override
    public void setCacheGpsData(String companyId, List<OAGps> list) {
        if (null == list || list.isEmpty()) {
            return;
        }

        Map<String, GpsData> gpsDataMap = new HashMap<>();
        GpsData gpsData = new GpsData();
        for (OAGps oaGps : list) {
            BeanUtils.copyProperties(oaGps, gpsData);
            gpsDataMap.put(gpsData.getPhone(), gpsData);
        }

        String key = RedisConst
                .buildKey(companyId, "KEY_GPS_DATA");
        redisUtil.set(key, gpsDataMap);
    }

    @Override
    public void updateGpsRecord(GpsLocationData data) {
        Map<String, Long> timeData = this.cacheListTimeData(data.getCompanyId());
        if (timeData == null || timeData.get(data.getPhone()) == null) {
            gpsServiceMapper.addGpsRecord(data);
            this.updateCacheTimeData(data);
        } else {
            if (timeData.get(data.getPhone()) != null) {
                long time = data.getUpdateTime().getTime() - timeData.get(data.getPhone());
                //时间差大于5分钟则往数据库存储一次
                if (time > 1000 * 60 * 5) {
                    gpsServiceMapper.addGpsRecord(data);
                    this.updateCacheTimeData(data);
                }
            }
        }
    }

    @Override
    public Map<String, Long> updateCacheTimeData(GpsLocationData data) {
        if (StringUtils.isEmpty(data.getCompanyId())) {
            data.setCompanyId(ContextUtil.getDefaultCompanyId());
        }
        Map<String, Long> mapList = this.cacheListTimeData(data
                .getCompanyId());

        if (null == mapList) {
            mapList = new HashMap<String, Long>();
        }
        mapList.put(data.getPhone(), data.getUpdateTime().getTime());
        String key = RedisConst.buildKey(data.getCompanyId(),
                "KEY_GPS_TIME_DATA");
        redisUtil.set(key, mapList);
        return mapList;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Map<String, Long> cacheListTimeData(String companyId) {
        if (StringUtils.isEmpty(companyId)) {
            companyId = ContextUtil.getDefaultCompanyId();
        }
        String key = RedisConst.buildKey(companyId,
                "KEY_GPS_TIME_DATA");
        Map<String, Long> result = (Map<String, Long>) redisUtil.get(key);
        if (null == result) {
            log.error("当前KEY={}没有获取到数据！", key);
        }
        return result;
    }

    @SuppressWarnings("unchecked")
    @Override
    public GpsData getCacheBySerialNum(String companyId, String serialNum) {
        String key = RedisConst.buildKey(companyId, "KEY_GPS_DATA");
        Map<String, GpsData> data = (Map<String, GpsData>) redisUtil.get(key);
        if (null == data) {
            log.error("GPS设备注册信息：没有获取到缓存信息，KEY={}", key);
            return null;
        }

        for (String s : data.keySet()) {
            if (data.get(s).getSn().equals(serialNum)) {
                return data.get(s);
            }
        }
        return null;
    }

    @Override
    public List<AssetData> getAsset(String companyId) {
        return gpsServiceMapper.getAsset(companyId);
    }
}