package com.ruoyi.approve.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.approve.mapper.ApproveFlowDefinitionMapper;
import com.ruoyi.approve.mapper.ApproveFlowNodeDefinitionMapper;
import com.ruoyi.approve.mapper.ApproveProcessMapper;
import com.ruoyi.approve.pojo.ApproveFlowDefinition;
import com.ruoyi.approve.pojo.ApproveFlowNodeDefinition;
import com.ruoyi.approve.pojo.ApproveProcess;
import com.ruoyi.approve.vo.ApproveFlowDefinitionVO;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.framework.web.domain.AjaxResult;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;

@RestController
@RequestMapping("/approveFlowDefinition")
public class ApproveFlowDefinitionController {
    private final ApproveFlowDefinitionMapper definitionMapper;
    private final ApproveFlowNodeDefinitionMapper nodeMapper;
    private final ApproveProcessMapper processMapper;

    public ApproveFlowDefinitionController(ApproveFlowDefinitionMapper definitionMapper,
                                           ApproveFlowNodeDefinitionMapper nodeMapper,
                                           ApproveProcessMapper processMapper) {
        this.definitionMapper = definitionMapper;
        this.nodeMapper = nodeMapper;
        this.processMapper = processMapper;
    }

    @GetMapping("/list")
    public AjaxResult list(Integer approveType) {
        LambdaQueryWrapper<ApproveFlowDefinition> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ApproveFlowDefinition::getTenantId, SecurityUtils.getLoginUser().getTenantId())
                .eq(ApproveFlowDefinition::getDeleteFlag, 0)
                .eq(approveType != null, ApproveFlowDefinition::getApproveType, approveType)
                .orderByDesc(ApproveFlowDefinition::getIsDefault)
                .orderByDesc(ApproveFlowDefinition::getUpdateTime);
        return AjaxResult.success(definitionMapper.selectList(wrapper));
    }

    @GetMapping("/{id}")
    public AjaxResult get(@PathVariable Long id) {
        ApproveFlowDefinition definition = getOwned(id);
        ApproveFlowDefinitionVO result = new ApproveFlowDefinitionVO();
        result.setDefinition(definition);
        result.setNodes(nodeMapper.selectList(new LambdaQueryWrapper<ApproveFlowNodeDefinition>()
                .eq(ApproveFlowNodeDefinition::getFlowDefinitionId, id)
                .eq(ApproveFlowNodeDefinition::getTenantId, definition.getTenantId())
                .eq(ApproveFlowNodeDefinition::getDeleteFlag, 0)
                .orderByAsc(ApproveFlowNodeDefinition::getNodeOrder)));
        return AjaxResult.success(result);
    }

    @PostMapping
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult add(@RequestBody ApproveFlowDefinitionVO request) {
        saveDefinition(request, false);
        return AjaxResult.success();
    }

    @PutMapping("/{id}")
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult update(@PathVariable Long id, @RequestBody ApproveFlowDefinitionVO request) {
        getOwned(id);
        request.getDefinition().setId(id);
        saveDefinition(request, true);
        return AjaxResult.success();
    }

    @PutMapping("/{id}/enabled")
    public AjaxResult enabled(@PathVariable Long id, @RequestParam Integer enabled) {
        ApproveFlowDefinition definition = getOwned(id);
        definition.setEnabled(enabled == null || enabled == 0 ? 0 : 1);
        definition.setUpdateUser(SecurityUtils.getUserId());
        definition.setUpdateTime(LocalDateTime.now());
        definitionMapper.updateById(definition);
        return AjaxResult.success();
    }

    @DeleteMapping("/{id}")
    public AjaxResult delete(@PathVariable Long id) {
        ApproveFlowDefinition definition = getOwned(id);
        Long activeCount = processMapper.selectCount(new LambdaQueryWrapper<ApproveProcess>()
                .eq(ApproveProcess::getTenantId, definition.getTenantId())
                .eq(ApproveProcess::getFlowDefinitionId, id)
                .eq(ApproveProcess::getApproveDelete, 0)
                .in(ApproveProcess::getApproveStatus, 0, 1));
        if (activeCount != null && activeCount > 0) throw new RuntimeException("该流程仍有进行中的审批，不能删除");
        definition.setDeleteFlag(1);
        definition.setUpdateUser(SecurityUtils.getUserId());
        definition.setUpdateTime(LocalDateTime.now());
        definitionMapper.updateById(definition);
        return AjaxResult.success();
    }

    private void saveDefinition(ApproveFlowDefinitionVO request, boolean update) {
        if (request == null || request.getDefinition() == null) throw new RuntimeException("流程定义不能为空");
        List<ApproveFlowNodeDefinition> nodes = request.getNodes() == null ? Collections.emptyList() : request.getNodes();
        if (nodes.isEmpty()) throw new RuntimeException("审批流程至少包含一个节点");
        Long tenantId = SecurityUtils.getLoginUser().getTenantId();
        Long userId = SecurityUtils.getUserId();
        ApproveFlowDefinition definition = request.getDefinition();
        definition.setTenantId(tenantId);
        definition.setUpdateUser(userId);
        definition.setUpdateTime(LocalDateTime.now());
        definition.setDeleteFlag(0);
        if (definition.getEnabled() == null) definition.setEnabled(1);
        if (definition.getIsDefault() == null) definition.setIsDefault(0);
        if (definition.getIsDefault() == 1) {
            List<ApproveFlowDefinition> oldDefaults = definitionMapper.selectList(new LambdaQueryWrapper<ApproveFlowDefinition>()
                    .eq(ApproveFlowDefinition::getTenantId, tenantId)
                    .eq(ApproveFlowDefinition::getApproveType, definition.getApproveType())
                    .eq(ApproveFlowDefinition::getIsDefault, 1)
                    .eq(ApproveFlowDefinition::getDeleteFlag, 0));
            oldDefaults.stream().filter(item -> !item.getId().equals(definition.getId())).forEach(item -> {
                item.setIsDefault(0);
                definitionMapper.updateById(item);
            });
        }
        if (update) {
            definitionMapper.updateById(definition);
            nodeMapper.delete(new LambdaQueryWrapper<ApproveFlowNodeDefinition>()
                    .eq(ApproveFlowNodeDefinition::getFlowDefinitionId, definition.getId())
                    .eq(ApproveFlowNodeDefinition::getTenantId, tenantId));
        } else {
            definition.setCreateUser(userId);
            definition.setCreateTime(LocalDateTime.now());
            definitionMapper.insert(definition);
        }
        int order = 1;
        for (ApproveFlowNodeDefinition node : nodes) {
            node.setId(null);
            node.setFlowDefinitionId(definition.getId());
            node.setNodeOrder(order++);
            node.setTenantId(tenantId);
            node.setCreateUser(userId);
            node.setUpdateUser(userId);
            node.setCreateTime(LocalDateTime.now());
            node.setUpdateTime(LocalDateTime.now());
            node.setDeleteFlag(0);
            if (node.getConditionOperator() == null) node.setConditionOperator("ALWAYS");
            nodeMapper.insert(node);
        }
    }

    private ApproveFlowDefinition getOwned(Long id) {
        ApproveFlowDefinition definition = definitionMapper.selectOne(new LambdaQueryWrapper<ApproveFlowDefinition>()
                .eq(ApproveFlowDefinition::getId, id)
                .eq(ApproveFlowDefinition::getTenantId, SecurityUtils.getLoginUser().getTenantId())
                .eq(ApproveFlowDefinition::getDeleteFlag, 0));
        if (definition == null) throw new RuntimeException("流程定义不存在");
        return definition;
    }
}