package com.moral.service.impl;

import java.util.*;
import java.util.stream.Collectors;

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

import com.alibaba.fastjson.JSONArray;
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.DeviceAndWind;
import com.moral.entity.DeviceProperty;
import com.moral.entity.MonitorPoint;
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.service.MonitorPointService;
import com.moral.util.LatLngTransformation;
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;
    @Resource
    private MonitorPointService monitorPointService ;

    @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");
        String regionCode = params.get("regionCode").toString();
        List<Device> deviceList = null;
        if (orgIdObj != null) {
            Integer orgId = Integer.parseInt(orgIdObj.toString());
            List<Integer> orgIds = orgMapper.selectLowerOrgIds(orgId);
            //剔除沧州地图页面非公司设备图标
            if (regionCode.startsWith("1309")&&orgIdObj.toString().equals("5")) {
                orgIds = new ArrayList<>();
                Collections.addAll(orgIds, 60, 65, 159, 165, 166);
                deviceList = deviceMapper.selectByMap(params);
                Iterator<Device> iter = deviceList.iterator();
                while (iter.hasNext()) {
                    Device device = iter.next();
                    Integer mpId = device.getMonitorPointId();
                    Integer oid = monitorPointService.byIdGetMonitorPoint(mpId).getOrganizationId();
                    if (!orgIds.contains(oid)) {
                        iter.remove();
                    } else {
                        if (orgId == 60) {
                            if (mpId != 56) {
                                iter.remove();
                            }
                        } else if (orgId == 65) {
                            if (mpId != 83 && mpId != 84) {
                                iter.remove();
                            }
                        }
                    }
                }
            }else {
                params.put("orgIds", orgIds);
                deviceList = deviceMapper.selectByMap(params);
            }
            // loadDeviceState(deviceList);
        }
        Example deviceExample = new Example(Device.class);//实例化
        Example.Criteria deviceCriteria = deviceExample.createCriteria();
        deviceCriteria.orEqualTo("isDelete", Constants.IS_DELETE_FALSE);
        List<Device> devicesInfo = deviceMapper.selectByExample(deviceExample);
        Example monitorExample = new Example(MonitorPoint.class);//实例化
        Example.Criteria monitorCriteria = monitorExample.createCriteria();
        monitorCriteria.orEqualTo("isDelete", Constants.IS_DELETE_FALSE);
        List<MonitorPoint> monitorsInfo = monitorPointMapper.selectByExample(monitorExample);
        for (Device d : deviceList) {
            if (dv.contains(d.getDeviceVersionId())) {
                d.setHasWindInfo(true);
            } else {
                d.setHasWindInfo(false);
            }
            for (Device temp : devicesInfo) {
                if (d.getId().equals(temp.getId())) {
                    d.setState(temp.getState());
                }
            }
            for (MonitorPoint mp : monitorsInfo) {
                if (d.getMonitorPointId().equals(mp.getId())) {
                    d.setMonitorPoint(mp);
                }
            }
        }
        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);
    }

    @Override
    public List<Device> queryDevice(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.selectDevicesAll(params);
        }
        List<Device> deviceListHasWind = new ArrayList<>();
        for (Device d : deviceList) {
            if (dv.contains(d.getDeviceVersionId())) {
                deviceListHasWind.add(d);
            }
        }
        return deviceListHasWind;
    }

    @Override
    public Map<String, Object> getAllFieldByMac(Map<String, Object> parameters) {
        Map<String, Object> deviceMap = deviceMapper.selectAllFieldByMac(parameters);
        return deviceMap;
    }

    @Override
    public List<DeviceAndWind> getAllDevice() {
        return deviceMapper.getAllDevice();
    }

    @Override
    public List<String> getAllMac() {
        return deviceMapper.getAllMac();
    }

    @Override
    public Device byMacGetDevice(String mac) {
        return deviceMapper.byMacGetDevice(mac);
    }

    @Override
    public List byMonitorIdGetDeviceAndWind(String id, String tab) {
        List<DeviceAndWind> deviceAndWinds = deviceMapper.byMonitorIdGetDeviceAndWind(Integer.parseInt(id), tab);
        System.out.println(deviceAndWinds);
        System.out.println(deviceAndWinds);
        List loList = new ArrayList();
        List laList = new ArrayList();
        Double U = 0.0;
        Double V = 0.0;
        List list = new ArrayList();
        for (DeviceAndWind andWind : deviceAndWinds) {
            Double lo = andWind.getLongitude();
            Double la = andWind.getLatitude();
            List tranlist = LatLngTransformation.Convert_BD09_To_GCJ02(la, lo);
            Double transLo = (Double) tranlist.get(0);
            Double transLa = (Double) tranlist.get(1);
            loList.add(transLo);
            laList.add(transLa);
        }
        Double loma = 0.0;
        Double lomi = 0.0;
        Double lama = 0.0;
        Double lami = 0.0;
        if (loList.size() > 0) {
            loma = (Double) Collections.max(loList);
            lomi = (Double) Collections.min(loList);
        }
        if (laList.size() > 0) {
            lama = (Double) Collections.max(laList);
            lami = (Double) Collections.min(laList);
        }
        Map laLaMap = new HashMap();
        laLaMap.put("maxLo", loma);
        laLaMap.put("minLo", lomi);
        laLaMap.put("maxLa", lama);
        laLaMap.put("minLa", lami);

        Double lo1 = lomi - 250 * 0.00001141;
        Double lo2 = loma + 250 * 0.00001141;
        Double la2 = lami - 250 * 0.00000899;
        Double la1 = lama + 250 * 0.00000899;

        Double dx = 0.00001141 * 20;
        Double dy = 0.00000899 * 20;
        int nx = (int) Math.floor((lo2 - lo1) / dx);
        int ny = (int) Math.floor((la1 - la2) / dy);
        String header1 = "\"" + "header" + "\"" + ": " + "{" + "\"" + "parameterUnit" + "\"" + ": " + "\"" + "m/s" + "\"" + ", " + "\"" + "parameterNumber" + "\"" + ": " + 2 +
                ", " + "\"" + "dx" + "\"" + ": " + dx + ", " + "\"" + "dy" + "\"" + ": " + dy +
                ", " + "\"" + "parameterNumberName" + "\"" + ": " + "\"" + "eastward_wind" + "\"" + ", " + "\"" + "la1" + "\"" + ": " + la1 + ", " + "\"" + "la2" + "\"" + ": " + la2 +
                ", " + "\"" + "parameterCategory" + "\"" + ": " + 2 + ", " + "\"" + "lo1" + "\"" + ": " + lo1 + ", " + "\"" + "lo2" + "\"" + ": " + lo2 +
                ", " + "\"" + "nx" + "\"" + ": " + nx + ", " + "\"" + "ny" + "\"" + ": " + ny + ", " + "\"" + "refTime" + "\"" + ": " + "\"" + "2020-07-22 23:00:00" + "\"" + "}";

        String header2 = "\"" + "header" + "\"" + ": " + "{" + "\"" + "parameterUnit" + "\"" + ": " + "\"" + "m/s" + "\"" + ", " + "\"" + "parameterNumber" + "\"" + ": " + 3 +
                ", " + "\"" + "dx" + "\"" + ": " + dx + ", " + "\"" + "dy" + "\"" + ": " + dy +
                ", " + "\"" + "parameterNumberName" + "\"" + ": " + "\"" + "eastward_wind" + "\"" + ", " + "\"" + "la1" + "\"" + ": " + la1 + ", " + "\"" + "la2" + "\"" + ": " + la2 +
                ", " + "\"" + "parameterCategory" + "\"" + ": " + 2 + ", " + "\"" + "lo1" + "\"" + ": " + lo1 + ", " + "\"" + "lo2" + "\"" + ": " + lo2 +
                ", " + "\"" + "nx" + "\"" + ": " + nx + ", " + "\"" + "ny" + "\"" + ": " + ny + ", " + "\"" + "refTime" + "\"" + ": " + "\"" + "2020-07-22 23:00:00" + "\"" + "}";

        List<Double> uList = new ArrayList<Double>();
        List<Double> vList = new ArrayList<Double>();
        int x = 0;
        int y = 0;
        List<Map> mapList = new ArrayList<Map>();

        for (int j = 0; j < deviceAndWinds.size(); j++) {
            Map<String, Double> map = new HashMap<String, Double>();
            Double windDir = deviceAndWinds.get(j).getWindDir();

            Double windSpeed = deviceAndWinds.get(j).getWindSpeed();
            if (windDir == null) {
                windDir = 0.0;
                windSpeed = 0.0;
            }
            Double tvoc = deviceAndWinds.get(j).getTVoc();

            List tranlist = LatLngTransformation.Convert_BD09_To_GCJ02(deviceAndWinds.get(j).getLatitude(), deviceAndWinds.get(j).getLongitude());
            Double transLo = (Double) tranlist.get(0);
            Double transLa = (Double) tranlist.get(1);
            if (tvoc == null) {
                tvoc = 0.0;
            }
            Double dir = (360.0 - (windDir+180.0) * Math.PI / 180.0);

            U = windSpeed * Math.cos(dir);
            V = windSpeed * Math.sin(dir);
            map.put("lo", transLo);
            map.put("la", transLa);
            map.put("U", U);
            map.put("V", V);
            mapList.add(map);
        }
        for (int i = 0; i < mapList.size(); i++) {
            Double lo = (Double) mapList.get(i).get("lo");
            Double la = (Double) mapList.get(i).get("la");
            x = (int) Math.floor((lo - lo1) / dx);
            y = Math.abs((int) Math.floor((la - la1) / dy));
            //y=Math.floor(Math.abs(la-la1)/dy);
            U = (Double) mapList.get(i).get("U");
            V = (Double) mapList.get(i).get("V");
            if (i == 0) {
                for (int j = 0; j < nx * ny; j++) {
                    uList.add(0.0);
                    vList.add(0.0);
                }
            }
            for (int j = 0; j < nx * ny; j++) {
                if (i == 0) {
                    if ((y >= 2 && j == (y) * nx + x)) {
                        int k;
                        for (k = j - 2 * nx; k <= j + 2 * nx; k = k + nx) {
                            uList.set(k, U);
                            uList.set(k - 1, U);
                            uList.set(k - 2, U);
                            uList.set(k + 1, U);
                            uList.set(k + 2, U);
                            vList.set(k, V);
                            vList.set(k - 1, V);
                            vList.set(k - 2, V);
                            vList.set(k + 1, V);
                            vList.set(k + 2, V);
                        }
                    }
                } else {
                    if (y >= 1 && j == y * nx + x) {
                        int k;
                        for (k = j - 2 * nx; k <= j + 2 * nx; ) {
                            uList.set(k - 1, U);
                            uList.set(k - 2, U);
                            uList.set(k + 1, U);
                            uList.set(k + 2, U);
                            vList.set(k - 1, V);
                            vList.set(k - 2, V);
                            vList.set(k + 1, V);
                            vList.set(k + 2, V);
                            k = k + nx;
                        }
                        uList.set(j, U);
                        vList.set(j, V);
                    }
                }
            }
        }
        String uData = "\"" + "data" + "\"" + ": " + uList;
        String vData = "\"" + "data" + "\"" + ": " + vList;
        String s1 = "[" + "{" + header1 + ", " + uData + "}" + ", " + "{" + header2 + ", " + vData + "}" + "]";
        JSONArray jsonArray = JSONArray.parseArray(s1);
        MonitorPoint monitorPoint = monitorPointMapper.byIdGetMonitorPoint(Integer.parseInt(id));
        Double monitorLo = monitorPoint.getLongitude();
        Double monitorLa = monitorPoint.getLatitude();
        List transList = LatLngTransformation.Convert_BD09_To_GCJ02(monitorLa, monitorLo);
        Double transLo = (Double) transList.get(0);
        Double transLa = (Double) transList.get(1);
        list.add(jsonArray);
        list.add(transLo);
        list.add(transLa);
        list.add(laLaMap);
        return list;
    }

    @Override
    public List byMonitorIdGetDeviceAndWindSpecial(String id, String tab) {
        MonitorPoint monitorPoint = monitorPointMapper.byIdGetMonitorPoint(Integer.parseInt(id));
        Integer areaCode = monitorPoint.getAreaCode();
        String townCode = monitorPoint.getTownCode() + "";
        int monitorPointId = monitorPoint.getId();
        Map<String, Object> parm = new HashMap<>();
        List<DeviceAndWind> deviceAndWinds = new ArrayList<>();
        Double loma = 0.0;
        Double lomi = 0.0;
        Double lama = 0.0;
        Double lami = 0.0;

        int length = 1;
        int perdlen = 1;
        if (areaCode == 320581) {
            parm.put("areaCode", areaCode);
            List<Device> deviceList = deviceMapper.getDeviceByCode(parm);
            for (Device d : deviceList) {
                String mac = d.getMac();
                DeviceAndWind deviceAndWind = deviceMapper.byMacGetDeviceAndWind(mac, tab);
                if (deviceAndWind != null) {
                    deviceAndWinds.add(deviceAndWind);
                }
            }
            length = 8000;
            perdlen = 2200;
        } else if ((areaCode == 320583) && (townCode.equals("320583108000"))) {
            parm.put("townCode", townCode);
            List<Device> deviceList = deviceMapper.getDeviceByCode(parm);
            for (Device d : deviceList) {
                String mac = d.getMac();
                DeviceAndWind deviceAndWind = deviceMapper.byMacGetDeviceAndWind(mac, tab);
                if (deviceAndWind != null) {
                    deviceAndWinds.add(deviceAndWind);
                }
            }
            length = 2000;
            perdlen = 280;
        } else if (monitorPointId == 35) {
            DeviceAndWind deviceAndWind = deviceMapper.getDeviceAndWindByMac("898607b0101730392253", tab);
            DeviceAndWind deviceAndWind1 = deviceMapper.getDeviceAndWindByMac("p5dnd7a0392083", tab);
            deviceAndWinds.add(deviceAndWind);
            deviceAndWinds.add(deviceAndWind1);
            length = 2000;
            perdlen = 50;

        } else {
            deviceAndWinds = deviceMapper.byMonitorIdGetDeviceAndWind(Integer.parseInt(id), tab);
            length = 2000;
            perdlen = 80;
        }
        List loList = new ArrayList();
        List laList = new ArrayList();
        Double U = 0.0;
        Double V = 0.0;
        List list = new ArrayList();
        for (DeviceAndWind andWind : deviceAndWinds) {
            Double lo = andWind.getLongitude();
            Double la = andWind.getLatitude();
            List tranlist = LatLngTransformation.Convert_BD09_To_GCJ02(la, lo);
            Double transLo = (Double) tranlist.get(0);
            Double transLa = (Double) tranlist.get(1);
            loList.add(transLo);
            laList.add(transLa);
        }

        if (loList.size() > 0) {
            loma = (Double) Collections.max(loList);
            lomi = (Double) Collections.min(loList);
        }
        if (laList.size() > 0) {
            lama = (Double) Collections.max(laList);
            lami = (Double) Collections.min(laList);
        }
        Map laLaMap = new HashMap();
        laLaMap.put("maxLo", loma);
        laLaMap.put("minLo", lomi);
        laLaMap.put("maxLa", lama);
        laLaMap.put("minLa", lami);

        Double lo1 = lomi - length * 0.00001141;
        Double lo2 = loma + length * 0.00001141;
        Double la2 = lami - length * 0.00000899;
        Double la1 = lama + length * 0.00000899;

        Double dx = 0.00001141 * perdlen;
        Double dy = 0.00000899 * perdlen;
        int nx = (int) Math.floor((lo2 - lo1) / dx);
        int ny = (int) Math.floor((la1 - la2) / dy);
        String header1 = "\"" + "header" + "\"" + ": " + "{" + "\"" + "parameterUnit" + "\"" + ": " + "\"" + "m/s" + "\"" + ", " + "\"" + "parameterNumber" + "\"" + ": " + 2 +
                ", " + "\"" + "dx" + "\"" + ": " + dx + ", " + "\"" + "dy" + "\"" + ": " + dy +
                ", " + "\"" + "parameterNumberName" + "\"" + ": " + "\"" + "eastward_wind" + "\"" + ", " + "\"" + "la1" + "\"" + ": " + la1 + ", " + "\"" + "la2" + "\"" + ": " + la2 +
                ", " + "\"" + "parameterCategory" + "\"" + ": " + 2 + ", " + "\"" + "lo1" + "\"" + ": " + lo1 + ", " + "\"" + "lo2" + "\"" + ": " + lo2 +
                ", " + "\"" + "nx" + "\"" + ": " + nx + ", " + "\"" + "ny" + "\"" + ": " + ny + ", " + "\"" + "refTime" + "\"" + ": " + "\"" + "2020-07-22 23:00:00" + "\"" + "}";

        String header2 = "\"" + "header" + "\"" + ": " + "{" + "\"" + "parameterUnit" + "\"" + ": " + "\"" + "m/s" + "\"" + ", " + "\"" + "parameterNumber" + "\"" + ": " + 3 +
                ", " + "\"" + "dx" + "\"" + ": " + dx + ", " + "\"" + "dy" + "\"" + ": " + dy +
                ", " + "\"" + "parameterNumberName" + "\"" + ": " + "\"" + "eastward_wind" + "\"" + ", " + "\"" + "la1" + "\"" + ": " + la1 + ", " + "\"" + "la2" + "\"" + ": " + la2 +
                ", " + "\"" + "parameterCategory" + "\"" + ": " + 2 + ", " + "\"" + "lo1" + "\"" + ": " + lo1 + ", " + "\"" + "lo2" + "\"" + ": " + lo2 +
                ", " + "\"" + "nx" + "\"" + ": " + nx + ", " + "\"" + "ny" + "\"" + ": " + ny + ", " + "\"" + "refTime" + "\"" + ": " + "\"" + "2020-07-22 23:00:00" + "\"" + "}";

        List<Double> uList = new ArrayList<Double>();
        List<Double> vList = new ArrayList<Double>();
        int x = 0;
        int y = 0;
        List<Map> mapList = new ArrayList<Map>();

        for (int j = 0; j < deviceAndWinds.size(); j++) {
            Map<String, Double> map = new HashMap<String, Double>();
            Double windDir = deviceAndWinds.get(j).getWindDir();
            Double windSpeed = deviceAndWinds.get(j).getWindSpeed();
            if (windDir == null) {
                windDir = 0.0;
                windSpeed = 0.0;
            }
            Double tvoc = deviceAndWinds.get(j).getTVoc();

            List tranlist = LatLngTransformation.Convert_BD09_To_GCJ02(deviceAndWinds.get(j).getLatitude(), deviceAndWinds.get(j).getLongitude());
            Double transLo = (Double) tranlist.get(0);
            Double transLa = (Double) tranlist.get(1);
            if (tvoc == null) {
                tvoc = 0.0;
            }
            Double dir = (360.0 - (windDir+180.0) * Math.PI / 180.0);

            U = windSpeed * Math.cos(dir);
            V = windSpeed * Math.sin(dir);
            map.put("lo", transLo);
            map.put("la", transLa);
            map.put("U", U);
            map.put("V", V);
            mapList.add(map);
        }
        for (int i = 0; i < mapList.size(); i++) {
            Double lo = (Double) mapList.get(i).get("lo");
            Double la = (Double) mapList.get(i).get("la");
            x = (int) Math.floor((lo - lo1) / dx);
            y = Math.abs((int) Math.floor((la - la1) / dy));
            //y=Math.floor(Math.abs(la-la1)/dy);
            U = (Double) mapList.get(i).get("U");
            V = (Double) mapList.get(i).get("V");
            if (i == 0) {
                for (int j = 0; j < nx * ny; j++) {
                    uList.add(0.0);
                    vList.add(0.0);
                }
            }
            for (int j = 0; j < nx * ny; j++) {
                if (i == 0) {
                    if ((y >= 2 && j == (y) * nx + x)) {
                        int k;
                        for (k = j - 2 * nx; k <= j + 2 * nx; k = k + nx) {
                            uList.set(k, U);
                            uList.set(k - 1, U);
                            uList.set(k - 2, U);
                            uList.set(k + 1, U);
                            uList.set(k + 2, U);
                            vList.set(k, V);
                            vList.set(k - 1, V);
                            vList.set(k - 2, V);
                            vList.set(k + 1, V);
                            vList.set(k + 2, V);
                        }
                    }
                } else {
                    if (y >= 1 && j == y * nx + x) {
                        int k;
                        for (k = j - 2 * nx; k <= j + 2 * nx; ) {
                            uList.set(k - 1, U);
                            uList.set(k - 2, U);
                            uList.set(k + 1, U);
                            uList.set(k + 2, U);
                            vList.set(k - 1, V);
                            vList.set(k - 2, V);
                            vList.set(k + 1, V);
                            vList.set(k + 2, V);
                            k = k + nx;
                        }
                        uList.set(j, U);
                        vList.set(j, V);
                    }
                }
            }
        }
        String uData = "\"" + "data" + "\"" + ": " + uList;
        String vData = "\"" + "data" + "\"" + ": " + vList;
        String s1 = "[" + "{" + header1 + ", " + uData + "}" + ", " + "{" + header2 + ", " + vData + "}" + "]";
        JSONArray jsonArray = JSONArray.parseArray(s1);

        Double monitorLo = monitorPoint.getLongitude();
        Double monitorLa = monitorPoint.getLatitude();
        List transList = LatLngTransformation.Convert_BD09_To_GCJ02(monitorLa, monitorLo);
        Double transLo = (Double) transList.get(0);
        Double transLa = (Double) transList.get(1);

        list.add(jsonArray);
        list.add(transLo);
        list.add(transLa);
        list.add(laLaMap);
        return list;
    }

    @Override
    public List<Device> getDeviceByCodeAndId(String code, String id) {
        return deviceMapper.getDeviceByCodeAndId(code, id);
    }

    @Override
    public String byMacGetOrgId(String mac) {
        return deviceMapper.byMacGetOrgId(mac);
    }

    @Override
    public List<Device> getDevice(String macOrName) {
        return deviceMapper.getDevice(macOrName);
    }

    @Override
    public List<Device> getDeviceByCode() {
        return deviceMapper.getDeviceByCityCode();
    }

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

}