package com.ard.work.sdk.service;

import com.ard.common.core.constant.CacheConstants;
import com.ard.common.core.exception.ServiceException;
import com.ard.common.core.exception.device.CameraSDKException;
import com.ard.common.core.web.domain.AjaxResult;
import com.ard.common.redis.service.RedisService;
import com.ard.common.security.utils.SecurityUtils;
import com.ard.work.api.domian.*;
import com.ard.work.device.camera.domain.PtzParamDTO;
import com.ard.work.device.noview.domain.ArdNoViewingZone;
import com.ard.work.device.noview.service.IArdNoViewingZoneService;
import com.ard.work.sdk.annotation.SdkOperate;
import com.ard.work.sdk.common.RecordManager;
import com.ard.work.sdk.factory.CameraSDKFactory;
import com.ard.work.sdk.model.DeviceCFG;
import com.ard.work.sdk.model.PtzScope;
import com.ard.work.utils.gis.GisUtil;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

@Service
@Slf4j
public class CameraSDKService {

    @Resource
    private RedisService redisService;
    @Resource
    private CameraSDKFactory cameraSDKFactory;
    @Resource
    private IArdNoViewingZoneService ardNoViewingZoneService;

    // ========== 基础操作 ==========

    @Async("cameraSdkExecutor")
    public void login(ArdCamera ardCamera) {
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(null);
        }
        CameraSDK sdk = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
        sdk.login(ardCamera);
    }

    public void logout(String cameraId) {
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cameraId);
        if (ardCamera == null || ardCamera.getFactory() == null) {
            return;
        }
        CameraSDK sdk = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
        sdk.logout(cameraId);
    }

    // ========== 简单操作（一行搞定） ==========

    @SdkOperate
    public Boolean pTZControl(CameraCmd cmd) {
        return getSdk(cmd).pTZControl(cmd);
    }

    public Boolean setFocusPos(CameraCmd cmd) {
        return getSdk(cmd).setFocusPos(cmd);
    }

    public Integer getFocusPos(CameraCmd cmd) {
        return getSdk(cmd).getFocusPos(cmd);
    }

    public Boolean setPreset(CameraCmd cmd) {
        return getSdk(cmd).setPreset(cmd);
    }

    public Boolean gotoPreset(CameraCmd cmd) {
        return getSdk(cmd).gotoPreset(cmd);
    }

    public VideoCompressionCfg getVideoCompressionCfg(CameraCmd cmd) {
        return getSdk(cmd).getVideoCompressionCfg(cmd);
    }

    public Boolean controlDefog(CameraCmd cmd) {
        return getSdk(cmd).controlDefog(cmd);
    }

    public Boolean isEnableDefog(CameraCmd cmd) {
        return getSdk(cmd).isEnableDefog(cmd);
    }

    public Boolean controlInfrared(CameraCmd cmd) {
        return getSdk(cmd).controlInfrared(cmd);
    }

    public Boolean isEnableInfrared(CameraCmd cmd) {
        return getSdk(cmd).isEnableInfrared(cmd);
    }

    public Boolean controlFocusMode(CameraCmd cmd) {
        return getSdk(cmd).controlFocusMode(cmd);
    }

    public Boolean getFocusMode(CameraCmd cmd) {
        return getSdk(cmd).getFocusMode(cmd);
    }

    public Boolean controlPTHeater(CameraCmd cmd) {
        return getSdk(cmd).controlPTHeater(cmd);
    }

    public Boolean controlCameraDeicing(CameraCmd cmd) {
        return getSdk(cmd).controlCameraDeicing(cmd);
    }

    public Boolean getPTZLockInfo(CameraCmd cmd) {
        return getSdk(cmd).getPTZLockInfo(cmd);
    }

    public Boolean setPTZLockInfo(CameraCmd cmd) {
        return getSdk(cmd).setPTZLockInfo(cmd);
    }

    public byte[] localCapture(CameraCmd cmd) {
        return getSdk(cmd).localCapture(cmd);
    }

    public PtzScope getPtzScope(CameraCmd cmd) {
        return getSdk(cmd).getPtzScope(cmd);
    }

    public Boolean setZeroPtz(CameraCmd cmd) {
        return getSdk(cmd).setZeroPtz(cmd);
    }

    public Boolean set3DPosition(CameraCmd cmd) {
        return getSdk(cmd).set3DPosition(cmd);
    }

    public PtzParamDTO getGisInfo(CameraCmd cmd) {
        return getSdk(cmd).getGisInfo(cmd);
    }

    public Double correctPitch(CameraCmd cmd) {
        return getSdk(cmd).correctPitch(cmd);
    }

    // ========== 需要判断类型的操作 ==========

    public PtzDto getPtz(CameraCmd cmd) {
        return getSdk(cmd).getPtz(cmd);
    }

    @SdkOperate
    public Boolean setPtz(CameraCmd cmd) {
        return getSdk(cmd).setPtz(cmd);
    }

    // ========== 抓图（重载方法） ==========

    @SdkOperate
    public String picCutCate(CameraCmd cmd) {
        return getSdk(cmd).picCutCate(cmd);
    }

    @SdkOperate
    public String picCutCate(CameraCmd cmd, String bucketName, String objectName) {
        return getSdk(cmd).picCutCate(cmd, bucketName, objectName);
    }

    // ========== 录像 ==========
    public String record(CameraCmd cmd) {
        return getSdk(cmd).record(cmd);
    }

    public Boolean recordStart(CameraCmd cmd) {
        CameraSDK sdk = getSdk(cmd);
        Boolean result = sdk.recordStart(cmd);
        if (result != null && result) {
            RecordManager.addRecord(cmd.getCameraId() + "_" + cmd.getChanNo());
        }
        return result;
    }

    public String recordStop(CameraCmd cmd) {
        CameraSDK sdk = getSdk(cmd);
        String url = sdk.recordStop(cmd);
        String key = cmd.getCameraId() + "_" + cmd.getChanNo();
        RecordManager.stopRecord(key);
        return url;
    }

    // ========== 智能引导 ==========

    @SdkOperate
    public Boolean guideTargetPosition(CameraCmd cmd) {
        CameraSDK sdk = getSdk(cmd);
        ArdCamera camera = getCamera(cmd.getCameraId());
        String cameraId = camera.getId();

        // 判断是否超出引导距离
        if (isOutMaxDistance(cameraId, cmd.getTargetPosition())) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.OVER_GUIDANCE_RANGE.getCode(),
                    cameraId, "目标超出最大引导距离");
        }

        // 判断是否在不可视域
        if (isInNoViewingZone(cameraId, cmd.getTargetPosition())) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.BEYOND_VISIBILITY_RANGE.getCode(),
                    cameraId, "目标在不可视区域内");
        }

        cmd.setBaseYaw(camera.getBaseYaw());
        return sdk.guideTargetPosition(cmd);
    }

    // ========== 在线检测 ==========

    public boolean isOnLine(CameraCmd cmd) {
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            return false;
        }
        cmd.setLoginId(loginId);
        CameraSDK sdk = getSdk(cmd);
        return sdk.isOnLine(cmd);
    }

    // ========== 通道信息 ==========

    public List<ArdChannel> getChannels(ArdCamera camera) {
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, camera.getId());
        if (loginId == null) {
            return new ArrayList<>();
        }
        CameraSDK sdk = cameraSDKFactory.createCameraSDK(camera.getFactory());
        return sdk.getChannels(camera);
    }

    // ========== 视频标签 ==========

    public AjaxResult getCameraVideoLable(CameraCmd cmd) {
        CameraSDK sdk = cameraSDKFactory.createCameraSDK("1"); // 硬编码问题建议修复
        try {
            List<Map<String, Object>> result = sdk.getCameraVideoLable(SecurityUtils.getUserId(), cmd);
            return AjaxResult.success(result);
        } catch (ServiceException e) {
            return AjaxResult.error(e.getMessage());
        }
    }

    // ========== 定时任务 ==========

    @Scheduled(fixedRate = 30 * 1000)
    public void checkVideoTimeout() {
        Date now = new Date();
        RecordManager.getActiveRecords().forEach((name, date) -> {
            long duration = now.getTime() - date.getTime();
            if (duration > 15 * 60 * 1000) {
                CameraCmd cmd = new CameraCmd();
                String cameraId = name.split("_")[0];
                Integer chanNo = Integer.parseInt(name.split("_")[1]);
                cmd.setCameraId(cameraId);
                cmd.setChanNo(chanNo);
                recordStop(cmd);
                log.info("录像超时检测：停止{}_{}的录像,已录像时间超过15分钟", cameraId, chanNo);
            }
        });
    }

    // ========== 私有辅助方法 ==========

    /**
     * 获取SDK实例（会校验参数、相机存在性、在线状态）
     */
    private CameraSDK getSdk(CameraCmd cmd) {
        if (cmd == null || cmd.getCameraId() == null || cmd.getCameraId().isBlank()) {
            throw CameraSDKException.cameraNotExist(null);
        }

        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cmd.getCameraId());
        }
        cmd.setLoginId(loginId);

        ArdCamera camera = getCamera(cmd.getCameraId());
        return cameraSDKFactory.createCameraSDK(camera.getFactory());
    }

    /**
     * 获取相机信息（会校验存在性）
     */
    private ArdCamera getCamera(String cameraId) {
        ArdCamera camera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cameraId);
        if (camera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        return camera;
    }

    // 判断坐标是否超出引导范围
    private Boolean isOutMaxDistance(String cameraId, Point targetPoint) {
        ArdCamera camera = getCamera(cameraId);
        Point cameraCoordinate = new Point(camera.getLongitude(), camera.getLatitude(), camera.getAltitude());
        double distance = GisUtil.getDistance(cameraCoordinate, targetPoint);

        if (camera.getCamMaxVisibleDistance() == null) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.CAMERA_MAX_VISIBLE_DISTANCE_NULL.getCode(),
                    cameraId, CameraSDKException.ErrorCode.CAMERA_MAX_VISIBLE_DISTANCE_NULL.getMsg());
        }
        return distance > camera.getCamMaxVisibleDistance();
    }

    // 判断坐标是否在不可视域
    private Boolean isInNoViewingZone(String cameraId, Point targetPoint) {
        ArdNoViewingZone query = new ArdNoViewingZone();
        query.setCameraId(cameraId);
        List<ArdNoViewingZone> zones = ardNoViewingZoneService.selectArdNoViewingZoneList(query);
        if (zones.isEmpty()) {
            return false;
        }

        List<Point> points = new ArrayList<>();
        for (ArdNoViewingZone zone : zones) {
            String[] parts = zone.getPoi().split(",");
            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]));
                points.add(point);
            }
        }
        return GisUtil.isInPolygon(targetPoint, points);
    }
}