package com.ard.work.device.camera.controller;

import com.ard.common.core.constant.DeviceConstants;
import com.ard.common.core.domain.R;
import com.ard.common.core.utils.poi.ExcelUtil;
import com.ard.common.core.web.controller.BaseController;
import com.ard.common.core.web.domain.AjaxResult;
import com.ard.common.core.web.page.TableDataInfo;
import com.ard.common.log.annotation.Log;
import com.ard.common.log.enums.BusinessType;
import com.ard.common.security.annotation.InnerAuth;
import com.ard.common.security.annotation.RequiresPermissions;
import com.ard.common.security.utils.SecurityUtils;
import com.ard.work.api.domian.ArdCamera;
import com.ard.work.api.domian.CameraCmd;
import com.ard.work.device.camera.domain.CameraFilterDTO;
import com.ard.work.device.camera.domain.GeoDTO;
import com.ard.work.device.camera.service.IArdCameraService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 * 相机设备Controller
 *
 * @author ard
 * @date 2024-08-20
 */
@Slf4j
@RestController
@RequestMapping("/device/camera")
@Tag(name = "相机管理接口")
public class ArdCameraController extends BaseController {
    @Resource
    private IArdCameraService ardCameraService;

    /**
     * 查询相机设备列表
     */
    @RequiresPermissions("device:camera:list")
    @GetMapping("/list")
    @Operation(summary = "查询相机设备列表")
    public TableDataInfo list(ArdCamera ardCamera) {
        startPage();
        List<ArdCamera> list = ardCameraService.selectArdCameraList(ardCamera);
        return getDataTable(list);
    }

    /**
     * 查询相机设备列表
     */
    @InnerAuth
    @GetMapping("/list/all")
    public R<List<ArdCamera>> listAll() {
        List<ArdCamera> list = ardCameraService.selectArdCameraListAll(new ArdCamera());
        return R.ok(list);
    }

    /**
     * 根据条件查询相机设备列表
     */
    @InnerAuth
    @PostMapping("/list/rpc")
    public R<List<ArdCamera>> listAllRpc(@RequestBody ArdCamera ardCamera) {
        List<ArdCamera> list = ardCameraService.selectArdCameraListAll(ardCamera);
        return R.ok(list);
    }

    /**
     * 导出相机设备列表
     */
    @Operation(summary = "导出相机设备列表")
    @RequiresPermissions("device:camera:export")
    @Log(title = "相机设备", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, ArdCamera ardCamera) {
        List<ArdCamera> list = ardCameraService.selectArdCameraList(ardCamera);
        ExcelUtil<ArdCamera> util = new ExcelUtil<>(ArdCamera.class);
        util.exportExcel(response, list, "相机设备数据");
    }

    /**
     * 获取相机设备详细信息
     */
    @Operation(summary = "获取相机设备详细信息")
    @RequiresPermissions("device:camera:query")
    @GetMapping(value = "/{id}")
    public AjaxResult getInfo(@PathVariable("id") String id) {
        return success(ardCameraService.selectArdCameraById(id));
    }

    /**
     * 获取相机设备详细信息
     */
    @Operation(summary = "获取相机设备详细信息")
    @GetMapping(value = "/getCameraByName/{name}")
    public R<ArdCamera> getCameraByName(@PathVariable("name") String name) {
        return R.ok(ardCameraService.selectArdCameraByName(name));
    }

    /**
     * 获取相机设备详细信息
     */
    @InnerAuth
    @GetMapping(value = "/{id}/rpc")
    public R<ArdCamera> getInfoRpc(@PathVariable("id") String id) {
        return R.ok(ardCameraService.selectArdCameraById(id));
    }

    /**
     * 新增相机设备
     */
    @Operation(summary = "新增相机设备")
    @RequiresPermissions("device:cameras:add")
    @Log(title = "相机设备", businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody ArdCamera camera) {
        if (DeviceConstants.NOT_UNIQUE.equals(ardCameraService.checkCameraIpAndPortUnique(camera))) {
            return error("新增相机'" + camera.getIp() + ":" + camera.getPort() + "'失败，相机已存在");
        }
        int i = ardCameraService.insertArdCamera(camera);
        if (i > 0) {
            return success("新增相机'" + camera.getIp() + ":" + camera.getPort() + "'成功");
        }
        return error("新增相机'" + camera.getIp() + ":" + camera.getPort() + "'失败");
    }

    /**
     * 修改相机设备
     */
    @Operation(summary = "修改相机设备")
    @RequiresPermissions("device:camera:edit")
    @Log(title = "相机设备", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody ArdCamera camera) {
        if (DeviceConstants.NOT_UNIQUE.equals(ardCameraService.checkCameraIpAndPortUnique(camera))) {
            return error("修改相机'" + camera.getIp() + ":" + camera.getPort() + "'失败，相机已存在");
        }
        int i = ardCameraService.updateArdCamera(camera);
        if (i > 0) {
            return success("修改相机'" + camera.getIp() + ":" + camera.getPort() + "'成功");
        }
        return error("修改相机'" + camera.getIp() + ":" + camera.getPort() + "'失败");
    }
    /**
     * 修改相机设备
     */
    @InnerAuth
    @Log(title = "相机设备", businessType = BusinessType.UPDATE)
    @PutMapping("/rpc")
    public AjaxResult editRPC(@RequestBody ArdCamera camera) {
        if (DeviceConstants.NOT_UNIQUE.equals(ardCameraService.checkCameraIpAndPortUnique(camera))) {
            return error("修改相机'" + camera.getIp() + ":" + camera.getPort() + "'失败，相机已存在");
        }
        int i = ardCameraService.updateArdCamera(camera);
        if (i > 0) {
            return success("修改相机'" + camera.getIp() + ":" + camera.getPort() + "'成功");
        }
        return error("修改相机'" + camera.getIp() + ":" + camera.getPort() + "'失败");
    }

    @Operation(summary = "开关自动引导")
    @RequestMapping(value = "/updateAlarmGuideEnable",method = RequestMethod.POST)
    public AjaxResult updateAlarmGuideEnable(@RequestBody ArdCamera camera) {
        ardCameraService.updateAlarmGuideEnable(camera);
        return success();
    }

    /**
     * 修改相机坐标/基座偏航角
     */
    @InnerAuth
    @PutMapping("/rpc/updateCameraLocationAndYaw")
    public R<Integer> updateCameraLocationAndYaw(@RequestParam String cameraId,
                                           @RequestParam(required = false) Double longitude,
                                           @RequestParam(required = false) Double latitude,
                                           @RequestParam(required = false) Double altitude,
                                           @RequestParam(required = false) Float baseYaw) {
        return R.ok(ardCameraService.updateCameraLocationAndYaw(cameraId, longitude, latitude, altitude, baseYaw));
    }

    /**
     * 删除相机设备
     */
    @Operation(summary = "删除相机设备")
    @RequiresPermissions("device:camera:remove")
    @Log(title = "相机设备", businessType = BusinessType.DELETE)
    @DeleteMapping("/{ids}")
    public AjaxResult remove(@PathVariable String[] ids) {
        return toAjax(ardCameraService.deleteArdCameraByIds(ids));
    }

    /**
     * 导入相机设备
     */
    @Operation(summary = "导入相机设备")
    @Log(title = "导入相机设备", businessType = BusinessType.IMPORT)
    @RequiresPermissions("device:camera:import")
    @PostMapping("/importData")
    public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception {
        ExcelUtil<ArdCamera> util = new ExcelUtil<ArdCamera>(ArdCamera.class);
        List<ArdCamera> cameraList = util.importExcel(file.getInputStream());
        String operName = SecurityUtils.getLoginUser().getUsername();
        String message = ardCameraService.importCamera(cameraList, updateSupport, operName);
        return success(message);
    }

    /**
     * 相机设备导入模板
     */
    @Operation(summary = "相机设备导入模板")
    @PostMapping("/importTemplate")
    public void importTemplate(HttpServletResponse response) {
        ExcelUtil<ArdCamera> util = new ExcelUtil<ArdCamera>(ArdCamera.class);
        util.importTemplateExcel(response, "相机设备数据");
    }

    /**
     * 设置锁定
     */
    @Operation(summary = "设置锁定")
    @PostMapping("/setPTZLock")
    public AjaxResult setPTZLock(@RequestBody CameraCmd cmd) {
        cmd.setOperator(SecurityUtils.getUserId().toString());
        return ardCameraService.controlLock(cmd);
    }

    /**
     * 设置锁定
     */
    @InnerAuth
    @PostMapping("/setPTZLock/rpc")
    public R<AjaxResult> setPTZLockRpc(@RequestBody CameraCmd cmd) {
//        cmd.setOperator(SecurityUtils.getUserId().toString());
        return R.ok(ardCameraService.controlLock(cmd));
    }

    /**
     * 设置解锁
     */
    @Operation(summary = "设置解锁")
    @PostMapping("/setPTZUnLock")
    public AjaxResult setPTZUnLock(@RequestBody CameraCmd cmd) {
        cmd.setOperator(SecurityUtils.getUserId().toString());
        return ardCameraService.controlUnLock(cmd);
    }

    /**
     * 获取附近的相机
     */
    @RequiresPermissions("device:camera:list")
    @Operation(tags = "获取附近的相机")
    @PostMapping("/getNearbyCameras")
    public AjaxResult getNearbyCameras(@RequestBody CameraCmd cmd) {
        return AjaxResult.success(ardCameraService.getNearbyCameras(cmd));
    }

    /**
     * 获取附近的相机
     */
    @InnerAuth
    @PostMapping("/getNearbyCameras/rpc")
    public R<TreeMap<Double, ArdCamera>> getNearbyCamerasRpc(@RequestBody CameraCmd cmd) {
        return R.ok(ardCameraService.getNearbyCameras(cmd));
    }

    /**
     * 获取圆内的相机
     */
    @Operation(summary = "获取圆内的相机")
    @RequiresPermissions("device:camera:list")
    @PostMapping("/getCircularCameras")
    public AjaxResult getCircularCameras(@RequestBody GeoDTO geoDTO) {
        return AjaxResult.success(ardCameraService.getCircularCameras(geoDTO));
    }

    /**
     * 获取多边形内的相机
     */
    @Operation(summary = "获取多边形内的相机")
    @RequiresPermissions("device:camera:list")
    @PostMapping("/getPolygonCameras")
    public AjaxResult getPolygonCameras(@RequestBody GeoDTO geoDTO) {
        return AjaxResult.success(ardCameraService.getPolygonCameras(geoDTO));
    }

    /**
     * 获取雷达所在塔上的大光电
     */
    @Operation(summary = "获取雷达所在塔上的大光电")
    @GetMapping(value = "/{radarId}/getCameraByRadar")
    public AjaxResult getCameraByRadar(@PathVariable("radarId") String radarId) {
        return AjaxResult.success(ardCameraService.getCameraByRadar(radarId));
    }

    /**
     * 获取雷达所在塔上的大光电
     */
    @InnerAuth
    @GetMapping(value = "/{radarId}/getCameraByRadar/rpc")
    public R<ArdCamera> getCameraByRadarRpc(@PathVariable("radarId") String radarId) {
        return R.ok(ardCameraService.getCameraByRadar(radarId));
    }

    /**
     * 获取可视范围内的相机列表
     */
    @RequiresPermissions("device:camera:list")
    @PostMapping("/getCamerasInVisibleRange")
    @Operation(summary = "获取可视范围内的相机列表")
    public AjaxResult getCamerasInVisibleRange(@RequestBody CameraFilterDTO cameraFilterDTO) {
        return AjaxResult.success(ardCameraService.getCamerasInVisibleRange(cameraFilterDTO));
    }

    /**
     * 根据主键获取相机设备全部详细信息
     */
    @Operation(summary = "根据主键获取相机设备全部详细信息")
    @RequiresPermissions("device:camera:query")
    @GetMapping(value = "/getAllInfo/{id}")
    public AjaxResult getAllInfo(@PathVariable("id") String id) {
        return success(ardCameraService.selectArdCameraAllInfoById(id));
    }

    /**
     * 根据用户主键获取相机设备全部详细信息
     */
    @Operation(summary = "根据用户主键获取相机设备全部详细信息")
    @RequiresPermissions("device:camera:query")
    @GetMapping(value = "/getAllInfoByUserId")
    public AjaxResult getAllInfoByUserId() {
        return success(ardCameraService.selectArdCameraAllInfoByUserId(SecurityUtils.getUserId()));
    }

    /**
     * 根据经纬度获取设定范围内光电
     */
    @Operation(summary = "根据经纬度获取设定范围内光电")
    @RequiresPermissions("device:camera:getCameraAllInfoByPosition")
    @PostMapping(value = "/getCameraAllInfoByPosition")
    public AjaxResult getCameraAllInfoByPosition(@RequestBody Map<String,Number> para) {
        return success(ardCameraService.getCameraAllInfoByPosition(SecurityUtils.getUserId(),para));
    }

}