package org.jeecg.modules.eam.controller;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.modules.eam.constant.BusinessCodeConst;
import org.jeecg.modules.eam.constant.OrderCreationMethodEnum;
import org.jeecg.modules.eam.constant.SecondMaintenanceStatusEnum;
import org.jeecg.modules.eam.entity.EamSecondMaintenanceOrder;
import org.jeecg.modules.eam.entity.EamWeekMaintenanceOrder;
import org.jeecg.modules.eam.request.EamSecondMaintenanceQuery;
import org.jeecg.modules.eam.request.EamSecondMaintenanceRequest;
import org.jeecg.modules.eam.request.EamWeekMaintenanceRequest;
import org.jeecg.modules.eam.service.IEamSecondMaintenanceOrderService;
import org.jeecg.modules.system.service.ISysBusinessCodeRuleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Description: 设备二级保养
 * @Author: jeecg-boot
 * @Date: 2025-04-29
 * @Version: V1.0
 */
@Slf4j
@Api(tags = "设备二级保养")
@RestController
@RequestMapping("/eam/secondMaintenanceOrder")
public class EamSecondMaintenanceOrderController extends JeecgController<EamSecondMaintenanceOrder, IEamSecondMaintenanceOrderService> {
    @Autowired
    private IEamSecondMaintenanceOrderService eamSecondMaintenanceOrderService;
    @Autowired
    private ISysBusinessCodeRuleService businessCodeRuleService;


    /**
     * 分页列表查询
     *
     * @param query
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    @AutoLog(value = "设备二级保养-分页列表查询")
    @ApiOperation(value = "设备二级保养-分页列表查询", notes = "设备二级保养-分页列表查询")
    @GetMapping(value = "/list")
    public Result<?> queryPageList(EamSecondMaintenanceQuery query,
                                   @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                   @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                   HttpServletRequest req) {
//		QueryWrapper<EamSecondMaintenanceOrder> queryWrapper = QueryGenerator.initQueryWrapper(eamSecondMaintenanceOrder, req.getParameterMap());
        Page<EamSecondMaintenanceOrder> page = new Page<EamSecondMaintenanceOrder>(pageNo, pageSize);
        IPage<EamSecondMaintenanceOrder> pageList = eamSecondMaintenanceOrderService.queryPageList(page, query);
        return Result.OK(pageList);
    }

    /**
     * 添加
     *
     * @param request
     * @return
     */
    @AutoLog(value = "设备二级保养-添加")
    @ApiOperation(value = "设备二级保养-添加", notes = "设备二级保养-添加")
    @PostMapping(value = "/add")
    public Result<?> add(@RequestBody EamSecondMaintenanceRequest request) {
        if (request == null) {
            return Result.error("添加的对象不能为空！");
        }
        if (StrUtil.isEmpty(request.getStandardId())) {
            return Result.error("保养项不能为空！");
        }
        String codeSeq = businessCodeRuleService.generateBusinessCodeSeq(BusinessCodeConst.SECOND_MAINTENANCE_CODE_RULE);
        request.setOrderNum(codeSeq);
        request.setCreationMethod(OrderCreationMethodEnum.MANUAL.name());
        boolean b = eamSecondMaintenanceOrderService.addMaintenance(request);
        if (!b) {
            return Result.error("添加失败！");
        }
        return Result.OK("添加成功！");
    }

    /**
     * 批量添加
     * @param requests
     * @return
     */
    @AutoLog(value = "设备二级保养-批量添加")
    @ApiOperation(value = "设备二级保养-批量添加", notes = "设备二级保养-批量添加")
    @PostMapping(value = "/batchAdd")
    public Result<?> batchAdd(@RequestBody List<EamSecondMaintenanceRequest> requests) {
        if (CollectionUtils.isEmpty(requests)) {
            return Result.error("添加的对象列表不能为空！");
        }

        // 记录成功/失败的条目
        List<String> successOrders = new ArrayList<>();
        List<Map<String, Object>> failedItems = new ArrayList<>();

        for (int i = 0; i < requests.size(); i++) {
            EamSecondMaintenanceRequest item = requests.get(i);
            try {
                // 1. 参数校验
                if (item == null) {
                    failedItems.add(createErrorItem(i, "对象为空"));
                    continue;
                }
                if (StrUtil.isEmpty(item.getStandardId())) {
                    failedItems.add(createErrorItem(i, "保养项不能为空"));
                    continue;
                }

                // 2. 生成编码并设置属性
                String codeSeq = businessCodeRuleService.generateBusinessCodeSeq(
                        BusinessCodeConst.SECOND_MAINTENANCE_CODE_RULE);
                item.setOrderNum(codeSeq);
                item.setCreationMethod(OrderCreationMethodEnum.MANUAL.name());

                // 3. 执行添加
                if (eamSecondMaintenanceOrderService.addMaintenance(item)) {
                    successOrders.add(codeSeq);
                } else {
                    failedItems.add(createErrorItem(i, "服务添加失败"));
                }
            } catch (Exception e) {
                failedItems.add(createErrorItem(i, "系统异常: " + e.getMessage()));
            }
        }

        // 4. 构造返回结果
        if (failedItems.isEmpty()) {
            return Result.OK("批量添加成功，共添加" + successOrders.size() + "条记录");
        } else {
            Map<String, Object> result = new HashMap<>();
            result.put("successCount", successOrders.size());
            result.put("failedCount", failedItems.size());
            result.put("failedDetails", failedItems);

            return Result.OK(
                    "部分添加失败（成功" + successOrders.size() + "条，失败" + failedItems.size() + "条）",
                    result
            );
        }
    }

    // 创建错误条目信息
    private Map<String, Object> createErrorItem(int index, String reason) {
        Map<String, Object> error = new HashMap<>();
        error.put("index", index);
        error.put("reason", reason);
        return error;
    }

    /**
     * 创建错误项详情
     * @param id 工单ID
     * @param errorMessage 错误信息
     * @param detail 错误详情
     * @return 错误详情Map
     */
    private Map<String, Object> createErrorItem(String id, String errorMessage, Object detail) {
        Map<String, Object> errorItem = new HashMap<>();
        errorItem.put("id", id);
        errorItem.put("error", errorMessage);
        if (detail != null) {
            errorItem.put("detail", detail);
        }
        return errorItem;
    }

    /**
     * 构建批量操作返回结果
     * @param successCount 成功数量
     * @param failedDetails 失败详情列表
     * @param actionName 操作名称（"作废"或"还原"）
     * @return 统一格式的返回结果
     */
    private Result<?> buildBatchResult(int successCount,
                                       List<Map<String, Object>> failedDetails,
                                       List<String> successIds,
                                       String actionName) {
        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("successCount", successCount);
        resultMap.put("failedCount", failedDetails.size());
        resultMap.put("successIds", successIds);
        resultMap.put("failedDetails", failedDetails);

        if (failedDetails.isEmpty()) {
            return Result.OK("批量" + actionName + "成功，共" + actionName + " " + successCount + " 条工单！"+resultMap);
        } else {
            return Result.OK("批量" + actionName + "部分成功（成功" + successCount + "条，失败" + failedDetails.size() + "条）"+resultMap.get("failedDetails"));
        }
    }


    /**
     * 编辑
     *
     * @param request
     * @return
     */
    @AutoLog(value = "设备二级保养-编辑")
    @ApiOperation(value = "设备二级保养-编辑", notes = "设备二级保养-编辑")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT, RequestMethod.POST})
    public Result<?> edit(@RequestBody EamSecondMaintenanceRequest request) {
        if (request == null) {
            return Result.error("添加的对象不能为空！");
        }
        if (StrUtil.isEmpty(request.getStandardId())) {
            return Result.error("保养项不能为空！");
        }
        boolean b = eamSecondMaintenanceOrderService.editMaintenance(request);
        if (!b) {
            return Result.error("编辑失败！");
        }
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id查询
     *
     * @param id
     * @return
     */
    @AutoLog(value = "设备二级保养-通过id查询")
    @ApiOperation(value = "设备二级保养-通过id查询", notes = "设备二级保养-通过id查询")
    @GetMapping(value = "/queryById")
    public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
        EamSecondMaintenanceOrder eamSecondMaintenanceOrder = eamSecondMaintenanceOrderService.getById(id);
        return Result.OK(eamSecondMaintenanceOrder);
    }

    /**
     * 通过id作废
     *
     * @param id
     * @return
     */
    @AutoLog(value = "设备二级保养-作废")
    @ApiOperation(value = "设备二级保养-作废", notes = "设备二级保养-作废")
    @DeleteMapping(value = "/abolish")
    public Result<?> abolish(@RequestParam(name = "id", required = true) String id) {
        EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
        if (entity == null) {
            return Result.error("要作废的数据不存在，请刷新重试！");
        }
        if (!SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name().equals(entity.getMaintenanceStatus())) {
            return Result.error("该状态的数据不允许进行作废！");
        }
        entity.setMaintenanceStatus(SecondMaintenanceStatusEnum.ABOLISH.name());
        eamSecondMaintenanceOrderService.updateById(entity);
        return Result.OK("作废成功!");
    }

    @AutoLog(value = "周保工单-批量作废")
    @ApiOperation(value = "周保工单-批量作废", notes = "周保工单-批量作废")
    @DeleteMapping(value = "/abolishBatch")
    public Result<?> abolishBatch(@RequestParam(name = "ids", required = true) String ids) {
        List<String> list = Arrays.asList(ids.split(","));

        // 记录操作结果
        int successCount = 0;
        List<Map<String, Object>> failedDetails = new ArrayList<>();
        List<String> successIds = new ArrayList<>();

        for (String id : list) {
            try {
                EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
                if (entity == null) {
                    // 记录工单不存在
                    failedDetails.add(createErrorItem(id, "工单不存在", null));
                    continue;
                }

                if (!SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name().equals(entity.getMaintenanceStatus())) {
                    // 记录状态不符合要求
                    failedDetails.add(createErrorItem(id, "工单状态不满足作废要求", entity.getMaintenanceStatus()));
                    continue;
                }

                entity.setMaintenanceStatus(SecondMaintenanceStatusEnum.ABOLISH.name());
                boolean updateResult = eamSecondMaintenanceOrderService.updateById(entity);

                if (updateResult) {
                    successCount++;
                    successIds.add(id);
                } else {
                    // 记录更新失败
                    failedDetails.add(createErrorItem(id, "更新操作执行失败", entity.getMaintenanceStatus()));
                }
            } catch (Exception e) {
                // 记录系统异常
                failedDetails.add(createErrorItem(id, "系统异常: " + e.getMessage(), null));
            }
        }

        // 构造返回结果
        return buildBatchResult(successCount, failedDetails, successIds, "作废");
    }

    /**
     * 还原作废工单
     * @param id
     * @return
     */
    @AutoLog(value = "设备二级保养-还原作废工单")
    @ApiOperation(value = "设备二级保养-还原作废工单", notes = "设备二级保养-还原作废工单")
    @GetMapping(value = "/restore")
    public Result<?> restore(@RequestParam(name = "id", required = true) String id) {
        EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
        if (entity == null) {
            return Result.error("要还原的作废数据不存在，请刷新重试！");
        }
        if (!SecondMaintenanceStatusEnum.ABOLISH.name().equals(entity.getMaintenanceStatus())) {
            return Result.error("该状态的数据不允许进行还原！");
        }
        //查询当前设备和保养规范id是否有值
        List<EamSecondMaintenanceOrder> eamSecondMaintenanceOrderList=eamSecondMaintenanceOrderService
                .list(new QueryWrapper<EamSecondMaintenanceOrder>().eq("equipment_id",entity.getEquipmentId())
                        .eq("standard_id",entity.getStandardId())
                        .ne("maintenance_status",SecondMaintenanceStatusEnum.ABOLISH.name()));
        if(!eamSecondMaintenanceOrderList.isEmpty()){
            return Result.error("该设备已存在对应二保工单，不允许还原!");
        }
        entity.setMaintenanceStatus(SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name());
        eamSecondMaintenanceOrderService.updateById(entity);
        return Result.OK("还原成功!");
    }

    /**
     * 批量还原作废工单
     * @param ids
     * @return
     */
    @AutoLog(value = "设备二级保养-批量还原作废工单")
    @ApiOperation(value = "设备二级保养-批量还原作废工单", notes = "设备二级保养-批量还原作废工单")
    @DeleteMapping(value = "/restoreBatch")
    public Result<?> restoreBatch(@RequestParam(name = "ids", required = true) String ids) {
        List<String> list = Arrays.asList(ids.split(","));

        // 记录操作结果
        int successCount = 0;
        List<Map<String, Object>> failedDetails = new ArrayList<>();
        List<String> successIds = new ArrayList<>();

        for (String id : list) {
            try {
                EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
                if (entity == null) {
                    // 记录工单不存在
                    failedDetails.add(createErrorItem(id, "工单不存在", null));
                    continue;
                }

                if (!SecondMaintenanceStatusEnum.ABOLISH.name().equals(entity.getMaintenanceStatus())) {
                    // 记录状态不是已作废
                    failedDetails.add(createErrorItem(id, "工单状态不是已作废", entity.getMaintenanceStatus()));
                    continue;
                }

                // 查询当前设备和保养规范是否存在非作废状态的工单
                List<EamSecondMaintenanceOrder> existingOrders = eamSecondMaintenanceOrderService
                        .list(new QueryWrapper<EamSecondMaintenanceOrder>()
                                .eq("equipment_id", entity.getEquipmentId())
                                .eq("standard_id", entity.getStandardId())
                                .ne("maintenance_status", SecondMaintenanceStatusEnum.ABOLISH.name()));

                if (CollectionUtils.isNotEmpty(existingOrders)) {
                    // 记录存在非作废状态的工单
                    failedDetails.add(createErrorItem(id, "该设备和保养规范已存在非作废状态的工单", existingOrders.size()));
                    continue;
                }

                entity.setMaintenanceStatus(SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name());
                boolean updateResult = eamSecondMaintenanceOrderService.updateById(entity);

                if (updateResult) {
                    successCount++;
                    successIds.add(id);
                } else {
                    // 记录更新失败
                    failedDetails.add(createErrorItem(id, "更新操作执行失败", entity.getMaintenanceStatus()));
                }
            } catch (Exception e) {
                // 记录系统异常
                failedDetails.add(createErrorItem(id, "系统异常: " + e.getMessage(), null));
            }
        }

        // 构造返回结果
        return buildBatchResult(successCount, failedDetails, successIds, "还原");
    }

    /**
     * 通过id领取
     *
     * @param id
     * @return
     */
    @AutoLog(value = "设备二级保养-领取")
    @ApiOperation(value = "设备二级保养-领取", notes = "设备二级保养-领取")
    @GetMapping(value = "/collect")
    public Result<?> collect(@RequestParam(name = "id", required = true) String id) {
        boolean b = eamSecondMaintenanceOrderService.collect(id);
        if (!b) {
            Result.OK("领取失败!");
        }
        return Result.OK("领取成功!");
    }

    /**
     * 通过id批量领取
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "设备二级保养-批量领取")
    @ApiOperation(value = "设备二级保养-批量领取", notes = "设备二级保养-批量领取")
    @DeleteMapping(value = "/collectBatch")
    public Result<?> collectBatch(@RequestParam(name = "ids", required = true) String ids) {
        List<String> list = Arrays.asList(ids.split(","));

        // 记录操作结果
        int successCount = 0;
        List<Map<String, Object>> failedDetails = new ArrayList<>();
        List<String> successIds = new ArrayList<>();

        for (String id : list) {
            try {
                EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.getById(id);
                if (entity == null) {
                    // 记录工单不存在
                    failedDetails.add(createErrorItem(id, "工单不存在", null));
                    continue;
                }

                // 状态校验
                if (!SecondMaintenanceStatusEnum.WAIT_MAINTENANCE.name().equals(entity.getMaintenanceStatus())) {
                    failedDetails.add(createErrorItem(id,
                            "工单当前状态不满足领取条件",
                            entity.getMaintenanceStatus()));
                    continue;
                }

                // 执行领取操作
                boolean collectResult = eamSecondMaintenanceOrderService.collect(id);

                if (collectResult) {
                    successCount++;
                    successIds.add(id);
                } else {
                    failedDetails.add(createErrorItem(id, "领取操作执行失败", null));
                }
            } catch (Exception e) {
                failedDetails.add(createErrorItem(id, "系统异常: " + e.getMessage(), null));
            }
        }

        // 构造返回结果（使用与批量作废/还原相同的方法）
        return buildBatchResult(successCount, failedDetails, successIds, "领取");
    }

    /**
     * 我的待办，审批动作
     *
     * @param request
     * @return
     */
    @ApiOperation(value = "二保工单-执行操作", notes = "二保工单-执行操作")
    @PutMapping(value = "/approval")
    public Result<?> approval(@RequestBody EamSecondMaintenanceRequest request) {
        if (request == null) {
            return Result.error("审批的对象不能为空！");
        }
        if (StrUtil.isEmpty(request.getStandardId())) {
            return Result.error("保养项不能为空！");
        }
        // 检查请求参数
        if (StrUtil.isBlank(request.getTaskId()) || StrUtil.isBlank(request.getDataId()) || StrUtil.isBlank(request.getInstanceId())) {
            return Result.error("审批任务错误或不存在！");
        }
        EamSecondMaintenanceOrder entity = eamSecondMaintenanceOrderService.approval(request);
        if (entity == null) {
            return Result.error("操作失败！");
        }
        return Result.ok("操作成功！");
    }
}