package com.dy.pipIrrWechat.irrigatePlan;

import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.common.webUtil.QueryResultVo;
import com.dy.pipIrrGlobal.pojoIr.IrIrrigatePlan;
import com.dy.pipIrrGlobal.pojoIr.IrIrrigateSchedule;
import com.dy.pipIrrGlobal.pojoIr.IrOpeningSchedule;
import com.dy.pipIrrGlobal.pojoIr.IrPlanOperate;
import com.dy.pipIrrGlobal.voIr.VoIrrigatePlan;
import com.dy.pipIrrGlobal.voIr.VoIrrigateSchedule;
import com.dy.pipIrrWechat.irrigatePlan.dto.IrrigatePlan;
import com.dy.pipIrrWechat.irrigatePlan.dto.IrrigateSchedule;
import com.dy.pipIrrWechat.irrigatePlan.dto.PlanSimple;
import com.dy.pipIrrWechat.irrigatePlan.enums.OperateTypeENUM;
import com.dy.pipIrrWechat.irrigatePlan.qo.QoIrrigatePlan;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import java.util.Date;
import java.util.List;
import java.util.Objects;

/**
 * @author ZhuBaoMin
 * @date 2025-02-20 15:27
 * @LastEditTime 2025-02-20 15:27
 * @Description
 */

@Slf4j
@RestController
@RequestMapping(path = "plan")
@RequiredArgsConstructor
public class IrrigatePlanCtrl {
    private final IrrigatePlanSv irrigatePlanSv;

    /**
     * 创建灌溉计划
     * 1. 添加灌溉计划
     * 2. 添加灌溉次序
     * 3. 添加灌溉计划操作记录
     * @param planAndSchedule
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "createPlan", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    public BaseResponse<Boolean> createPlan(@RequestBody @Valid IrrigatePlan planAndSchedule, BindingResult bindingResult){
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildErrorMsg(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long operatorId = planAndSchedule.getOperatorId();

        // 添加灌溉计划
        IrIrrigatePlan plan = new IrIrrigatePlan();
        plan.setProjectId(planAndSchedule.getProjectId());
        plan.setPlanName(planAndSchedule.getPlanName());
        plan.setStartupMode(planAndSchedule.getStartupMode());
        plan.setPlanStartTime(planAndSchedule.getPlanStartTime());
        plan.setPlanStopTime(planAndSchedule.getPlanStopTime());
        plan.setPlanState((byte)1);
        plan.setExecutingState((byte)1);
        plan.setDeleted(0L);

        Long planId = irrigatePlanSv.addIrrigatePlan(plan);
        if(planId == null) {
            return BaseResponseUtils.buildErrorMsg("创建灌溉计划失败");
        }

        // 添加灌溉次序
        if(planId != null){
            for(IrrigateSchedule schedule : planAndSchedule.getSchedules()){
                IrIrrigateSchedule po = new IrIrrigateSchedule();
                po.setPlanId(planId);

                if(planAndSchedule.getIrrigateType() == 1) {
                    po.setGroupId(schedule.getIrrigateId());
                    List<Long> intakesData = irrigatePlanSv.getIntakesByGroupId(schedule.getIrrigateId());
                    if(intakesData != null && intakesData.size() > 0){
                        String intakeIds = "";
                        for(Long intakeId : intakesData){
                            intakeIds += intakeId + ",";
                        }
                        po.setIntakeIds(intakeIds.substring(0, intakeIds.length() - 1));
                    }
                }else {
                    po.setUnitId(schedule.getIrrigateId());
                    Long intakeId = irrigatePlanSv.getIntakeIdByUnitId(schedule.getIrrigateId());
                    if(intakeId != null){
                        po.setIntakeIds(intakeId.toString());
                    }
                }

                po.setStartTime(schedule.getStartTime());
                po.setStopTime(schedule.getStopTime());
                po.setCurrentState((byte)1);
                Long scheduleId = irrigatePlanSv.addIrrigateSchedule(po);
            }
        }

        // 添加灌溉计划操作记录
        IrPlanOperate planOperate  = new IrPlanOperate();
        planOperate.setPlanId(planId);
        planOperate.setOperator(operatorId);
        planOperate.setOperateType(OperateTypeENUM.CREATE.getCode());
        planOperate.setOperateTime(new Date());
        if(irrigatePlanSv.addPlanOperate(planOperate) == 0){
            return BaseResponseUtils.buildErrorMsg("添加灌溉计划操作记录失败");
        }

        return BaseResponseUtils.buildSuccess();
    }

    /**
     * 发布灌溉计划
     * 1. 修改灌溉计划状态为发布状态
     * 2. 添加灌溉计划操作记录
     * 3. 生成开阀计划
     * @param planSimple
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "publishPlan", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    public BaseResponse<Boolean> publishPlan(@RequestBody @Valid PlanSimple planSimple, BindingResult bindingResult){
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildErrorMsg(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }
        Long planId = planSimple.getPlanId();
        Long operatorId = planSimple.getOperatorId();

        // 修改灌溉计划状态为发布状态
        if(irrigatePlanSv.publishIrrigatePlan(planId) == 0){
            return BaseResponseUtils.buildErrorMsg("修改灌溉计划状态失败");
        }

        // 添加灌溉计划操作记录
        IrPlanOperate planOperate  = new IrPlanOperate();
        planOperate.setPlanId(planId);
        planOperate.setOperator(operatorId);
        planOperate.setOperateType(OperateTypeENUM.PUBLISH.getCode());
        planOperate.setOperateTime(new Date());
        if(irrigatePlanSv.addPlanOperate(planOperate) == 0){
            return BaseResponseUtils.buildErrorMsg("添加灌溉计划操作记录失败");
        }

        // 生成开阀计划
        List<VoIrrigateSchedule> schedules = irrigatePlanSv.getIrrigateSchedules(planId);
        if(schedules == null || schedules.size() == 0) {
            return BaseResponseUtils.buildErrorMsg("无取水口，生成开阀计划失败");
        }
        for (VoIrrigateSchedule schedule : schedules) {
            for(String intakeId : schedule.getIntakeIds().split(",")){
                // 添加灌溉计划开启记录
                IrOpeningSchedule openingSchedule = new IrOpeningSchedule();
                openingSchedule.setScheduleId(schedule.getScheduleId());
                openingSchedule.setIntakeId(Long.parseLong(intakeId));
                openingSchedule.setStartTime(schedule.getStartTime());
                openingSchedule.setDuration(schedule.getDuration());
                if(irrigatePlanSv.addOpeningSchedule(openingSchedule) == 0){
                    return BaseResponseUtils.buildErrorMsg("添加开阀计划失败");
                }
            }
        }
        return BaseResponseUtils.buildSuccess();
    }

    /**
     * 获取灌溉计划列表
     * @param vo
     * @return
     */
    @GetMapping(path = "/getIrrigatePlans")
    public BaseResponse<QueryResultVo<List<VoIrrigatePlan>>> getIrrigatePlans(QoIrrigatePlan vo) {
        try {
            QueryResultVo<List<VoIrrigatePlan>> res = irrigatePlanSv.getIrrigatePlans(vo);
            return BaseResponseUtils.buildSuccess(res);
        } catch (Exception e) {
            log.error("获取轮灌组记录异常", e);
            return BaseResponseUtils.buildException(e.getMessage());
        }
    }
}