package com.ld.igds.sec.manager;

import com.ld.igds.camera.ApiCameraManager;
import com.ld.igds.camera.CameraUtil;
import com.ld.igds.camera.data.ApiCameraResp;
import com.ld.igds.common.CoreCommonService;
import com.ld.igds.common.CoreDeviceService;
import com.ld.igds.common.CoreSerService;
import com.ld.igds.common.dto.DepotSerData;
import com.ld.igds.constant.BizType;
import com.ld.igds.constant.DeviceType;
import com.ld.igds.constant.RespCodeEnum;
import com.ld.igds.data.PageResponse;
import com.ld.igds.door.dto.DoorAccessData;
import com.ld.igds.door.dto.DoorAccessParam;
import com.ld.igds.door.service.CoreDoorService;
import com.ld.igds.file.CoreFileService;
import com.ld.igds.io.RemoteControlService;
import com.ld.igds.io.RemoteManager;
import com.ld.igds.io.constant.OrderRespEnum;
import com.ld.igds.io.request.DeviceControlRequest;
import com.ld.igds.io.request.ExeDevice;
import com.ld.igds.io.response.DeviceControlResponse;
import com.ld.igds.common.DepotStatusService;
import com.ld.igds.models.Depot;
import com.ld.igds.models.Device;
import com.ld.igds.models.DeviceSer;
import com.ld.igds.models.DoorSensor;
import com.ld.igds.order.ExeOrderService;
import com.ld.igds.order.data.ExeRequest;
import com.ld.igds.sec.dto.*;
import com.ld.igds.camera.data.ApiCameraData;
import com.ld.igds.sec.service.CoreSecCameraService;
import com.ld.igds.sec.service.CoreSecFireService;
import com.ld.igds.sec.service.CoreSecPatrolService;
import com.ld.igds.util.ContextUtil;
import com.ld.igds.util.DateUtil;
import com.ld.igds.util.FfmpegUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 安防模块
 */
@Slf4j
@Component
public class SecManager {

    @Autowired
    private CoreCommonService coreCommonService;
    @Autowired
    private CoreDeviceService coreDeviceService;
    @Autowired
    private ExeOrderService exeOrderService;
    @Autowired
    private CoreSerService coreSerService;
    @Autowired
    private CoreSecCameraService secCameraService;
    @Autowired
    private CoreSecFireService secFileService;
    @Autowired
    private RemoteManager remoteManager;
    @Autowired
    private CoreDoorService coreDoorService;
    @Autowired
    private DepotStatusService authCheckService;
    @Autowired
    private CoreSecPatrolService patrolService;
    @Autowired
    private CoreFileService fileService;
    @Autowired
    private ApiCameraManager apiCameraManager;

    private RemoteControlService remoteControlService;

    /**
     * 获取手动通风仓库的设备列表
     *
     * @param param
     * @return
     */
    public PageResponse<List<Device>> listDevice(SecurityParam param) {

        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        // 根据仓库缓存获取相同建筑物下的仓库集合
        List<Depot> depotList = coreCommonService.getCacheCommonBuildingDepot(
                param.getCompanyId(), param.getDepotId());
        // 获取ID信息
        List<String> depotIds = depotList.stream().map(Depot::getId)
                .collect(Collectors.toList());

        // 根据仓库多个ID获取仓库与分机的关系数据
        List<DepotSerData> depotSerDataList = coreCommonService
                .getCacheDepotSerByDepots(param.getCompanyId(), depotIds);
        if (null == depotSerDataList) {
            log.error("没有获取到当前仓库{}的相关分机，执行失败。", param.getDepotId());
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "没有获取到当前仓的分机信息，执行被拒绝！");
        }

        List<Device> listAll = new ArrayList<>();// 分机的所有设备
        List<Device> tempList;
        for (DepotSerData depotSerData : depotSerDataList) {
            tempList = coreDeviceService.getCacheDeviceBySerId(
                    param.getCompanyId(), depotSerData.getSerId());
            listAll.addAll(tempList);
        }

        if (listAll.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "当前仓库没有获取到设备配置信息，请联管理员！！");
        }

        // 循环遍历出当前仓的
        List<Device> listResult = listAll
                .stream()
                .filter(item -> item.getType().equals(
                        DeviceType.TYPE_0E.getCode()))
                .collect(Collectors.toList());

        if (null == listResult || listResult.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "当前仓库没有获取到气调设备信息，请联系管理员！！");
        }

        return new PageResponse<>(RespCodeEnum.CODE_0000, listResult);
    }

    /**
     * 设备操作接口管理
     *
     * @param param
     * @return
     */
    public DeviceControlResponse controlDevice(SecurityParam param) {
        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        List<ExeDevice> deviceList = param.getDeviceList();

        if (null == deviceList || deviceList.isEmpty()) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(),
                    "没有获取到需要被执行的设备信息，请重新选择执行");
        }

        // 添加逻辑验证
        String msg = authCheckService.checkDepotStatus(param.getCompanyId(),
                param.getDepotId(), deviceList);
        if (null != msg) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(), msg);
        }

        // 如果是单个设备
        if (deviceList.size() == 1) {
            return controlDevice2(param);
        }

        // 如果多个设备，需要对设备按分机进行分组
        Map<String, List<ExeDevice>> deviceMap = deviceList.stream().collect(
                Collectors.groupingBy(ExeDevice::getSerId));
        String temp = "";
        DeviceControlResponse tempResp;
        for (String key : deviceMap.keySet()) {
            param.setDeviceList(deviceMap.get(key));
            tempResp = controlDevice2(param);
            if (OrderRespEnum.ORDER_ERROR.getCode().equals(tempResp.getCode())) {
                temp += tempResp.getMsg();
            }
        }

        if ("".equals(temp)) {
            return new DeviceControlResponse(OrderRespEnum.ORDER_SUCCESS);
        }

        return new DeviceControlResponse(OrderRespEnum.ORDER_ERROR.getCode(),
                "发送存在异常：" + temp);
    }

    /**
     * 单个分机设备操作接口管理
     *
     * @param param
     * @return
     */
    public DeviceControlResponse controlDevice2(SecurityParam param) {
        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        List<ExeDevice> deviceList = param.getDeviceList();

        if (null == deviceList || deviceList.isEmpty()) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(),
                    "没有获取到需要被执行的设备信息，请重新选择执行");
        }
        String serId = deviceList.get(0).getSerId();

        // 获取分机信息
        DeviceSer deviceSer = coreSerService.getCacheSer(param.getCompanyId(),
                serId);

        DeviceControlRequest request = new DeviceControlRequest();
        request.setDepotId(param.getDepotId());
        request.setCompanyId(param.getCompanyId());
        request.setDeviceList(deviceList);
        request.setBizType(BizType.SECURITY.getCode());
        request.setIp(deviceSer.getIp());
        request.setPort(deviceSer.getPort());
        request.setSerId(serId);
        request.setControlModel(deviceSer.getControlModel());
        request.setRealNum(deviceList.size());

        // 避免重复发送命令和添加操作记录
        ExeRequest exeRequest = new ExeRequest(request);
        exeRequest.setRepeatTag(true);
        exeOrderService.checkExecute(exeRequest);

        // 添加开门记录
        addDoorRecord(request);

        remoteControlService = remoteManager.getRemoteControlService(deviceSer
                .getProtocol());

        if (null == remoteControlService) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(), "系统没有"
                    + deviceSer.getProtocol() + "的协议实现，执行被拒绝！");
        }

        DeviceControlResponse response = remoteControlService
                .deviceControl(request);

        if (OrderRespEnum.ORDER_SUCCESS.getCode().equals(response.getCode())) {
            exeOrderService.addCache(exeRequest);
        }

        return response;
    }

    public DeviceControlResponse queryDeviceStatus(SecurityParam param) {
        if (null == param.getCompanyId()) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        if (null == param.getDepotId()) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(), "系统没有获取到仓库参数，执行被拒绝。");
        }
        // 根据仓库多个ID获取仓库与分机的关系数据
        List<String> depotIds = new ArrayList<String>();
        depotIds.add(param.getDepotId());
        List<DepotSerData> depotSerDataList = coreCommonService
                .getCacheDepotSerByDepots(param.getCompanyId(), depotIds);

        if (null == depotSerDataList) {
            return new DeviceControlResponse(
                    OrderRespEnum.ORDER_ERROR.getCode(),
                    "当前仓库没有匹配的控制柜信息，执行被拒绝。");
        }

        DeviceControlResponse response = new DeviceControlResponse(
                OrderRespEnum.ORDER_SUCCESS.getCode(), "命令发送成功！");

        DeviceSer deviceSer;
        DeviceControlRequest request;
        for (DepotSerData depotSerData : depotSerDataList) {
            deviceSer = coreSerService.getCacheSer(param.getCompanyId(),
                    depotSerData.getSerId());

            if (null == deviceSer) {
                log.info("根据仓库{}获取设备状态，分机编码{}的分机不存在，取消执行。", param.getDepotId(),
                        depotSerData.getSerId());
                continue;
            }

            request = new DeviceControlRequest();
            request.setDepotId(param.getDepotId());
            request.setCompanyId(param.getCompanyId());
            request.setBizType(BizType.SECURITY.getCode());
            request.setIp(deviceSer.getIp());
            request.setPort(deviceSer.getPort());
            request.setSerId(deviceSer.getId());

            remoteControlService = remoteManager
                    .getRemoteControlService(deviceSer.getProtocol());

            if (null == remoteControlService) {
                return new DeviceControlResponse(
                        OrderRespEnum.ORDER_ERROR.getCode(), "系统没有"
                        + deviceSer.getProtocol() + "的协议实现，执行被拒绝！");
            }

            response = remoteControlService.queryStatus(request);
        }

        return response;
    }

    public SecCameraDto getCameraById(String companyId, String cameraId,
                                      boolean flag) {

        if (StringUtils.isEmpty(cameraId))
            return null;

        SecCameraDto dto = secCameraService.getCameraById(companyId, cameraId);

        if (flag) {
            dto.setMediaAddr(CameraUtil.updateMediaAddr2(dto, false));
        }

        log.debug("视频信息={}", dto.toString());
        return dto;
    }

    public List<SecCameraDto> listCamera(String deptId, String companyId) {
        List<SecCameraDto> list = secCameraService.getAllCacheCamera(companyId);

        if (null == list || list.isEmpty())
            return list;

        if (null == deptId)
            return list;

        return list.stream().filter(item -> deptId.equals(item.getDeptId()))
                .collect(Collectors.toList());

    }

    public PageResponse<String> updatePos(List<SecurityParam> params) {

        if (null == params || params.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "当前没有需要执行的信息！");
        }

        for (SecurityParam param : params) {
            secCameraService.updatePos(param);
        }

        secCameraService.refreshCache(ContextUtil.getCompanyId());
        return new PageResponse<>(RespCodeEnum.CODE_0000, "执行成功！！");
    }

    public List<SecFireDto> listFire(String deptId, String companyId) {
        List<SecFireDto> list = secFileService.getAllFire(companyId);

        if (null == list || list.isEmpty())
            return list;

        if (null == deptId)
            return list;

        return list.stream().filter(item -> deptId.equals(item.getDeptId()))
                .collect(Collectors.toList());

    }

    public PageResponse<String> updateFirePos(List<SecurityParam> params) {

        if (null == params || params.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "当前没有需要执行的信息！");
        }

        for (SecurityParam param : params) {
            secFileService.updateFirePos(param);
        }

        return new PageResponse<>(RespCodeEnum.CODE_0000, "执行成功！！");
    }

    public SecCameraDto getPlayAddr(SecCameraDto param) {

        if (StringUtils.isEmpty(param.getId())) {
            log.error("没有获取到ID"+ param.toString());
            return null;
        }
        if(StringUtils.isEmpty(param.getCompanyId())){
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        // 根据id获取设备信息
        SecCameraDto camera = secCameraService.getCameraById(param.getCompanyId(), param.getId());
        if(camera == null){
            log.error("缓存中没有获取到摄像头信息"+ param.toString());
            return null;
        }

        //若为海康流媒体，使用插件播放则直接返回摄像头信息
        if (CameraUtil.PLAY_TYPE_MEDIA_HIK.equals(camera.getPlayType())) {
            camera.setPlayAddr(CameraUtil.PLAY_TYPE_MEDIA_HIK);
            return camera;
        }

        //通过统一入口获取播放地址
        ApiCameraData apiCameraData = new ApiCameraData();
        apiCameraData.setCompanyId(camera.getCompanyId());
        apiCameraData.setSn(camera.getSn());
        apiCameraData.setCameraId(camera.getId());
        apiCameraData.setPlayType(camera.getPlayType());
        apiCameraData.setMediaAddr(CameraUtil.updateMediaAddr2(camera, false));

        ApiCameraResp result = apiCameraManager.getApiCameraService(camera.getPlayType()).getPlayAddr(apiCameraData);
        log.debug("视频播放地址为:"+result.toString());
        if (null != result && ApiCameraResp.CODE_SUCCESS.equals(result.getCode())) {
            camera.setPlayAddr(result.getPlayAddr());
            camera.setPlayIframe(result.getPlayIframe());
            return camera;
        }

        return null;
    }

    /**
     * 云台控制
     * @param param
     * @return
     */
    public ApiCameraResp ptzMedia(ApiCameraData param) {

        if(StringUtils.isEmpty(param.getCompanyId())){
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        return apiCameraManager.getApiCameraService(param.getPlayType()).ptzMedia(param);
    }

    /**
     * 流媒体保活
     * @param param
     * @return
     */
    public ApiCameraResp keepAlive(ApiCameraData param) {

        return apiCameraManager.getApiCameraService(param.getPlayType()).keepAlive(param);
    }

    /**
     * 预置位设置
     * @param param
     * @return
     */
    public ApiCameraResp ptzPreset(ApiCameraData param) {

        return apiCameraManager.getApiCameraService(param.getPlayType()).ptzPreset(param);
    }

    /**
     * 验证门禁权限码
     *
     * @param token
     * @param depotId
     * @return
     */
    public PageResponse<String> checkToken(String token, String depotId,
                                           String deptId, String companyId) {
        DoorAccessParam param = new DoorAccessParam();
        param.setCompanyId(companyId);
        param.setDeptId(deptId);
        param.setToken(token);
        DoorAccessData doorToken = coreDoorService.getDoorAccess(param);
        // 判断权限码是否存在
        if (doorToken == null) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "权限码不存在，请重试！");
        }

        // 判断权限码是否失效
        if (doorToken.getEnd() != null && doorToken.getEnd().before(new Date())) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "权限码已失效，请重新申请！");
        }

        // 判断操作仓库是否有权限
        if (StringUtils.isNotEmpty(depotId)) {
            if (!"ALL".equals(doorToken.getDepotId())
                    && !doorToken.getDepotId().equals(depotId)) {
                return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                        "您没有操作此仓库门禁的权限！！");
            }
        }

        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "验证成功！！");
    }

    /**
     * 添加门禁操作记录
     *
     * @param request
     */
    private void addDoorRecord(DeviceControlRequest request) {
        // TODO
        return;
    }

    /**
     * 根据id获取巡更记录
     *
     * @param patrolId
     */
    public List<SecPatrolRecordDto> getPatrolRecord(String patrolId) {

        if (StringUtils.isEmpty(patrolId)) {
            return null;
        }

        SecPatrolRecordParam param = new SecPatrolRecordParam();
        param.setId(patrolId);
        List<SecPatrolRecordDto> list = patrolService.getPatrolList(param);
        if (list == null || list.isEmpty()) {
            return null;
        }
        SecPatrolRecordDto data = list.get(0);
        param.setId(null);
        param.setCompanyId(data.getCompanyId());
        param.setDeptId(data.getDeptId());
        param.setUserName(data.getUserName());
        param.setStart(DateUtil.getCurZero(data.getCreateTime()));
        param.setEnd(DateUtil.getNextZero(data.getCreateTime()));

        return patrolService.getPatrolList(param);
    }

    /**
     * 获取巡更记录
     *
     * @param patrolId
     */
    public SecPatrolRecordDto getPatrolImg(String patrolId) {
        if (StringUtils.isEmpty(patrolId)) {
            return null;
        }

        SecPatrolRecordParam param = new SecPatrolRecordParam();
        param.setId(patrolId);
        List<SecPatrolRecordDto> list = patrolService.getPatrolList(param);
        if (list == null || list.isEmpty()) {
            return null;
        }
        SecPatrolRecordDto data = list.get(0);

        if (StringUtils.isNotEmpty(data.getImgName())) {
            String bathPath = fileService.getInoutFilePath(data.getCreateTime());
            String imgBase = FfmpegUtil.getImgStr(bathPath + data.getImgName());
            data.setBase64Img(imgBase);
        }

        return list.get(0);
    }

    /**
     * 获取巡更记录
     *
     * @param param
     */
    @SuppressWarnings("unused")
    public PageResponse<List<DoorSensor>> queryDoorSensorData(DoorSensor param) {

        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        if (StringUtils.isEmpty(param.getDeptId())) {
            param.setDeptId(ContextUtil.subDeptId(null));
        }

        // List<DoorSensor> list = doorSensorService.getDoorSensorList(param);

        List<DoorSensor> list = null;
        if (list == null || list.isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到相关信息！");
        }

        return new PageResponse<>(RespCodeEnum.CODE_0000, list);
    }

    public List<String> recordImgList(Integer id) {

        return null;
    }

    /**
     * 门禁撤防
     *
     * @param param
     * @return
     */
    public PageResponse<String> addDoorAccess(DoorAccessParam param) {

        if (param == null || param.getStart() == null || param.getEnd() == null
                || StringUtils.isEmpty(param.getDepotId())) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "撤防失败，请重试！");
        }

        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        if (StringUtils.isEmpty(param.getDeptId())) {
            param.setDeptId(ContextUtil.subDeptId(null));
        }

        param.setUser(ContextUtil.getLoginUserName());
        param.setToken(coreDoorService.getNewToken(null));
        // 添加一条门禁权限记录
        coreDoorService.addDoorAccess(param);

        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "撤防成功！！");
    }

    /**
     * 门禁布防
     *
     * @param param
     * @return
     */
    public PageResponse<String> delDoorAccess(DoorAccessParam param) {

        if (param == null || StringUtils.isEmpty(param.getDepotId())) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "布防失败，请重试！");
        }
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        if (StringUtils.isEmpty(param.getDeptId())) {
            param.setDeptId(ContextUtil.subDeptId(null));
        }
        param.setTime(new Date());

        // coreDoorService.emptyDoorAccessByDepotId(param);
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "布防成功！！");
    }
}