package com.ruoyi.approve.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruoyi.approve.enums.ApproveType;
import com.ruoyi.approve.mapper.ApproveFlowDefinitionMapper;
import com.ruoyi.approve.mapper.ApproveFlowNodeDefinitionMapper;
import com.ruoyi.approve.mapper.ApproveNodeMapper;
import com.ruoyi.approve.mapper.ApproveProcessMapper;
import com.ruoyi.approve.pojo.ApproveFlowDefinition;
import com.ruoyi.approve.pojo.ApproveFlowNodeDefinition;
import com.ruoyi.approve.pojo.ApproveNode;
import com.ruoyi.approve.pojo.ApproveProcess;
import com.ruoyi.approve.service.IApproveNodeService;
import com.ruoyi.approve.service.IApproveProcessService;
import com.ruoyi.approve.utils.DailyRedisCounter;
import com.ruoyi.approve.vo.ApproveGetAndUpdateVo;
import com.ruoyi.approve.vo.ApproveNodeVO;
import com.ruoyi.approve.vo.ApproveProcessVO;
import com.ruoyi.common.enums.FileNameType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.other.service.impl.TempFileServiceImpl;
import com.ruoyi.project.system.domain.SysDept;
import com.ruoyi.project.system.domain.SysUser;
import com.ruoyi.project.system.mapper.SysDeptMapper;
import com.ruoyi.project.system.mapper.SysUserMapper;
import com.ruoyi.sales.mapper.CommonFileMapper;
import com.ruoyi.sales.mapper.SalesLedgerMapper;
import com.ruoyi.sales.pojo.CommonFile;
import com.ruoyi.sales.pojo.SalesLedger;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class ApproveProcessServiceImpl extends ServiceImpl<ApproveProcessMapper, ApproveProcess> implements IApproveProcessService {
    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("yyyyMMdd");

    private final DailyRedisCounter dailyRedisCounter;
    private final SysDeptMapper sysDeptMapper;
    private final IApproveNodeService approveNodeService;
    private final SysUserMapper sysUserMapper;
    private final ApproveProcessMapper approveProcessMapper;
    private final ApproveNodeMapper approveNodeMapper;
    private final TempFileServiceImpl tempFileService;
    private final CommonFileMapper commonFileMapper;
    private final SalesLedgerMapper salesLedgerMapper;
    private final ApproveFlowDefinitionMapper flowDefinitionMapper;
    private final ApproveFlowNodeDefinitionMapper flowNodeDefinitionMapper;
    private final ObjectMapper objectMapper;

    @Override
    public void addApprove(ApproveProcessVO request) throws Exception {
        if (request == null || request.getApproveType() == null) throw new RuntimeException("审批类型不能为空");
        ApproveType type = ApproveType.fromCode(request.getApproveType());
        Long tenantId = tenantId();
        SysUser applicant = SecurityUtils.getLoginUser().getUser();
        Long deptId = resolveDeptId(request.getApproveDeptId());
        SysDept dept = sysDeptMapper.selectDeptById(deptId);
        if (dept == null) throw new RuntimeException("申请部门不存在");

        List<ApproveNodeVO> nodes = resolveNodes(request, tenantId);
        List<SysUser> approvers = validateApprovers(nodes, tenantId);
        prepareBusinessData(request, type, tenantId);

        String approveCode = LocalDate.now().format(DATE_FORMAT)
                + String.format("%03d", dailyRedisCounter.incrementAndGetByDb());
        ApproveProcess process = new ApproveProcess();
        process.setApproveId(approveCode);
        process.setApproveUser(applicant.getUserId());
        process.setApproveUserName(applicant.getNickName());
        process.setApproveDeptId(deptId);
        process.setApproveDeptName(dept.getDeptName());
        process.setApproveUserIds(nodes.stream().map(item -> String.valueOf(item.getUserId())).collect(Collectors.joining(",")));
        process.setApproveUserNames(approvers.stream().map(SysUser::getNickName).collect(Collectors.joining(",")));
        process.setApproveTime(parseDate(request.getApproveTime()));
        process.setApproveReason(request.getApproveReason());
        process.setApproveStatus(0);
        process.setApproveDelete(0);
        process.setApproveType(type.getCode());
        process.setTenantId(tenantId);
        process.setBusinessId(request.getBusinessId());
        process.setBusinessNo(request.getBusinessNo());
        process.setBusinessTitle(request.getBusinessTitle());
        process.setAmount(request.getAmount());
        process.setBusinessData(request.getBusinessData());
        process.setFlowDefinitionId(request.getFlowDefinitionId());
        process.setCreateTime(LocalDateTime.now());
        process.setUpdateTime(LocalDateTime.now());
        approveProcessMapper.insert(process);
        approveNodeService.initApproveNodes(nodes, approveCode, tenantId);
        tempFileService.migrateTempFilesToFormal(process.getId(), request.getTempFileIds(), FileNameType.ApproveProcess.getValue());
    }

    private void prepareBusinessData(ApproveProcessVO request, ApproveType type, Long tenantId) throws JsonProcessingException {
        if (type == ApproveType.SALES_CONTRACT) {
            if (request.getBusinessId() == null) throw new RuntimeException("请选择销售合同");
            SalesLedger ledger = salesLedgerMapper.selectById(request.getBusinessId());
            if (ledger == null || !tenantId.equals(ledger.getTenantId())) throw new RuntimeException("销售合同不存在或不属于当前租户");
            Long duplicate = approveProcessMapper.selectCount(new LambdaQueryWrapper<ApproveProcess>()
                    .eq(ApproveProcess::getTenantId, tenantId)
                    .eq(ApproveProcess::getApproveType, ApproveType.SALES_CONTRACT.getCode())
                    .eq(ApproveProcess::getBusinessId, ledger.getId())
                    .in(ApproveProcess::getApproveStatus, Arrays.asList(0, 1))
                    .eq(ApproveProcess::getApproveDelete, 0));
            if (duplicate != null && duplicate > 0) throw new RuntimeException("该销售合同已有待审流程");
            Map<String, Object> snapshot = new LinkedHashMap<>();
            snapshot.put("salesLedgerId", ledger.getId());
            snapshot.put("salesContractNo", ledger.getSalesContractNo());
            snapshot.put("customerContractNo", ledger.getCustomerContractNo());
            snapshot.put("customerName", ledger.getCustomerName());
            snapshot.put("projectName", ledger.getProjectName());
            snapshot.put("salesman", ledger.getSalesman());
            snapshot.put("contractAmount", ledger.getContractAmount());
            snapshot.put("executionDate", ledger.getExecutionDate());
            snapshot.put("paymentMethod", ledger.getPaymentMethod());
            snapshot.put("remarks", ledger.getRemarks());
            request.setBusinessNo(ledger.getSalesContractNo());
            request.setBusinessTitle(StringUtils.hasText(request.getBusinessTitle())
                    ? request.getBusinessTitle() : "销售合同审批-" + ledger.getSalesContractNo());
            request.setAmount(ledger.getContractAmount());
            request.setBusinessData(objectMapper.writeValueAsString(snapshot));
        } else if (type == ApproveType.PURCHASE_PLAN || type == ApproveType.FREE_COLLABORATION) {
            if (!StringUtils.hasText(request.getBusinessTitle())) throw new RuntimeException("审批标题不能为空");
            if (type == ApproveType.PURCHASE_PLAN && request.getAmount() == null) throw new RuntimeException("采购预算金额不能为空");
            if (!StringUtils.hasText(request.getBusinessNo())) {
                String prefix = type == ApproveType.PURCHASE_PLAN ? "CG" : "XT";
                request.setBusinessNo(prefix + LocalDate.now().format(DATE_FORMAT)
                        + String.format("%03d", dailyRedisCounter.incrementAndGetByDb()));
            }
        }
    }

    private List<ApproveNodeVO> resolveNodes(ApproveProcessVO request, Long tenantId) {
        if (!CollectionUtils.isEmpty(request.getNodes())) return request.getNodes();
        if (request.getFlowDefinitionId() != null) {
            ApproveFlowDefinition definition = flowDefinitionMapper.selectOne(new LambdaQueryWrapper<ApproveFlowDefinition>()
                    .eq(ApproveFlowDefinition::getId, request.getFlowDefinitionId())
                    .eq(ApproveFlowDefinition::getTenantId, tenantId)
                    .eq(ApproveFlowDefinition::getApproveType, request.getApproveType())
                    .eq(ApproveFlowDefinition::getEnabled, 1)
                    .eq(ApproveFlowDefinition::getDeleteFlag, 0));
            if (definition == null) throw new RuntimeException("审批流程定义不存在或已停用");
            List<ApproveFlowNodeDefinition> definitions = flowNodeDefinitionMapper.selectList(
                    new LambdaQueryWrapper<ApproveFlowNodeDefinition>()
                            .eq(ApproveFlowNodeDefinition::getFlowDefinitionId, definition.getId())
                            .eq(ApproveFlowNodeDefinition::getTenantId, tenantId)
                            .eq(ApproveFlowNodeDefinition::getDeleteFlag, 0)
                            .orderByAsc(ApproveFlowNodeDefinition::getNodeOrder));
            List<ApproveNodeVO> result = new ArrayList<>();
            for (ApproveFlowNodeDefinition item : definitions) {
                if (!"USER".equals(item.getApproverType()) || !StringUtils.hasText(item.getApproverValue())) {
                    throw new RuntimeException("当前预设流程包含尚未指定的审批人");
                }
                ApproveNodeVO node = new ApproveNodeVO();
                node.setUserId(Long.valueOf(item.getApproverValue().split(",")[0].trim()));
                node.setNodeName(item.getNodeName());
                node.setConditionField(item.getConditionField());
                node.setConditionOperator(item.getConditionOperator());
                node.setConditionValue(item.getConditionValue());
                result.add(node);
            }
            if (!result.isEmpty()) return result;
        }
        if (!StringUtils.hasText(request.getApproveUserIds())) throw new RuntimeException("请选择审批人");
        List<ApproveNodeVO> result = new ArrayList<>();
        for (String id : request.getApproveUserIds().split(",")) {
            ApproveNodeVO node = new ApproveNodeVO();
            node.setUserId(Long.valueOf(id.trim()));
            node.setConditionOperator("ALWAYS");
            result.add(node);
        }
        return result;
    }

    private List<SysUser> validateApprovers(List<ApproveNodeVO> nodes, Long tenantId) {
        List<SysUser> users = new ArrayList<>();
        for (ApproveNodeVO node : nodes) {
            SysUser user = sysUserMapper.selectUserById(node.getUserId());
            if (user == null || !tenantId.equals(user.getTenantId())) throw new RuntimeException("审批人不存在或不属于当前租户");
            users.add(user);
        }
        return users;
    }

    @Override
    public List<SysDept> selectDeptListByDeptIds(Long[] deptIds) {
        List<SysDept> departments = new ArrayList<>();
        if (deptIds == null) return departments;
        for (Long deptId : deptIds) {
            SysDept dept = sysDeptMapper.selectDeptById(deptId);
            if (dept != null) departments.add(dept);
        }
        return departments;
    }

    @Override
    public IPage<ApproveProcess> listAll(Page page, ApproveProcess request) {
        request.setTenantId(tenantId());
        IPage<ApproveProcess> result = approveProcessMapper.listPage(page, request);
        result.getRecords().forEach(record -> record.setCommonFileList(commonFileMapper.selectList(
                new LambdaQueryWrapper<CommonFile>()
                        .eq(CommonFile::getCommonId, record.getId())
                        .eq(CommonFile::getType, FileNameType.ApproveProcess.getValue()))));
        return result;
    }

    @Override
    public void delApprove(String[] ids) {
        if (ids == null) return;
        for (String code : ids) {
            ApproveProcess process = findOwnedByCode(code);
            if (!SecurityUtils.getUserId().equals(process.getApproveUser())) throw new RuntimeException("只能删除本人申请");
            if (!(Integer.valueOf(0).equals(process.getApproveStatus()) || Integer.valueOf(3).equals(process.getApproveStatus()))) {
                throw new RuntimeException("审核中的流程不能删除");
            }
            UpdateWrapper<ApproveProcess> wrapper = new UpdateWrapper<>();
            wrapper.lambda().set(ApproveProcess::getApproveDelete, 1)
                    .set(ApproveProcess::getUpdateTime, LocalDateTime.now())
                    .eq(ApproveProcess::getApproveId, code)
                    .eq(ApproveProcess::getTenantId, tenantId());
            update(wrapper);
            approveNodeService.delApproveNodeByApproveId(code);
        }
    }

    @Override
    public ApproveProcess getApproveById(String id) {
        ApproveProcess process = findOwnedByCode(id);
        process.setCommonFileList(commonFileMapper.selectList(new LambdaQueryWrapper<CommonFile>()
                .eq(CommonFile::getCommonId, process.getId())
                .eq(CommonFile::getType, FileNameType.ApproveProcess.getValue())));
        return process;
    }

    @Override
    public void updateByApproveId(ApproveGetAndUpdateVo request) throws IOException {
        ApproveProcess process = approveProcessMapper.selectOne(new LambdaQueryWrapper<ApproveProcess>()
                .eq(ApproveProcess::getId, request.getId())
                .eq(ApproveProcess::getTenantId, tenantId())
                .eq(ApproveProcess::getApproveDelete, 0));
        if (process == null) throw new RuntimeException("审批不存在");
        if (!SecurityUtils.getUserId().equals(process.getApproveUser())) throw new RuntimeException("只能编辑本人申请");
        if (!(Integer.valueOf(0).equals(process.getApproveStatus()) || Integer.valueOf(3).equals(process.getApproveStatus()))) {
            throw new RuntimeException("当前审批状态不允许编辑");
        }
        process.setApproveReason(request.getApproveReason());
        process.setBusinessTitle(request.getBusinessTitle());
        process.setAmount(request.getAmount());
        process.setBusinessData(request.getBusinessData());
        process.setUpdateTime(LocalDateTime.now());
        process.setApproveStatus(0);
        process.setApproveOverTime(null);
        approveProcessMapper.updateById(process);

        List<ApproveNodeVO> nodes = request.getNodes();
        if (CollectionUtils.isEmpty(nodes) && StringUtils.hasText(request.getApproveUserIds())) {
            nodes = new ArrayList<>();
            for (String id : request.getApproveUserIds().split(",")) {
                ApproveNodeVO node = new ApproveNodeVO();
                node.setUserId(Long.valueOf(id.trim()));
                node.setConditionOperator("ALWAYS");
                nodes.add(node);
            }
        }
        if (!CollectionUtils.isEmpty(nodes)) {
            validateApprovers(nodes, tenantId());
            UpdateWrapper<ApproveNode> oldNodes = new UpdateWrapper<>();
            oldNodes.lambda().set(ApproveNode::getDeleteFlag, 1)
                    .set(ApproveNode::getIsCurrent, 0)
                    .eq(ApproveNode::getApproveProcessId, process.getApproveId())
                    .eq(ApproveNode::getTenantId, tenantId());
            approveNodeMapper.update(null, oldNodes);
            approveNodeService.initApproveNodes(nodes, process.getApproveId(), tenantId());
        }
        tempFileService.migrateTempFilesToFormal(process.getId(), request.getTempFileIds(), FileNameType.ApproveProcess.getValue());
    }

    private ApproveProcess findOwnedByCode(String code) {
        ApproveProcess process = approveProcessMapper.selectOne(new LambdaQueryWrapper<ApproveProcess>()
                .eq(ApproveProcess::getApproveId, code)
                .eq(ApproveProcess::getApproveDelete, 0)
                .eq(ApproveProcess::getTenantId, tenantId())
                .last("limit 1"));
        if (process == null) throw new RuntimeException("审批不存在");
        return process;
    }

    private Long resolveDeptId(Long requested) {
        Long[] allowed = SecurityUtils.getDeptId();
        if (requested == null) return SecurityUtils.getLoginUser().getCurrentDeptId();
        if (allowed != null && Arrays.asList(allowed).contains(requested)) return requested;
        Long current = SecurityUtils.getLoginUser().getCurrentDeptId();
        if (requested.equals(current)) return requested;
        throw new RuntimeException("无权使用该申请部门");
    }

    private Date parseDate(String value) throws ParseException {
        return StringUtils.hasText(value) ? new SimpleDateFormat("yyyy-MM-dd").parse(value) : new Date();
    }

    private Long tenantId() {
        return SecurityUtils.getLoginUser().getTenantId();
    }
}