package com.cdzy.ebikemaintenance.controller;

import com.alibaba.fastjson2.JSONObject;
import com.cdzy.common.model.JsonResult;
import com.cdzy.common.model.ResGPSDto;
import com.cdzy.ebikemaintenance.model.dto.request.*;
import com.cdzy.ebikemaintenance.model.dto.response.*;
import com.cdzy.ebikemaintenance.model.pojo.*;
import com.cdzy.ebikemaintenance.service.*;
import com.cdzy.common.utils.ConvertUtil;
import com.cdzy.ebikemaintenance.utils.MinioUtil;
import com.cdzy.ebikemaintenance.utils.RedisUtil;
import com.ebike.feign.model.res.ReqEcuSnDto;
import com.ebike.feign.model.rsp.RspBikeInfo;
import com.mybatisflex.core.paginate.Page;
import com.mybatisflex.core.query.QueryWrapper;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;

import static com.cdzy.ebikemaintenance.model.pojo.table.EbikeBatteryInfoTableDef.EBIKE_BATTERY_INFO;
import static com.cdzy.ebikemaintenance.model.pojo.table.EbikeHelmetInfoTableDef.EBIKE_HELMET_INFO;

/**
 * 车辆基本信息 控制层。
 *
 * @author zjd
 * @since 2025-03-17
 */
@Slf4j
@RestController
@RequestMapping("/ebikeBikeInfo")
public class EbikeBikeInfoController {

    @Autowired
    private EbikeBikeInfoService ebikeBikeInfoService;
    @Autowired
    private EbikeEcuInfoService ebikeEcuInfoService;
    @Autowired
    private EbikeBatteryInfoService ebikeBatteryInfoService;
    @Autowired
    private EbikeHelmetInfoService ebikeHelmetInfoService;
    @Autowired
    private EbikeBikeCheckinService ebikeBikeCheckinService;
    @Resource
    private EbikeSystemInfoService ebikeSystemInfoService;
    @Autowired
    @Resource
    private RedisUtil redisUtil;
    @Autowired
    private MinioUtil minioUtil;


    /**
     * 整车信息保存
     *
     * @param reqEbikeBikeInfoDto 车辆基本信息
     * @return
     */
    @PostMapping("saveEbikeInfo")
    public JsonResult<?> saveEbikeInfo(@RequestBody ReqEbikeBikeInfoDto reqEbikeBikeInfoDto) {

        Boolean b = ebikeBikeInfoService.saveEbikeInfo(reqEbikeBikeInfoDto);
        if (b) {
            return JsonResult.success(true);
        }
        return JsonResult.failed("保存失败");
    }

    /**
     * 根据车辆ID 获取整车信息详情
     *
     * @param ebikeId 车辆ID
     * @return
     */
    @RequestMapping("getEbikeInfoById")
    public JsonResult<?> getEbikeInfoById(@RequestParam(name = "ebikeId") String ebikeId) {
        try {
            ReqEbikeBikeInfoDto reqEbikeBikeInfoDto = new ReqEbikeBikeInfoDto();
            EbikeBikeInfo ebikeBikeInfo = ebikeBikeInfoService.getById(ebikeId);
            BeanUtils.copyProperties(ebikeBikeInfo, reqEbikeBikeInfoDto);
            EbikeBatteryInfo ebikeBatteryInfo = ebikeBatteryInfoService.getById(ebikeBikeInfo.getBatteryId());
            EbikeHelmetInfo ebikeHelmetInfo = ebikeHelmetInfoService.getById(ebikeBikeInfo.getHelmetId());
            EbikeEcuInfo ebikeEcuInfo = ebikeEcuInfoService.getById(ebikeBikeInfo.getEcuId());
            reqEbikeBikeInfoDto.setEbikeBatteryInfo(ebikeBatteryInfo);
            reqEbikeBikeInfoDto.setEbikeHelmetInfo(ebikeHelmetInfo);
            reqEbikeBikeInfoDto.setEbikeEcuInfo(ebikeEcuInfo);
            //汉化状态
            String bike_state = ebikeBikeInfo.getState();
            if (bike_state == null || bike_state.isEmpty()) {
                bike_state = "0";
            }
            bike_state = ebikeSystemInfoService.getEbikeCarStatusName(Integer.valueOf(bike_state));
            reqEbikeBikeInfoDto.setState(bike_state);
            return JsonResult.success(reqEbikeBikeInfoDto);
        } catch (Exception e) {
            log.error("getEbikeInfoById===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed(e.getMessage());
        }

    }

    /**
     * 根据车辆编号 获取整车信息详情
     *
     * @param ebikeCode 车辆编号
     * @return
     */
    @RequestMapping("getEbikeInfoByCode")
    public JsonResult<?> getEbikeInfoByCode(@RequestParam(name = "ebikeCode") String ebikeCode) {
        try {
            ReqEbikeBikeInfoDto reqEbikeBikeInfoDto = new ReqEbikeBikeInfoDto();
            EbikeBikeInfo ebikeBikeInfo = ebikeBikeInfoService.getByBikeCode(ebikeCode);
            BeanUtils.copyProperties(ebikeBikeInfo, reqEbikeBikeInfoDto);
            EbikeBatteryInfo ebikeBatteryInfo = ebikeBatteryInfoService.getById(ebikeBikeInfo.getBatteryId());
            EbikeHelmetInfo ebikeHelmetInfo = ebikeHelmetInfoService.getById(ebikeBikeInfo.getHelmetId());
            EbikeEcuInfo ebikeEcuInfo = ebikeEcuInfoService.getById(ebikeBikeInfo.getEcuId());
            reqEbikeBikeInfoDto.setEbikeBatteryInfo(ebikeBatteryInfo);
            reqEbikeBikeInfoDto.setEbikeHelmetInfo(ebikeHelmetInfo);
            reqEbikeBikeInfoDto.setEbikeEcuInfo(ebikeEcuInfo);
            //汉化状态
            String bike_state = ebikeBikeInfo.getState();
            if (bike_state == null || bike_state.isEmpty()) {
                bike_state = "0";
            }
            bike_state = ebikeSystemInfoService.getEbikeCarStatusName(Integer.valueOf(bike_state));
            reqEbikeBikeInfoDto.setState(bike_state);
            return JsonResult.success(reqEbikeBikeInfoDto);
        } catch (Exception e) {
            log.error("getEbikeInfoByCode===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed(e.getMessage());
        }

    }

    /**
     * 根据车辆编号获取ecuSn
     *
     * @param bikeCode 车辆编号
     * @return
     */
    @GetMapping("getEbikeEcuSnByCode")
    public JsonResult<?> getEbikeEcuSnByID(@RequestParam(name = "bikeCode") String bikeCode) {
        String ecuSn = ebikeBikeInfoService.getEcuSnByBikeCode(bikeCode);
        if (ecuSn == null || ecuSn.isEmpty()) {
            return JsonResult.failed("获取车辆ECU信息失败");
        }
        return JsonResult.success("获取车辆ECU信息成功", ecuSn);
    }

    /**
     * 更换头盔
     *
     * @param ebikeBikeInfo 车辆基本信息
     * @return
     */
    @PostMapping("updateEbikeHelmet")
    public JsonResult<?> updateEbikeHelmet(@RequestBody ReqUpdateHelmetDto ebikeBikeInfo) {

        Boolean b = ebikeBikeInfoService.updateEbikeHelmet(ebikeBikeInfo);
        if (b) {
            return JsonResult.success(true);
        }
        return JsonResult.failed("保存失败");
    }

    /**
     * 根据头盔编号获取头盔信息
     *
     * @param helmetCode 头盔编号
     * @return
     */
    @RequestMapping("getHelmetInfo")
    public JsonResult<?> getHelmetInfo(@RequestParam(value = "helmetCode") String helmetCode) {

        try {
            ResEbikeHelmetInfoDto resEbikeHelmetInfoDto = new ResEbikeHelmetInfoDto();
            QueryWrapper queryWrapper = QueryWrapper.create();
            queryWrapper.eq(EBIKE_HELMET_INFO.HELMET_CODE.getName(), helmetCode);
            EbikeHelmetInfo one = ebikeHelmetInfoService.getOne(queryWrapper);
            BeanUtils.copyProperties(one, resEbikeHelmetInfoDto);
            return JsonResult.success(resEbikeHelmetInfoDto);
        } catch (Exception e) {
            log.error("getHelmetInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed(e.getMessage());
        }
    }

    ///**
    // * 更换中控
    // *
    // * @param reqUpdateEcuDto 车辆基本信息
    // * @return
    // */
//    @PostMapping("updateEbikeEcu")
//    public JsonResult<?> updateEbikeEcu(@RequestBody ReqUpdateEcuDto reqUpdateEcuDto) {
//        Boolean b = ebikeBikeInfoService.updateEbikeEcu(reqUpdateEcuDto);
//        if (b) {
//            return JsonResult.success(true);
//        }
//        return JsonResult.failed("保存失败");
//    }

    /**
     * 分页查询车辆信息列表
     *
     * @param request 查询参数
     * @return
     */
    @PostMapping("pageQueryEbikeList")
    public JsonResult<Object> pageQueryEbikeList(@RequestBody ReqEbikeCheckinDto request) {
        //查询车辆信息列表
        Page<ResInventoryBikeListDto> inventoryBikeListDtoPage = ebikeBikeInfoService.getInventoryBikeList(request);
        //汉化状态 改为leftJoin查询
        //inventoryBikeListDtoPage.getRecords().forEach(resInventoryBikeListDto -> {
        //    String bikeState = resInventoryBikeListDto.getState();
        //    if (bikeState == null || bikeState.isEmpty()) {
        //        bikeState = "0";
        //    }
        //    bikeState = ebikeSystemInfoService.getEbikeCarStatusName(Integer.valueOf(bikeState));
        //    resInventoryBikeListDto.setStateName(bikeState);
        //});
        return JsonResult.success(inventoryBikeListDtoPage);
    }

    /**
     * 获取库存车辆详情信息
     *
     * @param bikeId 车辆ID
     * @return
     */
    @RequestMapping("getInventoryBikeDetails")
    public JsonResult<?> getInventoryBikeDetails(@RequestParam(name = "bikeId") String bikeId) {
        ResInventoryBikeDetailsDto details = ebikeBikeInfoService.getInventoryBikeDetails(bikeId);
        if (details != null) {
            //查询车辆入库时间
            LocalDateTime bikeCheckinTime = ebikeBikeCheckinService.getBikeCheckinTime(details.getBikeId());
            if (bikeCheckinTime != null) {
                details.setEnterTime(bikeCheckinTime);
            }
            return JsonResult.success(details);
        }
        return JsonResult.failed("获取库存车辆详情信息失败");
    }

    /**
     * 根据车辆编号获取车辆基本信息
     *
     * @param bikeCode 车辆编号
     * @return
     */
    @RequestMapping("getBikeINfoData")
    public JsonResult<?> getBikeINfoData(@RequestParam(name = "bikeCode") String bikeCode) {

        Boolean b = ebikeBikeInfoService.inspectBikeHaveOrNot(bikeCode);
        if (!b) {
            return JsonResult.failed("车辆信息不存在");
        }
        ResEbikeBikeAndEcuCodeDto bikeINfoData = ebikeBikeInfoService.getBikeINfoData(bikeCode);
        if (bikeINfoData != null) {
            return JsonResult.success(bikeINfoData);
        }
        return JsonResult.failed("获取信息失败");
    }


    /**
     * 根据头盔编号、车辆编号获取车辆头盔信息
     *
     * @param helmetDto
     * @return
     */
    @RequestMapping("/getHelmetINfoData")
    public JsonResult<?> getHelmetINfoData(@RequestBody ReqEbikeHelmetDto helmetDto) {
        if ((helmetDto.getHelmetCode() == null || helmetDto.getHelmetCode().isEmpty()) && (helmetDto.getBikeCode() == null || helmetDto.getBikeCode().isEmpty())) {
            return JsonResult.failed("参数不能为空");
        }
        ResEbikeHelmetInfoDto2 helmetINfoData = ebikeHelmetInfoService.getHelmetINfoData(helmetDto);
        if (helmetINfoData != null) {
            ResEbikeHelmetInfoDto helmetInfoDto = new ResEbikeHelmetInfoDto();
            BeanUtils.copyProperties(helmetINfoData, helmetInfoDto);
            if (helmetINfoData.getEcuSn() != null && !helmetINfoData.getEcuSn().isEmpty()) {
                String jsonString = JSONObject.toJSONString(redisUtil.get(helmetINfoData.getEcuSn()));
                ResGPSDto resGpsDto = JSONObject.parseObject(jsonString, ResGPSDto.class);
                if (resGpsDto != null) {
                    helmetInfoDto.setUpdatedAt(ConvertUtil.timestampToDate(resGpsDto.getTimestamp().longValue()));
                    helmetInfoDto.setHelmetExit(resGpsDto.getHelmetExit() == '0' ? "不在位" : "在位");
                }
            }
            return JsonResult.success(helmetInfoDto);
        }
        return JsonResult.failed("获取信息失败");
    }

    /**
     * 解绑中控
     *
     * @param bikeId 车辆ID
     * @return
     */
    @PostMapping("untieEcu")
    public JsonResult<?> untieEcu(@RequestBody List<String> bikeId) {

        Boolean b = ebikeBikeInfoService.untieEcu(bikeId);
        if (b) {
            return JsonResult.success(true);
        }
        return JsonResult.failed("解绑失败");
    }

    /**
     * 更换二维码
     *
     * @param reqUpBikeCodeDto 更换二维码dto
     * @return
     */
    @PostMapping("updateBikeQRCode")
    public JsonResult<?> updateBikeQRCode(@RequestBody ReqUpBikeCodeDto reqUpBikeCodeDto) {

        Boolean b = ebikeBikeInfoService.updateBikeQRCode(reqUpBikeCodeDto);
        if (b) {
            return JsonResult.success(true);
        }
        return JsonResult.failed("更换成功");
    }

    /**
     * 车辆批量出库
     *
     * @param reqBulkDeliveryDto 车辆出库信息
     * @return
     */
    @PostMapping("vehicleLeaveWarehouse")
    public JsonResult<?> vehicleLeaveWarehouse(@RequestBody ReqBulkDeliveryDto reqBulkDeliveryDto) {

        Boolean b = ebikeBikeInfoService.vehicleLeaveWarehouse(reqBulkDeliveryDto);
        if (b) {
            return JsonResult.success(true);
        }
        return JsonResult.failed("出库失败");
    }


    /**
     * 文件上传
     *
     * @param multipartFile 文件对象
     * @return
     */
    @PostMapping(value = "fileUpload", consumes = "multipart/*", headers = "content-type=multipart/form-data")
    public JsonResult<?> fileUpload(@RequestParam("multipartFile") MultipartFile multipartFile) {

        try {
            minioUtil.createBucket(MinioUtil.BUCKET_FAULT);
            InputStream inputStream = multipartFile.getInputStream();
            String fileName = multipartFile.getOriginalFilename();
            String fileUniqueKey = UUID.randomUUID() + fileName.substring(fileName.lastIndexOf("."));
            minioUtil.uploadFile(inputStream, MinioUtil.BUCKET_FAULT, fileUniqueKey);
            String fileUrl = minioUtil.getFileUrl(MinioUtil.BUCKET_FAULT, fileUniqueKey);
            ResEbikeFaultReportFileDto resEbikeFaultReportFileDto = new ResEbikeFaultReportFileDto();
            resEbikeFaultReportFileDto.setUrl(fileUrl);
            resEbikeFaultReportFileDto.setFileUniqueKey(fileUniqueKey);
            //resEbikeFaultReportFileDto.setFileBucket(MinioUtil.BUCKET_FAULT);
            resEbikeFaultReportFileDto.setFileName(fileName);
            resEbikeFaultReportFileDto.setFileType(fileName.substring(fileName.lastIndexOf(".")));
            resEbikeFaultReportFileDto.setFileSize(multipartFile.getSize());
            return JsonResult.success(resEbikeFaultReportFileDto);
        } catch (Exception e) {
            log.error("fileUpload===>{}", e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("上传失败");
        }
    }

    /**
     * 删除附件
     *
     * @param fileUniqueKey 附件唯一标识
     * @return
     */
    @RequestMapping("deletedFile")
    public JsonResult<?> deletedFile(@RequestParam(name = "fileUniqueKey") String fileUniqueKey) {

        try {
            minioUtil.deleteObject(MinioUtil.BUCKET_FAULT, fileUniqueKey);
            return JsonResult.success("删除成功");
        } catch (Exception e) {
            log.error("deletedFile===>{}", e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("删除失败");
        }
    }

    /**
     * 故障上报提交
     *
     * @param reqEbikeBikeFaultReportDto 故障上报基本信息
     * @return
     */
    @PostMapping("faultReporting")
    public JsonResult<?> faultReporting(@RequestBody ReqEbikeBikeFaultReportDto reqEbikeBikeFaultReportDto) {

        Boolean b = ebikeBikeInfoService.faultReporting(reqEbikeBikeFaultReportDto);
        if (b) {
            return JsonResult.success(true);
        }
        return JsonResult.failed("提交失败");
    }

    /**
     * 获取当前车辆所有上报的故障列表
     *
     * @param bikeCode 车辆编号
     * @return
     */
    @RequestMapping("getFaultReportList")
    public JsonResult<?> getFaultReportList(@RequestParam(name = "bikeCode") String bikeCode) {
        return JsonResult.success(ebikeBikeInfoService.getFaultReportList(bikeCode));
    }

    /**
     * 检查是否有工单
     *
     * @param reqEbikeWorkOrderDto 工单基本信息
     * @return
     */
    @PostMapping("inspectHaveOrNotWorkOrder")
    public JsonResult<?> inspectHaveOrNotWorkOrder(@RequestBody ReqEbikeWorkOrderDto reqEbikeWorkOrderDto) {

        EbikeBikeOrder ebikeBikeOrder = ebikeBikeInfoService.inspectHaveOrNotWorkOrder(reqEbikeWorkOrderDto);
        if (ebikeBikeOrder != null) {
            return JsonResult.success("", ebikeBikeOrder.getOrderId());
        }
        return JsonResult.failed("没有找到相关工单信息");
    }

    /**
     * 故障领取创建工单
     *
     * @param reqEbikeBikeOrderDto 工单基本信息
     * @return
     */
    @PostMapping("createWorkOrder")
    public JsonResult<?> createWorkOrder(@RequestBody ReqEbikeBikeOrderDto reqEbikeBikeOrderDto) {

        String orderId = ebikeBikeInfoService.createWorkOrder(reqEbikeBikeOrderDto);
        if (!StringUtils.isEmpty(orderId)) {
            return JsonResult.success("", orderId);
        }
        return JsonResult.failed("领取失败");
    }

    /**
     * 根据车辆编号获取故障信息详情
     *
     * @param orderId 工单ID
     * @return
     */
    @RequestMapping("getFaultInfo")
    public JsonResult<?> getFaultInfo(@RequestParam(name = "orderId") String orderId) {

        try {
            return JsonResult.success(ebikeBikeInfoService.getFaultInfo(orderId));
        } catch (Exception e) {
            log.error("getFaultInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("获取信息失败");
        }
    }

    /**
     * 故障处理完成
     *
     * @param reqEbikeBikeFaultHandleDto 故障处理完成实体
     * @return
     */
    @PostMapping("faultHandelComplete")
    public JsonResult<?> faultHandelComplete(@RequestBody ReqEbikeBikeFaultHandleDto reqEbikeBikeFaultHandleDto) {

        Boolean b = ebikeBikeInfoService.faultHandelComplete(reqEbikeBikeFaultHandleDto);
        if (b) {
            return JsonResult.success(true);
        }
        return JsonResult.failed("处理失败");
    }

    /**
     * 根据车辆编号获取故障上报历史记录
     *
     * @param reqFaultHistoryListDto 查询参数
     * @return
     */
    @PostMapping("getFaultHistoryList")
    public JsonResult<?> getFaultHistoryList(@RequestBody ReqFaultHistoryListDto reqFaultHistoryListDto) {

        try {
            return JsonResult.success(ebikeBikeInfoService.getFaultHistoryList(reqFaultHistoryListDto));
        } catch (Exception e) {
            log.error("getFaultHistoryList===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("获取信息失败");
        }
    }

    /**
     * 获取指令记录列表
     *
     * @param reqInstructionRecordListDto 查询参数
     * @return
     */
    @PostMapping("getInstructionRecordList")
    public JsonResult<?> getInstructionRecordList(@RequestBody ReqInstructionRecordListDto reqInstructionRecordListDto) {
        try {
            return JsonResult.success(ebikeBikeInfoService.getInstructionRecordList(reqInstructionRecordListDto));
        } catch (Exception e) {
            log.error("getFaultHistoryList===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("获取信息失败");
        }
    }

    /**
     * 获取工单记录列表
     *
     * @param reqWorkOrderRecordListDto 查询参数
     * @return
     */
    @PostMapping("getWorkOrderRecordList")
    public JsonResult<?> getWorkOrderRecordList(@RequestBody ReqWorkOrderRecordListDto reqWorkOrderRecordListDto) {
        try {
            return JsonResult.success(ebikeBikeInfoService.getWorkOrderRecordList(reqWorkOrderRecordListDto));
        } catch (Exception e) {
            log.error("getFaultHistoryList===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("获取信息失败");
        }
    }

    /**
     * 取消工单
     *
     * @param orderId 工单ID
     * @return
     */
    @RequestMapping("canCellWorkOrder")
    public JsonResult<?> canCellWorkOrder(@RequestParam(name = "orderId") String orderId) {

        boolean b = ebikeBikeInfoService.canCellWorkOrder(orderId);
        if (b) {
            return JsonResult.success(true);
        }
        return JsonResult.failed("取消失败");
    }

    /**
     * 获取车辆信息详情
     *
     * @param reqEbikeGetBikeDetailsDto 车辆基本信息
     * @return
     */
    @PostMapping("getBikeDetailsINfoData")
    public JsonResult<?> getBikeDetailsINfoData(@RequestBody ReqEbikeGetBikeDetailsDto reqEbikeGetBikeDetailsDto) {

        try {
            return JsonResult.success(ebikeBikeInfoService.getBikeDetailsINfoData(reqEbikeGetBikeDetailsDto));
        } catch (Exception e) {
            log.error("getBikeDetailsINfoData===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("获取信息失败");
        }
    }


    /**
     * 根据EcuSn列表获取车辆信息
     *
     * @param ecuSnDto 中控SN码
     * @return 车辆基本信息列表
     */
    @PostMapping("getBikeByEcuSn")
    public JsonResult<?> getBikeByEcuSn(@RequestBody ReqEcuSnDto ecuSnDto) {
        List<RspBikeInfo> list = ebikeBikeInfoService.getBikeByEcuSn(ecuSnDto);
        return JsonResult.success(list);
    }

    /**
     * 获取定位基本信息
     *
     * @param reqEbikeGetBikeDetailsDto 车辆基本信息
     * @return
     */
    @PostMapping("getOrientationInfo")
    public JsonResult<?> getOrientationInfo(@RequestBody ReqEbikeGetBikeDetailsDto reqEbikeGetBikeDetailsDto) {

        try {
            return JsonResult.success(ebikeBikeInfoService.getOrientationInfo(reqEbikeGetBikeDetailsDto));
        } catch (Exception e) {
            log.error("getOrientationInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("获取信息失败");
        }
    }

    /**
     * 保存头盔信息
     *
     * @param helmetCodes 头盔编号
     * @return
     */
    @PostMapping("saveHelmetInfo")
    public JsonResult<?> saveHelmetInfo(@RequestBody List<String> helmetCodes) {

        try {
            List<EbikeHelmetInfo> ebikeHelmetInfos = new ArrayList<>();
            for (String helmetCode : helmetCodes) {
                QueryWrapper query = QueryWrapper.create();
                query.eq(EBIKE_HELMET_INFO.HELMET_CODE.getName(), helmetCode);
                EbikeHelmetInfo one = ebikeHelmetInfoService.getOne(query);
                if (one == null) {
                    EbikeHelmetInfo ebikeHelmetInfo = new EbikeHelmetInfo();
                    ebikeHelmetInfo.setHelmetCode(helmetCode);
                    ebikeHelmetInfos.add(ebikeHelmetInfo);
                }
            }
            if (!ebikeHelmetInfos.isEmpty()) {
                ebikeHelmetInfoService.saveBatch(ebikeHelmetInfos);
            }
            return JsonResult.success();
        } catch (Exception e) {
            log.error("saveHelmetInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("保存失败");
        }
    }

    /**
     * 保存电池信息
     *
     * @param batteryCodes 电池编号
     * @return
     */
    @PostMapping("saveBatteryInfo")
    public JsonResult<?> saveBatteryInfo(@RequestBody List<String> batteryCodes) {

        try {
            List<EbikeBatteryInfo> ebikeBatteryInfos = new ArrayList<>();
            for (String batteryCode : batteryCodes) {
                QueryWrapper query = QueryWrapper.create();
                query.eq(EBIKE_BATTERY_INFO.BATTERY_CODE.getName(), batteryCode);
                EbikeBatteryInfo one = ebikeBatteryInfoService.getOne(query);
                if (one == null) {
                    EbikeBatteryInfo ebikeBatteryInfo = new EbikeBatteryInfo();
                    ebikeBatteryInfo.setBatteryCode(batteryCode);
                    ebikeBatteryInfos.add(ebikeBatteryInfo);
                }
            }
            if (!ebikeBatteryInfos.isEmpty()) {
                ebikeBatteryInfoService.saveBatch(ebikeBatteryInfos);
            }
            return JsonResult.success();
        } catch (Exception e) {
            log.error("saveHelmetInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("保存失败");
        }
    }

    /**
     * 获取工单详情信息
     *
     * @param orderId 工单ID
     * @return
     */
    @RequestMapping("getWorkOrderInfo")
    public JsonResult<?> getWorkOrderInfo(@RequestParam(value = "orderId") String orderId) {
        try {
            return JsonResult.success(ebikeBikeInfoService.getWorkOrderInfo(orderId));
        } catch (Exception e) {
            log.error("getWorkOrderInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("获取信息失败");
        }
    }


    /**
     * 删除头盔信息
     *
     * @param helmetCodes 头盔编号
     * @return
     */
    @PostMapping("deleteHelmetInfo")
    public JsonResult<?> deleteHelmetInfo(@RequestBody List<String> helmetCodes) {
        try {
            List<String> ebikeHelmetIds = new ArrayList<>();
            for (String helmetCode : helmetCodes) {
                QueryWrapper query = QueryWrapper.create();
                query.eq(EBIKE_HELMET_INFO.HELMET_CODE.getName(), helmetCode);
                EbikeHelmetInfo one = ebikeHelmetInfoService.getOne(query);
                if (one == null) {
                    ebikeHelmetIds.add(one.getHelmetId());
                }
            }
            if (!ebikeHelmetIds.isEmpty()) {
                ebikeHelmetInfoService.removeByIds(ebikeHelmetIds);
            }
            return JsonResult.success();
        } catch (Exception e) {
            log.error("deleteHelmetInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("删除失败");
        }
    }


    /**
     * 删除电池信息
     *
     * @param batteryCodes 电池编号
     * @return
     */
    @PostMapping("deleteBatteryInfo")
    public JsonResult<?> deleteBatteryInfo(@RequestBody List<String> batteryCodes) {

        try {
            List<String> ebikeBatteryIds = new ArrayList<>();
            for (String batteryCode : batteryCodes) {
                QueryWrapper query = QueryWrapper.create();
                query.eq(EBIKE_BATTERY_INFO.BATTERY_CODE.getName(), batteryCode);
                EbikeBatteryInfo one = ebikeBatteryInfoService.getOne(query);
                if (one == null) {
                    ebikeBatteryIds.add(one.getBatteryId());
                }
            }
            if (!ebikeBatteryIds.isEmpty()) {
                ebikeBatteryInfoService.removeByIds(ebikeBatteryIds);
            }
            return JsonResult.success();
        } catch (Exception e) {
            log.error("deleteBatteryInfo===>" + e.getMessage() + Arrays.toString(e.getStackTrace()));
            return JsonResult.failed("删除失败");
        }
    }
    /**
     * 批量投放，创建车辆调度工单
     *
     * @param reqWorkOrderDispatchDto 车辆编号
     * @return
     */
    @PostMapping("createWorkOrderDispatch")
    public JsonResult<?> createWorkOrderDispatch(@RequestBody ReqWorkOrderDispatchDto reqWorkOrderDispatchDto) {

        String orderId = ebikeBikeInfoService.createWorkOrderDispatch(reqWorkOrderDispatchDto);
        if (!StringUtils.isEmpty(orderId)) {
            return JsonResult.success("", orderId);
        }
        return JsonResult.failed("创建调度工单失败");
    }
    /**
     *  根据工单id 获取调度车辆数据接口
     *
     * @param orderId 工单Id
     * @return
     */
    @GetMapping("getDispatchVehicleByOrderId")
    public JsonResult<?> getDispatchVehicleByOrderId(@RequestParam(name = "orderId")  String orderId) {
        ResDispatchVehicleDto resDispatchVehicleDto = ebikeBikeInfoService.getDispatchVehicleByOrderId(orderId);
        if (!StringUtils.isEmpty(resDispatchVehicleDto)) {
            return JsonResult.success("", resDispatchVehicleDto);
        }
        return JsonResult.failed("获取调度车辆数据失败！");
    }
    /**
     * 有工单-根据工单ID 车辆编号 新增调度车车辆
     * @param ebikeDispatchRecordDto
     */

    @PostMapping("createDispatchRecord")
    public JsonResult<?> createDispatchRecord(@RequestBody ReqEbikeDispatchRecordDto ebikeDispatchRecordDto) {
        EbikeDispatchRecords dispatchRecord = ebikeBikeInfoService.createDispatchRecord(ebikeDispatchRecordDto);
        if (!StringUtils.isEmpty(dispatchRecord)) {
            return JsonResult.success("", dispatchRecord);
        }else{
            return JsonResult.failed("车辆已经在调度列表中！");
        }
    }

    /**
     * 删除调度记录接口
     * @param recordId
     * @return
     */
    @GetMapping("deleteDispatchRecord")
    public JsonResult<?> deleteDispatchRecord(@RequestParam(name = "recordId") String recordId) {
        Boolean aBoolean = ebikeBikeInfoService.deleteDispatchRecord(recordId);
        if (aBoolean) {
            return JsonResult.success("删除成功", aBoolean);
        }
        return JsonResult.failed("删除失败！");
    }
}