package com.moral.service.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.annotation.Resource;
import javax.validation.constraints.NotNull;

import com.alibaba.fastjson.TypeReference;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.moral.common.bean.Constants;
import com.moral.common.bean.PageBean;
import com.moral.common.bean.PageResult;
import com.moral.common.exception.BusinessException;
import com.moral.common.util.ExampleUtil;
import com.moral.common.util.RedisUtils;
import com.moral.common.util.ValidateUtil;
import com.moral.entity.Device;
import com.moral.entity.DeviceProperty;
import com.moral.mapper.DeviceMapper;
import com.moral.mapper.DevicePropertyMapper;
import com.moral.mapper.DeviceVersionMapper;
import com.moral.mapper.DictionaryDataMapper;
import com.moral.mapper.MonitorPointMapper;
import com.moral.mapper.OrganizationMapper;
import com.moral.service.AccountService;
import com.moral.service.DeviceService;
import com.moral.util.TkMybatisUtils;

import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;
import tk.mybatis.mapper.entity.Example;

@Service
public class DeviceServiceImpl implements DeviceService {
    private static Logger log = Logger.getLogger(DeviceServiceImpl.class);
    //-----------------------redis key前缀-开始---------------------------------
    private static String AlARM = "alarm";//警报阀值储存key前缀
    private static String ADJUST = "adjust";//校准值存储key前缀
    private static String DEVICE = "device";//设备信息数据key前缀
    private static String STATE = "state";//设备实时状态key前缀
    private static String DATA = "data";//设备实时数据key前缀

    //-----------------------redis key前缀-结束---------------------------------
    private String keysConnect(String... keys) {
        StringBuilder key = new StringBuilder(keys[0]);
        for (int i = 1; i < keys.length; i++) {
            key.append("_");
            key.append(keys[i]);
        }
        return key.toString().toLowerCase();
    }

    @Resource
    private DeviceMapper deviceMapper;
    @Resource
    private MonitorPointMapper monitorPointMapper;
    @Resource
    private AccountService accountService;
    private Class ENTITY_CLASS = Device.class;
    @Resource
    OrganizationMapper orgMapper;
    @Resource
    DeviceVersionMapper deviceVersionMapper;
    @Resource
    RedisUtils redisUtils;
    @Resource
    OrganizationMapper organizationMapper;
    @Resource
    DictionaryDataMapper dictionaryDataMapper;

    @Override
    public Map<String, Object> getDeviceStatesByAccount(Map<String, Object> parameters) {
        ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");
        Map<String, Object> result = new HashMap<String, Object>();
        accountService.setOrgIdsByAccount(parameters);
        List<Map<String, Object>> list = deviceMapper.getDeviceStatesByAccount(parameters);
        Long all = 0L, normal = 0L, abnormal = 0L, stop = 0L;
        for (Map<String, Object> map : list) {
            Long count = (Long) map.get("count");
            all += count;
            switch (Integer.valueOf((String) map.get("state"))) {
                case 0:
                    normal = count;
                    break;
                case 4:
                    stop = count;
                    break;
                default:
                    abnormal += count;
            }
        }
        result.put("all", all);
        result.put("normal", normal);
        result.put("abnormal", abnormal);
        result.put("stop", stop);
        return result;
    }

    @Override
    @Transactional
    public void saveOrUpdateDevice(Device device) {
        ValidateUtil.notNull(device, "param.is.null");
        ValidateUtil.notEmpty(device.getMac(), "param.is.null");
        Device queryDevice = new Device();
        queryDevice.setMac(device.getMac());
        queryDevice = deviceMapper.selectOne(queryDevice);
        Date operateDate = new Date();
        device.setInstallTime(operateDate);
        if (ObjectUtils.isEmpty(queryDevice)) {
            device.setCreateTime(operateDate);
            device.setState("4");
            device.setIsDelete(Constants.IS_DELETE_FALSE);
            deviceMapper.insertSelective(device);
        } else {
            device.setId(queryDevice.getId());
            deviceMapper.updateByPrimaryKeySelective(device);
        }
        //刷新redis里的信息
        refreshDeviceInRedis(device.getMac());
    }

    @Override
    public List<Device> getInstallDevicesByOperateUser(Integer uid, Integer pageIndex, Integer pageSize) {
        ValidateUtil.notNull(uid, "param.is.null");
        Device device = new Device();
        device.setOperateUserId(uid);
        PageHelper.startPage(pageIndex, pageSize, false);
        List<Device> devices = deviceMapper.select(device);
        return devices;
    }

    /**
     * @param mac
     * @param fromCache
     * @return 包含组织数组
     */
    @Override
    public Device getDeviceByMac(String mac, boolean fromCache) {
        if (fromCache) {
            Device device = getDeviceFromRedis(mac);
            if (device == null) {
                device = deviceMapper.selectWithOrgIdsByMac(mac);
            }
            return device;
        } else {
            return deviceMapper.selectWithOrgIdsByMac(mac);
        }

    }

    /**
     * 默认会从缓存取
     *
     * @param mac
     * @return
     */
    @Override
    public Device getDeviceByMac(String mac) {

        return getDeviceByMac(mac, true);
    }

    /*
     * 获取报警阀值在redis里的key
     */
    private String getDeviceKey(String mac) {
        return keysConnect(DEVICE, mac);
    }

    //	/*
//	 * 将校正值存入redis方法组 开始
//	 */
//	private void setDeviceToRedis(String mac,Device device){
//		String key = getDeviceKey(mac);
//		Device simpleDevice = new Device();
//		simpleDevice.setId(device.getId());// id
//		simpleDevice.setName(device.getName());// name
//		simpleDevice.setAddress(device.getAddress());// address
//		simpleDevice.setDeviceVersionId(device.getDeviceVersionId());// version
//		simpleDevice.setMac(device.getMac()); // mac
//		simpleDevice.setMonitorPointId(device.getMonitorPointId());// 监控地id
//		simpleDevice.setOrganizationIds(device.getOrganizationIds());// 组织数组
//		simpleDevice.setDeviceVersion(device.getDeviceVersion());
//		redisUtils.set(key,simpleDevice);
//	}
    private Device getDeviceFromRedis(String mac) {
        String key = getDeviceKey(mac);
        return redisUtils.get(key, Device.class);
    }

    /**
     * @param params map里 包括 组织id和4个坐标点
     * @return 返回未删除结果集
     */
    @Override
    public List<Device> query(Map<String, Object> params) {
        List<Integer> dv = deviceMapper.getHasWindDirAndWindSpeedDeviceVersion();
        Object orgIdObj = params.get("orgId");
        List<Device> deviceList = null;
        if (orgIdObj != null) {
            Integer orgId = Integer.parseInt(orgIdObj.toString());
            List<Integer> orgIds = orgMapper.selectLowerOrgIds(orgId);
            params.put("orgIds", orgIds);
            deviceList = deviceMapper.selectByMap(params);
            // loadDeviceState(deviceList);
        }
      for(Device d:deviceList){
            if(dv.contains(d.getDeviceVersionId())){
                d.setHasWindInfo(true);
            }else{
                d.setHasWindInfo(false);
            }
      }
        return deviceList;
    }

    /**
     * 根据组织id和设备名称 分页查询设备
     *
     * @param orgId
     * @param deviceName
     * @param pageSize
     * @param pageNo
     * @return 返回未删除结果
     */
    @Override
    public PageResult query(Integer orgId, String deviceName, Integer pageSize, Integer pageNo) {
        List<Integer> orgIds = orgMapper.selectLowerOrgIds(orgId);
        if (!ObjectUtils.isEmpty(pageSize) && !ObjectUtils.isEmpty(pageNo)) {
            PageHelper.startPage(pageNo, pageSize);
        }
        String state = null;
        switch (deviceName) {
            case "正常":
                state = "0";
                deviceName = null;
                break;
            case "轻度":
                state = "1";
                deviceName = null;
                break;
            case "中度":
                state = "2";
                deviceName = null;
                break;
            case "重度":
                state = "3";
                deviceName = null;
                break;
            case "维保":
                state = "4";
                deviceName = null;
                break;
        }
        List<Device> list = deviceMapper.selectByOrgIdAndDevName(orgId, orgIds, state, deviceName);
        //从redis里取状态
        loadDeviceState(list);
        if (list instanceof Page) {
            return new PageResult(((Page) list).getTotal(), list);
        }
        return new PageResult(null, list);
    }

    /**
     * 根据组织id和监控点id 分页查询设备
     *
     * @param orgId
     * @param mpId
     * @param pageSize
     * @param pageNo
     * @return 返回未删除结果
     */
    @Override
    public PageResult query(Integer orgId, Integer mpId, Integer pageSize, Integer pageNo) {
        List<Integer> orgIds = orgMapper.selectLowerOrgIds(orgId);
        if (!ObjectUtils.isEmpty(pageSize) && !ObjectUtils.isEmpty(pageNo)) {
            PageHelper.startPage(pageNo, pageSize);
        }
        List<Device> list = deviceMapper.selectByOrgIdAndMpId(orgId, orgIds, mpId);
        //从redis里取状态
        loadDeviceState(list);
        if (list instanceof Page) {
            return new PageResult(((Page) list).getTotal(), list);
        }
        return new PageResult(null, list);
    }

    private void loadDeviceState(List<Device> list) {
        //从redis里取状态
        list.stream().map(device -> {
            String mac = device.getMac();
            if (!StringUtils.isBlank(mac)) {
                String state = getSateFromRedis(device.getMonitorPointId(), mac.toLowerCase());
                device.setState(state);
            } else {
                device.setState(Constants.DEVICE_STATE_OFFLINE);
            }
            return device;
        }).count();
    }

    private String getSateFromRedis(Integer mpId, String mac) {

        Map<String, String> stateMap = getStateMapFromRedis(mpId, mac);
        String state = null;
        if (stateMap != null) {
            state = stateMap.get("state");
        }
        state = state == null ? Constants.DEVICE_STATE_OFFLINE : state;
        return state;
    }

    public Map<String, String> getStateMapFromRedis(Integer mpId, String mac) {
        StringBuilder key = new StringBuilder();
        //拼凑key
        key.append("state_").append(mpId).append("_").append(mac);
        return redisUtils.get(key.toString(), new TypeReference<Map<String, String>>() {
        });
    }

    private Device getDeviceWithOrgIdsByMac(String mac) {
        String key = "device_" + mac;
        Device device = redisUtils.get(key, Device.class);
        if (device == null) {
            device = deviceMapper.selectWithOrgIdsByMac(mac);
            if (device != null) {
                redisUtils.set(key, device);
            }
        }
        return device;
    }

    /**
     * 要在数据库更改后刷新
     * 刷新 redis 设备的信息,注意此处指删除不做更新。更新由task完成
     *
     * @param mac
     */
    private void refreshDeviceInRedis(String mac) {
        if (!StringUtils.isBlank(mac)) {
            String key = getDeviceKey(mac);
            redisUtils.remove(key);
        } else {
            log.warn("param mac is null in method [refreshDeviceInRedis]");
        }
    }

    @Override
    public int countByExample(PageBean pageBean) {
        Example example = ExampleUtil.generateExample(ENTITY_CLASS, pageBean);
        TkMybatisUtils.addDeletesToExample(example);
        return deviceMapper.selectCountByExample(example);
    }

    @Override
    public PageBean queryByPageBean(PageBean pageBean) {
        Example example = ExampleUtil.generateExample(ENTITY_CLASS, pageBean);
//		addDeletesToExample(example);
        if (pageBean.getPageSize() > 0) {
            PageHelper.startPage(pageBean.getPageIndex(), pageBean.getPageSize());
        }
        List<Device> deviceList = deviceMapper.selectWithRelationData(example);
        return new PageBean(deviceList);
    }

    @Override
    public void deleteByIds(Integer[] ids) {
        Device device = new Device();
        device.setIsDelete(Constants.IS_DELETE_TRUE);
        if (ids != null && ids.length > 0) {
            Example example = new Example(ENTITY_CLASS);
            example.or().andIn("id", Arrays.asList(ids));
            if (ids.length == 1) {
                device.setId(ids[0]);
                deviceMapper.updateByPrimaryKeySelective(device);
            } else {
                deviceMapper.updateByExampleSelective(device, example);
            }
            List<Device> deviceList = deviceMapper.selectByExample(example);
            List<String> adjustAndDeviceKeys = deviceList.stream().collect(
                    ArrayList<String>::new,
                    (list, dev) -> {
                        if (!StringUtils.isBlank(dev.getMac())) {
                            list.add("device_" + dev.getMac());
                            list.add("adjust_" + dev.getMac());
                        }
                    },
                    (oList, nList) -> {
                        oList.addAll(nList);
                    }
            );
            redisUtils.remove(adjustAndDeviceKeys.toArray(new String[adjustAndDeviceKeys.size()]));
        }
    }

    @Override
    @Transactional
    public void addOrModify(Device device) {
        try {
            //mac 转小写
            if (!StringUtils.isBlank(device.getMac())) {
                device.setMac(device.getMac().toLowerCase());
            }
            if (device.getId() != null) {
                deviceMapper.updateByPrimaryKeySelective(device);
            } else {
                Device deviceQuery = new Device();
                deviceQuery.setMac(device.getMac());
                Device deviceResult = deviceMapper.selectOne(deviceQuery);
                if (deviceResult != null) {
                    device.setId(deviceResult.getId());
                    deviceMapper.updateByPrimaryKeySelective(device);
                } else {
                    device.setState(Constants.DEVICE_STATE_OFFLINE);
                    device.setIsDelete(Constants.IS_DELETE_FALSE);
                    deviceMapper.insertSelective(device);
                }
            }
            //刷新redis里设备信息
            refreshDeviceInRedis(device.getMac());
        } catch (Exception ex) {
            throw ex;
        }
    }

    @Override
    public List<Map> countByTimes(Date start, Date end, String format) {
        if (start == null || end == null || StringUtils.isBlank(format)) {
            log.error("some  params is null");
            throw new BusinessException("some  params is null");
        }
        return deviceMapper.countByTimes(start, end, format);
    }

    @Override
    public List<Device> getDevicesByMonitorPointId(Integer monitorPointId) {
        Device device = new Device();
        device.setMonitorPointId(monitorPointId);
        device.setIsDelete(Constants.IS_DELETE_FALSE);
        List<Device> devices = deviceMapper.select(device);
        for (Device device2 : devices) {
            DeviceProperty deviceProperty = devicePropertyMapper.selectByPrimaryKey(device2.getId());
            device2.setDeviceProperty(deviceProperty);
        }
        return devices;
    }

    /**
     * 返回map{mac：，state：}
     *
     * @param macList
     * @return
     */
    @Override
    public List<Map<String, String>> queryDevicesState(List<String> macList, Boolean withData) {
        List<Map<String, String>> list = macList.stream().map(mac -> {
            Map<String, String> resultMap = new HashMap<>();
            if (!StringUtils.isBlank(mac)) {
                mac = mac.toLowerCase();
                Device device = getDeviceWithOrgIdsByMac(mac);
                Map<String, String> stateMap = getStateMapFromRedis(device.getMonitorPointId(), mac);
                if (!MapUtils.isEmpty(stateMap)) {
                    resultMap.putAll(stateMap);
                } else {
                    resultMap.put("state", Constants.DEVICE_STATE_OFFLINE);
                    resultMap.put("mac", mac);
                }
                //添加data
                if (BooleanUtils.isTrue(withData)) {
                    String dataKey = "data_" + mac;
                    Map<String, String> dataMap = redisUtils.get(dataKey, new TypeReference<Map<String, String>>() {
                    });
                    if (!MapUtils.isEmpty(dataMap)) {
                        resultMap.putAll(dataMap);
                    }
                }
            }
            return resultMap;
        }).collect(Collectors.toList());
        return list;
    }

    @Override
    public Device queryById(Integer id) {
        return deviceMapper.selectByPrimaryKey(id);
    }

    @Override
    public List<Device> getDevicesByProfessionId(Map<String, Object> parameters) {

        return deviceMapper.getDevicesByProfession(parameters);
    }

    @Override
    public List<Device> getDevicesByOrganizationId(Map<String, Object> parameters) {
        ValidateUtil.notNull(parameters.get("organizationId"), "param.is.null");
        return deviceMapper.getDevicesByOrganizationId(parameters);
    }

    @Override
    public Map<String, Long> queryDeviceStateSummary(@NotNull Integer orgId) {
        Map<String, Object> params = new HashMap<>();
        if (!dictionaryDataMapper.isSupperOrgId(orgId)) {
            List<Integer> orgIds = organizationMapper.selectLowerOrgIds(orgId);
            params.put("orgIds", orgIds);
        }
        List<Map<String, Object>> list = deviceMapper.getDeviceStatesByAccount(params);
        Long all = 0L, normal = 0L, abnormal = 0L, stop = 0L;
        for (Map<String, Object> map : list) {
            Long count = (Long) map.get("count");
            all += count;
            switch (Integer.valueOf((String) map.get("state"))) {
                case 0:
                    normal = count;
                    break;
                case 4:
                    stop = count;
                    break;
                default:
                    abnormal += count;
            }
        }
        Map<String, Long> result = new HashMap<>();
        result.put("all", all);
        result.put("normal", normal);
        result.put("abnormal", abnormal);
        result.put("stop", stop);
        return result;
    }

    @Resource
    private DevicePropertyMapper devicePropertyMapper;

    @Override
    @Transactional
    public void saveOrUpdate(Device device, DeviceProperty deviceProperty) {
        device.setMac(device.getMac().toLowerCase());
        if (ObjectUtils.isEmpty(device.getId())) {
            device.setState(Constants.DEVICE_STATE_OFFLINE);
            device.setIsDelete(Constants.IS_DELETE_FALSE);
            deviceMapper.insertSelective(device);
            deviceProperty.setId(device.getId());
        } else {
            deviceMapper.updateByPrimaryKeySelective(device);
            devicePropertyMapper.deleteByPrimaryKey(deviceProperty);
        }
        devicePropertyMapper.insertSelective(deviceProperty);
        refreshDeviceInRedis(device.getMac());

    }

    @Override
    public PageBean getDeviceList(PageBean pageBean) {
        Example example = ExampleUtil.generateExample(ENTITY_CLASS, pageBean);
        if (pageBean.getPageSize() > 0) {
            PageHelper.startPage(pageBean.getPageIndex(), pageBean.getPageSize());
        }
        List<Device> deviceList = deviceMapper.getDeviceList(example);
        return new PageBean(deviceList);
    }

    @Override
    public void offLinToMaintenance(Map<String, Object> parameters) {
        ValidateUtil.notNull(parameters.get("id"), "param.is.null");
        ValidateUtil.notNull(parameters.get("old_state"), "param.is.null");
        ValidateUtil.notNull(parameters.get("new_state"), "param.is.null");
        int count = 0;
        if (Constants.DEVICE_STATE_OFFLINE.equals(parameters.get("old_state")) && Constants.DEVICE_STATE_MAINTENANCE.equals(parameters.get("new_state"))) {
            Device device = new Device();
            Example example = new Example(ENTITY_CLASS);
            example.and().andEqualTo("id", new Integer(parameters.get("id").toString())).andEqualTo("state", Constants.DEVICE_STATE_OFFLINE);
            device.setState(Constants.DEVICE_STATE_MAINTENANCE);
            count = deviceMapper.updateByExampleSelective(device, example);
        }
        if (count == 0) {
            throw new BusinessException("参数不合法！");
        }
    }

    @Override
    public void saveOrUpdate4Mobile(Device device, DeviceProperty deviceProperty) {
        device.setMac(device.getMac().toLowerCase());
        Device selectDevice = new Device();
        selectDevice.setMac(device.getMac());
        selectDevice = deviceMapper.selectOne(selectDevice);
        if (ObjectUtils.isEmpty(selectDevice)) {
            device.setState(Constants.DEVICE_STATE_OFFLINE);
            device.setIsDelete(Constants.IS_DELETE_FALSE);
            deviceMapper.insertSelective(device);
            deviceProperty.setId(device.getId());
            devicePropertyMapper.insertSelective(deviceProperty);
        } else {
            device.setId(selectDevice.getId());
            deviceMapper.updateByPrimaryKeySelective(device);
            deviceProperty.setId(selectDevice.getId());
            devicePropertyMapper.selectByPrimaryKey(selectDevice.getId());
            if (ObjectUtils.isEmpty(devicePropertyMapper.selectByPrimaryKey(deviceProperty.getId()))) {
                devicePropertyMapper.insertSelective(deviceProperty);
            } else {
                devicePropertyMapper.updateByPrimaryKeySelective(deviceProperty);
            }

        }
        refreshDeviceInRedis(device.getMac());


    }

    @Override
    public String getLimitDataByDevice(Map<String, Object> parameters) {
        // TODO Auto-generated method stub
        return deviceMapper.getLimitDataByDevice(parameters);
    }

    //按经度升序排序，通过mac地址找到相邻经度的第二个点位置
    @Override
    public Device getDeviceByLongitudeAsc(String mac) {
        Example example = new Example(Device.class);
        example.setOrderByClause("longitude ASC");
        List<Device> deviceList = deviceMapper.selectByExample(example);
        for (int i = 0; i < deviceList.size(); i++) {
            if (mac.equals(deviceList.get(i).getMac())) {
                Device deviceSecond = deviceList.get(i + 1);
                return deviceSecond;
            }
        }
        return null;
    }

    @Override
    public List<String> getMacsByOrganizationId(List<Object> organizationIdList) {
        return deviceMapper.getMacsByOrganizationId(organizationIdList);
    }

    @Override
    public List<Device> getDeviceById1(int id) {
        return deviceMapper.getDeviceById1(id);
    }

    @Override
    public List<Device> getDeviceById2(int id) {
        return deviceMapper.getDeviceById2(id);
    }

    @Override
    public List<Device> getDeviceById3(int id) {
        return deviceMapper.getDeviceById3(id);
    }
}