package com.glxp.api.controller.basic;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.entity.auth.AuthAdmin;
import com.glxp.api.entity.auth.DeptEntity;
import com.glxp.api.entity.basic.SysApprovalFlow;
import com.glxp.api.entity.dev.DeviceChangeLogEntity;
import com.glxp.api.entity.dev.DeviceChangeOrderEntity;
import com.glxp.api.entity.dev.DeviceChangeOrderItemEntity;
import com.glxp.api.enums.ApprovalFlowEnum;
import com.glxp.api.enums.dev.DeviceChangeStatusEnum;
import com.glxp.api.enums.dev.DeviceChangeTypeEnum;
import com.glxp.api.enums.dev.DeviceStatusEnum;
import com.glxp.api.exception.JsonException;
import com.glxp.api.req.basic.SubmitApprovalFlowRequest;
import com.glxp.api.res.basic.SysApprovalFlowDetailResponse;
import com.glxp.api.service.auth.CustomerService;
import com.glxp.api.service.auth.DeptService;
import com.glxp.api.service.basic.SysApprovalFlowService;
import com.glxp.api.service.dev.DeviceChangeLogService;
import com.glxp.api.service.dev.DeviceChangeOrderItemService;
import com.glxp.api.service.dev.DeviceChangeOrderService;
import com.glxp.api.service.dev.DeviceInfoService;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.vo.dev.DeviceChangeOrderVo;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.validation.Valid;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

@Slf4j
@RestController
public class SysApprovalFlowController {

    @Resource
    private SysApprovalFlowService sysApprovalFlowService;
    @Resource
    private SystemParamConfigService systemParamConfigService;
    @Resource
    private DeviceChangeOrderService deviceChangeOrderService;
    @Resource
    private DeviceChangeOrderItemService deviceChangeOrderItemService;
    @Resource
    private DeviceInfoService deviceInfoService;
    @Resource
    private DeviceChangeLogService deviceChangeLogService;
    @Resource
    private DeptService deptService;
    @Resource
    private CustomerService customerService;

    @ApiOperation(value = "获取流程审批过程")
    @GetMapping("/udiwms/sysApprovalFlow/approvalFlowDetailList/{approvalFlowId}")
    public BaseResponse getDetailList(@PathVariable String approvalFlowId) {
        List<SysApprovalFlowDetailResponse> list = sysApprovalFlowService.getDetailList(approvalFlowId);
        return ResultVOUtils.success(list);
    }

    @ApiOperation(value = "提交节点审批")
    @PostMapping("/udiwms/sysApprovalFlow/submitApprovalFlow")
    public BaseResponse submitApprovalFlow(@RequestBody @Valid SubmitApprovalFlowRequest submitApprovalFlowRequest) {
        sysApprovalFlowService.submitApprovalFlow(submitApprovalFlowRequest);
        return ResultVOUtils.success();
    }

    @ApiOperation(value = "获取流程审批开关参数")
    @GetMapping("/udiwms/sysApprovalFlow/config")
    public BaseResponse getConfig() {
        Boolean sys_approval_flow = "1".equals(systemParamConfigService.selectValueByParamKey("sys_approval_flow"));
        return ResultVOUtils.success(sys_approval_flow);
    }

    @ApiOperation(value = "是否有节点审批权限")
    @GetMapping("/sysApprovalFlow/nodePermissions/{id}")
    public BaseResponse nodePermissions(@PathVariable String id) {
        boolean b = sysApprovalFlowService.nodePermissions(id);
        return ResultVOUtils.success(b);
    }

    @ApiOperation(value = "提交节点审批-设备一处")
    @PostMapping("/udiwms/sysApprovalFlow/submitApprovalFlow/sbyc")
    @Transactional(rollbackFor = Exception.class)
    public BaseResponse submitApprovalFlowSbyc(@RequestBody @Valid SubmitApprovalFlowRequest submitApprovalFlowRequest) {
        String approvalFlowMxId = submitApprovalFlowRequest.getId();
        sysApprovalFlowService.submitApprovalFlow(submitApprovalFlowRequest);

        //判断是否是最终状态为 审核通过 是 调用 审核通过的后续方法
        SysApprovalFlow sysApprovalFlow = sysApprovalFlowService.getApprovalFlowByMxId(approvalFlowMxId);
        Integer status = sysApprovalFlow.getStatus();
        if (status.equals(ApprovalFlowEnum.TG.getCode())){
            //后续方法
            String id = sysApprovalFlow.getId();
            DeviceChangeOrderEntity order = deviceChangeOrderService.getOne(Wrappers.lambdaQuery(DeviceChangeOrderEntity.class).eq(DeviceChangeOrderEntity::getApprovalFlowId, id));
            if (order == null){
                return ResultVOUtils.error("未找到对应的审批流程，请确认");
            }
            LocalDateTime now = LocalDateTime.now();
            Long userId = customerService.getUserId();
            AuthAdmin authUserDto = customerService.getUserBean();
            //查询创建人名称
            String userName = authUserDto.getEmployeeName();

            deviceChangeOrderService.update(Wrappers.lambdaUpdate(DeviceChangeOrderEntity.class)
                                    .set(DeviceChangeOrderEntity::getStatus, DeviceChangeStatusEnum.FINISH)
                                    .set(DeviceChangeOrderEntity::getConfirmTime, now)
                                    .set(DeviceChangeOrderEntity::getConfirmUser, userId)
                                    .set(DeviceChangeOrderEntity::getConfirmUserName, userName)
                                    .eq(DeviceChangeOrderEntity::getApprovalFlowId, id)
                                    .eq(DeviceChangeOrderEntity::getStatus, DeviceChangeStatusEnum.AUDITING));

            List<DeviceChangeOrderItemEntity> list = deviceChangeOrderItemService.list(Wrappers.lambdaQuery(DeviceChangeOrderItemEntity.class).eq(DeviceChangeOrderItemEntity::getOrderId, order.getOrderId()));
            if (CollectionUtil.isEmpty(list)){
                return ResultVOUtils.error("单据里待移除设备不存在，请确认");
            }
            List<DeviceChangeLogEntity> logs = new ArrayList<>();
            DeviceChangeOrderVo orderVo = BeanUtil.copyProperties(order, DeviceChangeOrderVo.class);
            orderVo.setConfirmTime(now);
            orderVo.setConfirmUser(userId);
            orderVo.setConfirmUserName(userName);
            DeptEntity dept = deptService.selectByCode(orderVo.getDeptCode());
            orderVo.setDeptName(dept.getName());
            if (orderVo.getToDeptCode().equals(orderVo.getDeptCode())) {
                orderVo.setToDeptName(dept.getName());
            } else {
                dept = deptService.selectByCode(orderVo.getToDeptCode());
                orderVo.setToDeptName(dept.getName());
            }
            list.forEach( i ->{
                deviceInfoService.changeStatus(i.getDeviceCode(), order.getDeptCode(), DeviceStatusEnum.NORMAL, order.getType() == DeviceChangeTypeEnum.CHANGE ? DeviceStatusEnum.CHANGE : DeviceStatusEnum.DESTROY);
                if (order.getType() == DeviceChangeTypeEnum.DESTROY) {
                    DeviceChangeLogEntity logEntity = DeviceChangeLogEntity.genEntity(i.getDeviceCode(), orderVo);
                    logs.add(logEntity);
                }
            });
            if (CollectionUtil.isNotEmpty(logs)) {
                deviceChangeLogService.saveBatch(logs);
            }
        }
        return ResultVOUtils.success();
    }
}