package com.ruoyi.device.camera.service.impl;

import java.awt.geom.Point2D;
import java.time.LocalTime;
import java.util.*;
import java.util.stream.Collectors;

import com.ruoyi.common.constant.CacheConstants;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.uuid.IdUtils;
import com.ruoyi.device.camera.domain.CameraCmd;
import com.ruoyi.device.channel.domain.ArdChannel;
import com.ruoyi.device.channel.mapper.ArdChannelMapper;
import com.ruoyi.device.channel.service.IArdChannelService;
import com.ruoyi.device.hiksdk.common.GlobalVariable;
import com.ruoyi.device.hiksdk.service.IHikClientService;
import com.ruoyi.scheduling.domian.SchedulingParam;
import com.ruoyi.system.domain.SysConfig;
import com.ruoyi.utils.tools.ArdTool;
import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.device.camera.mapper.ArdCamerasMapper;
import com.ruoyi.device.camera.service.IArdCamerasService;
import com.ruoyi.common.annotation.DataScope;
import com.ruoyi.system.mapper.SysDeptMapper;
import com.ruoyi.utils.tools.GisTool;
import com.ruoyi.utils.tools.Point;
import com.sun.org.apache.bcel.internal.generic.NEW;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

/**
 * 相机设备Service业务层处理
 *
 * @author 刘苏义
 * @date 2023-02-11
 */
@Service
@Slf4j
public class ArdCamerasServiceImpl implements IArdCamerasService {
    @Resource
    private ArdCamerasMapper ardCamerasMapper;
    @Resource
    private SysDeptMapper sysDeptMapper;
    @Resource
    private RedisCache redisCache;

    @Resource
    private ArdChannelMapper ardChannelMapper;


    @PostConstruct
    public void loadCameras() {
        List<ArdCameras> ardCameras = selectArdCamerasListNoDataScope(new ArdCameras());
        for (ArdCameras ardCamera : ardCameras) {
            redisCache.setCacheObject(getCacheKey(ardCamera.getId()), ardCamera);
        }

    }

    /**
     * 设置cache key
     *
     * @param configKey 参数键
     * @return 缓存键key
     */
    private String getCacheKey(String configKey) {
        return CacheConstants.CAMERA_LIST_KEY + configKey;
    }

    /**
     * 查询相机设备
     *
     * @param id 相机设备主键
     * @return 相机设备
     */
    @Override
    public ArdCameras selectArdCamerasById(String id) {
        return ardCamerasMapper.selectArdCamerasById(id);
    }

    /**
     * 查询相机设备列表
     *
     * @param ardCameras 相机设备
     * @return 相机设备
     */
    @Override
    @DataScope(deptAlias = "d", userAlias = "u")
    public List<ArdCameras> selectArdCamerasList(ArdCameras ardCameras) {
        return ardCamerasMapper.selectArdCamerasList(ardCameras);
    }

    /**
     * 查询相机设备列表-不进行数据过滤
     *
     * @param ardCameras 相机设备
     * @return 相机设备
     */
    @Override
    public List<ArdCameras> selectArdCamerasListNoDataScope(ArdCameras ardCameras) {
        return ardCamerasMapper.selectArdCamerasListNoDataScope(ardCameras);
    }

    /**
     * 新增相机设备
     *
     * @param ardCameras 相机设备
     * @return 结果
     */
    @Override
    public int insertArdCameras(ArdCameras ardCameras) {
        ardCameras.setId(IdUtils.simpleUUID());
        ardCameras.setCreateBy(SecurityUtils.getUsername());
        ardCameras.setCreateTime(DateUtils.getNowDate());
        ardCameras.setUserId(SecurityUtils.getUserId());
        redisCache.setCacheObject(getCacheKey(ardCameras.getId()), ardCameras);
        int i = ardCamerasMapper.insertArdCameras(ardCameras);
        if (i > 0) {
//            //删除当前相机的所有通道
//            ardChannelMapper.deleteArdChannelByDeviceId(ardCameras.getId());
//            //获取相机通道
//            List<ArdChannel> ipChannelList = hikClientService.getCameraChannelList(ardCameras);
//            if (ipChannelList.size() > 0) {
//                for (ArdChannel channel : ipChannelList) {
//                    channel.setId(IdUtils.simpleUUID());
//                    ardChannelMapper.insertArdChannel(channel);
//                }
//            }
        }
        return i;
    }

    /**
     * 修改相机设备
     *
     * @param ardCameras 相机设备
     * @return 结果
     */
    @Override
    public int updateArdCameras(ArdCameras ardCameras) {
        ardCameras.setUpdateTime(DateUtils.getNowDate());
        int res = ardCamerasMapper.updateArdCameras(ardCameras);
        if (res > 0) {
            redisCache.deleteObject(getCacheKey(ardCameras.getId()));
            redisCache.setCacheObject(getCacheKey(ardCameras.getId()), ardCameras);
        }
        return res;
    }

    /**
     * 批量删除相机设备
     *
     * @param ids 需要删除的相机设备主键
     * @return 结果
     */
    @Override
    public int deleteArdCamerasByIds(String[] ids) {
        int res = ardCamerasMapper.deleteArdCamerasByIds(ids);
        if (res > 0) {
            for (String id : ids) {
                redisCache.deleteObject(getCacheKey(id));
                //删除当前相机的所有通道
                ardChannelMapper.deleteArdChannelByDeviceId(id);
            }
        }
        return res;
    }

    /**
     * 删除相机设备信息
     *
     * @param id 相机设备主键
     * @return 结果
     */
    @Override
    public int deleteArdCamerasById(String id) {
        int i = ardCamerasMapper.deleteArdCamerasById(id);
        if (i > 0) {
            //删除当前相机的所有通道
            ardChannelMapper.deleteArdChannelByDeviceId(id);
        }
        return i;
    }

    public List findOptions(ArdCameras ardCameras) {
        return ardCamerasMapper.findOptions(ardCameras);
    }

    /**
     * @描述 获取本部门以下的所有相机和部门
     * @参数 []
     * @返回值 java.util.Map
     * @创建人 刘苏义
     * @创建时间 2023/6/2 10:58
     * @修改人和其它信息
     */

    @Override
    public Map getChildDeptAndCamera(Boolean disabled) {
        Long deptId = SecurityUtils.getDeptId();
        SysDept sysDept = sysDeptMapper.selectDeptById(deptId);
        Map<String, Object> map = fetchChildDepartments(sysDept, disabled);
        return map;
    }

    /**
     * @描述 递归查询
     * @参数 [sysDept]
     * @返回值 java.util.Map<java.lang.String, java.lang.Object>
     * @创建人 刘苏义
     * @创建时间 2023/6/2 14:38
     * @修改人和其它信息
     */
    public Map<String, Object> fetchChildDepartments(SysDept sysDept, Boolean disabled) {
        Map<String, Object> map = new HashMap<>();
        map.put("name", sysDept.getDeptName());
        map.put("deptId", sysDept.getDeptId());
        map.put("disabled", disabled);
        List<SysDept> sysDepts = sysDeptMapper.selectNextChildrenDeptById(sysDept.getDeptId());
        List<ArdCameras> ardCameras = ardCamerasMapper.selectArdCamerasByDeptId(sysDept.getDeptId());
        List<Object> childList = new ArrayList<>();
        for (SysDept childDept : sysDepts) {
            Map<String, Object> childMap = new HashMap<>();
            childMap.put("name", childDept.getDeptName());
            childMap.put("deptId", childDept.getDeptId());
            childMap.put("disabled", disabled);
            Map<String, Object> map1 = fetchChildDepartments(childDept, disabled);
            childMap.putAll(map1);
            childList.add(childMap);
        }
        if (ardCameras.size() > 0) {
            for (ArdCameras camera : ardCameras) {
                ArdChannel ardChannel=new ArdChannel();
                ardChannel.setDeviceId(camera.getId());
                List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
                if(ardChannels!=null)
                {
                    camera.setChannelList(ardChannels);
                }
                Map<String, Object> cameraMap = ArdTool.convertEntityToMap(camera);
                childList.add(cameraMap);
            }
        }
        map.put("children", childList);
        return map;

    }

    /**
     * @描述 通过坐标获取附近的相机
     * @参数 [cmd]
     * @返回值 java.util.Map
     * @创建人 刘苏义
     * @创建时间 2023/6/17 11:55
     * @修改人和其它信息
     */
    @Override
    public TreeMap getNearCamerasBycoordinate(CameraCmd cmd) {
        try {
            double[] targetPosition = cmd.getTargetPosition();
            if (targetPosition == null || (targetPosition != null && targetPosition.length == 0)) {
                log.debug("目标位置为空");
                return new TreeMap<>();
            }
            String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
            //获取所有大光电
            List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(new ArdCameras("1"));
            //统计所有大光电可视范围内与报警点的距离
            Map<String, Double> distanceMap = new HashMap<>();
            TreeMap<Double, ArdCameras> ardCameras = new TreeMap<>();
            for (ArdCameras camera : ardCamerasList) {
                if (camera.getLongitude() == null && camera.getLatitude() == null) {
                    continue;
                }
                double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
                double distance = GisTool.getDistance(cmd.getTargetPosition(), camPosition);
                if (camera.getCamMaxVisibleDistance() == null) {
                    continue;
                }
                if (distance != 0.0 && distance <= camera.getCamMaxVisibleDistance()) {
                    distanceMap.put(camera.getId(), distance);
                    camera.setChanNo(ArdTool.getChannelBydayNightTime(dayNightTime));
                    ardCameras.put(distance, camera);
                }

            }
            return ardCameras;
        } catch (Exception ex) {
            log.error("获取附近相机异常:" + ex.getMessage());
        }
        return null;
    }

    /**
     * 获取监控圈内所有在线光电
     * 刘苏义
     * 2023/8/17 13:57:21
     */
    @Override
    public List<ArdCameras> getNearCameras(SchedulingParam param) {
        try {
            Long deptId=SecurityUtils.getLoginUser().getUser().getDeptId();
            Double longitude = param.getLongitude();
            Double latitude = param.getLatitude();
            if (longitude == null && latitude == null) {
                log.debug("原点坐标为空");
                return null;
            }
            Integer radius = param.getMonitoringRadius();
            if (radius == null) {
                log.debug("监控圈半径距离为空");
                return null;
            }
            String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
            //获取所有光电(按部门)
            ArdCameras cameras= new ArdCameras();
            cameras.setDeptId(deptId);
            List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(cameras);
            //统计所有光电可视范围内与报警点的距离
            List<ArdCameras> ardCameras = new ArrayList<>();
            for (ArdCameras camera : ardCamerasList) {
                if (camera.getLongitude() == null && camera.getLatitude() == null) {
                    continue;
                }
                double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
                double distance = GisTool.getDistance(new double[]{longitude, latitude}, camPosition);
                if (distance <= radius) {
                    /*获取通道列表*/
                    ArdChannel ardChannel=new ArdChannel();
                    ardChannel.setDeviceId(camera.getId());
                    List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
                    camera.setChannelList(ardChannels);
                    ardCameras.add(camera);
                }
            }
            //过滤在线相机
            List<ArdCameras> onlineList = ardCameras.stream()
                    .filter(ardCamera -> (!ardCamera.getLoginId().equals(-1)))
                    .collect(Collectors.toList());
            return onlineList;
        } catch (Exception ex) {
            log.error("获取附近相机异常:" + ex.getMessage());
        }
        return null;
    }
    /**
     * 获取监控圈内所有在线光电
     * 刘苏义
     * 2023/8/17 13:57:21
     */
    @Override
    public List<ArdCameras> getNearCamerasWithPolygon(SchedulingParam param) {
        try {
            Long deptId=SecurityUtils.getLoginUser().getUser().getDeptId();
            List<Point> partitionLocation = param.getPartitionLocation();
            if(partitionLocation==null)
            {
                log.debug("多边形坐标集合为空");
                return null;
            }
            String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
            //获取所有光电(按部门)
            ArdCameras cameras= new ArdCameras();
            cameras.setDeptId(deptId);
            List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(cameras);
            List<ArdCameras> ardCameras = new ArrayList<>();
            for (ArdCameras camera : ardCamerasList) {
                if (camera.getLongitude() == null && camera.getLatitude() == null) {
                    continue;
                }
                /*判断坐标是否在多边形范围内*/
                Point camPosition=new Point(camera.getLongitude(),camera.getLatitude());
                boolean inPolygon = GisTool.isInPolygon(camPosition, partitionLocation);
                if (inPolygon) {
                    /*获取通道列表*/
                    ArdChannel ardChannel=new ArdChannel();
                    ardChannel.setDeviceId(camera.getId());
                    List<ArdChannel> ardChannels = ardChannelMapper.selectArdChannelList(ardChannel);
                    camera.setChannelList(ardChannels);
                    ardCameras.add(camera);
                }
            }
            //过滤在线相机
            List<ArdCameras> onlineList = ardCameras.stream()
                    .filter(ardCamera -> (!ardCamera.getLoginId().equals(-1)))
                    .collect(Collectors.toList());
            return onlineList;
        } catch (Exception ex) {
            log.error("获取附近相机异常:" + ex.getMessage());
        }
        return null;
    }

}