package com.ruoyi.app.position.service.impl;

import com.ruoyi.alarm.wall.domain.ArdAlarmWall;
import com.ruoyi.alarm.wall.mapper.ArdAlarmWallMapper;
import com.ruoyi.alarm.wall.service.IArdAlarmWallService;
import com.ruoyi.alarmpoints.wall.domain.ArdWall;
import com.ruoyi.alarmpoints.wall.mapper.ArdWallMapper;
import com.ruoyi.app.position.domain.ArdAppPosition;
import com.ruoyi.app.position.mapper.ArdAppPositionMapper;
import com.ruoyi.app.position.service.IArdAppPositionService;
import com.ruoyi.common.core.domain.entity.SysUser;
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.scheduling.domian.SchedulingParam;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.utils.gis.GisUtil;
import com.ruoyi.utils.gis.Point;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;


/**
 * app位置Service业务层处理
 *
 * @author ard
 * @date 2023-07-18
 */
@Service
@Slf4j
public class ArdAppPositionServiceImpl implements IArdAppPositionService {
    @Resource
    private ArdAppPositionMapper ardAppPositionMapper;
    @Resource
    private ISysUserService iSysUserService;

    /**
     * 查询app位置
     *
     * @param id app位置主键
     * @return app位置
     */
    @Override
    public ArdAppPosition selectArdAppPositionById(String id) {
        return ardAppPositionMapper.selectArdAppPositionById(id);
    }

    /**
     * 按用户id查询最后的位置信息
     *
     * @param userId app用户主键
     * @return app位置
     */
    @Override
    public ArdAppPosition selectLastArdAppPositionByUserId(String userId) {
        return ardAppPositionMapper.selectLastArdAppPositionByUserId(userId);
    }

    /**
     * 查询app位置列表
     *
     * @param ardAppPosition app位置
     * @return app位置
     */
    @Override
    public List<ArdAppPosition> selectArdAppPositionList(ArdAppPosition ardAppPosition) {
        return ardAppPositionMapper.selectArdAppPositionList(ardAppPosition);
    }

    /**
     * 新增app位置
     *
     * @param ardAppPosition app位置
     * @return 结果
     */
    @Override
    public List<ArdAlarmWall> insertArdAppPosition(ArdAppPosition ardAppPosition) {
        ardAppPosition.setId(IdUtils.simpleUUID());
        ardAppPosition.setCreateTime(DateUtils.getNowDate());
        ardAppPositionMapper.insertArdAppPosition(ardAppPosition);
        return DetectionWallAlarm(ardAppPosition);
    }

    /**
     * 修改app位置
     *
     * @param ardAppPosition app位置
     * @return 结果
     */
    @Override
    public int updateArdAppPosition(ArdAppPosition ardAppPosition) {
        return ardAppPositionMapper.updateArdAppPosition(ardAppPosition);
    }

    /**
     * 批量删除app位置
     *
     * @param ids 需要删除的app位置主键
     * @return 结果
     */
    @Override
    public int deleteArdAppPositionByIds(String[] ids) {
        return ardAppPositionMapper.deleteArdAppPositionByIds(ids);
    }

    /**
     * 删除app位置信息
     *
     * @param id app位置主键
     * @return 结果
     */
    @Override
    public int deleteArdAppPositionById(String id) {
        return ardAppPositionMapper.deleteArdAppPositionById(id);
    }

    /**
     * 获取封控圈内所有在线app用户
     * 刘苏义
     * 2023/8/17 13:56:36
     */
    @Override
    public List<SysUser> getNearAppUsers(SchedulingParam param) {
        List<SysUser> filteredList = new ArrayList<>();
        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.getSealingRadius();

            if (radius == null) {
                log.debug("半径距离为空");
                return null;
            }

            SysUser user = new SysUser();
            user.setDeptId(deptId);
            List<SysUser> appUserList = iSysUserService.selectAllAppUserList(user);
            //过滤在线和单兵端
            List<SysUser> onLineList = appUserList.stream()
                    .filter(sysUser -> (sysUser.getAppOnlineState().equals("1")))
                    .filter(sysUser -> (sysUser.getAppUserType().equals("1")))
                    .collect(Collectors.toList());
            //过滤范围
            for (SysUser sysUser : onLineList) {
                ArdAppPosition ardAppPosition = ardAppPositionMapper.selectLastArdAppPositionByUserId(sysUser.getUserId());
                if (ardAppPosition != null) {
                    Double lon = ardAppPosition.getLongitude();
                    Double lat = ardAppPosition.getLatitude();
                    if (longitude == null || latitude == null) {
                        continue;
                    }
                    double distance = GisUtil.getDistance(new double[]{longitude, latitude}, new double[]{lon, lat});
                    if (distance <= radius) {
                        Map<String, Object> params = new HashMap<>();
                        params.put("longitude", lon);
                        params.put("latitude", lat);
                        sysUser.setParams(params);
                        filteredList.add(sysUser); // 将满足条件的用户添加到筛选列表中
                    }
                }
            }
        } catch (Exception ex) {
            log.error("获取封控圈内所有在线app用户异常" + ex.getMessage());
        }
        return filteredList;
    }

    /**
     * 获取封控圈内所有在线app用户(多边形)
     * 刘苏义
     * 2023/8/17 13:56:36
     */
    @Override
    public List<SysUser> getNearAppUsersWithPolygon(SchedulingParam param) {
        List<SysUser> filteredList = new ArrayList<>();
        try {
            Long deptId = SecurityUtils.getLoginUser().getUser().getDeptId();
            List<Point> partitionLocation = param.getPartitionLocation();

            SysUser user = new SysUser();
            user.setDeptId(deptId);
            List<SysUser> appUserList = iSysUserService.selectAllAppUserList(user);
            //过滤在线
            List<SysUser> onLineList = appUserList.stream()
                    .filter(sysUser -> (sysUser.getAppOnlineState().equals("1")))
                    .filter(sysUser -> (sysUser.getAppUserType().equals("1")))
                    .collect(Collectors.toList());
            //过滤范围
            for (SysUser sysUser : onLineList) {
                ArdAppPosition ardAppPosition = ardAppPositionMapper.selectLastArdAppPositionByUserId(sysUser.getUserId());
                if (ardAppPosition != null) {
                    Double lon = ardAppPosition.getLongitude();
                    Double lat = ardAppPosition.getLatitude();
                    if (lon == null || lat == null) {
                        continue;
                    }
                    Point point2D = new Point(lon, lat);
                    boolean inPolygon = GisUtil.isInPolygon(point2D, partitionLocation);
                    if (inPolygon) {
                        Map<String, Object> params = new HashMap<>();
                        params.put("longitude", lon);
                        params.put("latitude", lat);
                        sysUser.setParams(params);
                        filteredList.add(sysUser); // 将满足条件的用户添加到筛选列表中
                    }
                }
            }
        } catch (Exception ex) {
            log.error("获取封控圈内所有在线app用户异常" + ex.getMessage());
        }
        return filteredList;
    }


    @Resource
    RedisCache redisCache;
    @Resource
    ArdWallMapper ardWallMapper;
    @Resource
    IArdAlarmWallService ardAlarmWallService;
    Map<String, String> userInLastAlarm = new HashMap<>();
    Map<String, String> userOutLastAlarm = new HashMap<>();
    /**
     * 实时位置检测围栏报警
     * 刘苏义
     * 2023/8/31 8:54:06
     */
    public List<ArdAlarmWall> DetectionWallAlarm(ArdAppPosition ardAppPosition) {
        SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        List<ArdAlarmWall> ardAlarmWalls=new ArrayList<>();
        //获取当前用户的部门
        String userId = ardAppPosition.getUserId();
        SysUser sysUser = redisCache.getCacheObject("user_list:" + userId);
        Long deptId = sysUser.getDeptId();
        //获取部门下的所有电子围栏
        ArdWall ardWall = new ArdWall();
        ardWall.setDeptId(deptId);
        List<ArdWall> ardWalls = ardWallMapper.selectArdWallList(ardWall);
        if (ardWalls.size() > 0) {
            for (ArdWall wall : ardWalls) {
                String wallPoi = wall.getWallPoi();
                String wallType = wall.getType();
                //处理多边形的每个点的经纬度
                String[] parts = wallPoi.split(",");
                List<Point> pointList = new ArrayList<>();
                for (int i = 0; i < parts.length; i += 3) {
                    Point point = new Point();
                    point.setLongitude(Double.valueOf(parts[i]));
                    point.setLatitude(Double.valueOf(parts[i + 1]));
                    pointList.add(point);
                }
                Point userPoint=new Point(ardAppPosition.getLongitude(),ardAppPosition.getLatitude());
                boolean inPolygon = GisUtil.isInPolygon(userPoint, pointList);
                ArdAlarmWall ardAlarmWall = new ArdAlarmWall();
                ardAlarmWall.setWallId(wall.getId());
                ardAlarmWall.setWallName(wall.getWallName());
                ardAlarmWall.setUserId(userId);
                ardAlarmWall.setAlarmTime(DateUtils.getNowDate());
                ardAlarmWall.setAlarmType(wall.getType());
                ardAlarmWall.setLongitude(ardAppPosition.getLongitude());
                ardAlarmWall.setLatitude(ardAppPosition.getLatitude());
                ardAlarmWall.setAltitude(ardAppPosition.getAltitude());
                //禁入
                if("1".equals(wallType)) {
                    //判断当前用户位置是否在围栏内
                    if (inPolygon) {
                        String lastInAlarmId = userInLastAlarm.get(userId);
                        if (lastInAlarmId == null) {
                            String uuid = IdUtils.simpleUUID();
                            //当前用户上一次状态未进入，生成报警
                            ardAlarmWall.setId(uuid);
                            ardAlarmWallService.insertArdAlarmWall(ardAlarmWall);
                            //更新最后报警id
                            userInLastAlarm.put(userId, uuid);
                        } else {
                            //上一次用户状态已进入，更新最后报警
                            ardAlarmWall.setId(lastInAlarmId);
                            ardAlarmWallService.updateArdAlarmWall(ardAlarmWall);
                        }
                        ardAlarmWalls.add(ardAlarmWall);
                    }
                    else
                    {
                        //移除最后报警id
                        userInLastAlarm.remove(userId);
                    }
                }
                else//禁出
                {
                    //判断当前用户位置是否在围栏外
                    if (!inPolygon) {
                        String lastAlarmId = userOutLastAlarm.get(userId);
                        if (lastAlarmId == null) {
                            String uuid = IdUtils.simpleUUID();
                            //当前用户上一次状态未进入，生成报警
                            ardAlarmWall.setId(uuid);
                            ardAlarmWallService.insertArdAlarmWall(ardAlarmWall);
                            //更新最后报警id
                            userOutLastAlarm.put(userId, uuid);
                        } else {
                            //上一次用户状态已进入，更新最后报警
                            ardAlarmWall.setId(lastAlarmId);
                            ardAlarmWallService.updateArdAlarmWall(ardAlarmWall);
                        }
                        ardAlarmWalls.add(ardAlarmWall);
                    }
                    else
                    {
                        //移除最后报警id
                        userOutLastAlarm.remove(userId);
                    }
                }

            }
        }
        return ardAlarmWalls;
    }
}