package com.ruoyi.approve.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.ruoyi.approve.mapper.ApproveProcessMapper;
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.basic.pojo.Customer;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
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 lombok.AllArgsConstructor;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;

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

    private final StringRedisTemplate redisTemplate;

    private final DailyRedisCounter dailyRedisCounter;

    private final SysDeptMapper sysDeptMapper;
    private final IApproveNodeService approveNodeService;
    private final SysUserMapper sysUserMapper;
    private final ApproveProcessMapper approveProcessMapper;


    @Override
    public void addApprove(ApproveProcessVO approveProcessVO) {
        Long userId = SecurityUtils.getUserId();
        String nickName = SecurityUtils.getLoginUser().getNickName();
        //租户id
        Long tenantId = SecurityUtils.getLoginUser().getTenantId();
        String deptName = sysDeptMapper.selectDeptById(approveProcessVO.getApproveDeptId()).getDeptName();

        String today = LocalDate.now().format(DATE_FORMAT);
        Long approveId = dailyRedisCounter.incrementAndGet("approveId");
        String formattedCount = String.format("%03d", approveId);
        //流程 ID
        String approveID = today + formattedCount;

        //审批人姓名处理
        String approverIds = approveProcessVO.getApproveUserIds();
        String[] idArray = approverIds.split(",");
        String approverNames = getApproverNames(approveProcessVO.getApproveUserIds());
        String[] namdArray = approverNames.split(",");

        ApproveProcess approveProcess = new ApproveProcess();
        approveProcess.setApproveId(approveID);
        approveProcess.setApproveUser(userId);
        approveProcess.setApproveUserName(nickName);
        approveProcess.setApproveDeptId(approveProcessVO.getApproveDeptId());
        approveProcess.setApproveDeptName(deptName);
        approveProcess.setApproveUserIds(approveProcessVO.getApproveUserIds());
        approveProcess.setApproveUserNames(approverNames);
        approveProcess.setApproveUserCurrentId(Long.parseLong(idArray[0]));
        approveProcess.setApproveUserCurrentName(namdArray[0]);
        approveProcess.setApproveTime(new Date());
        approveProcess.setApproveReason(approveProcessVO.getApproveReason());
        approveProcess.setApproveOverTime(null);
        approveProcess.setApproveStatus(0);
        approveProcess.setApproveDelete(0);
        approveProcess.setTenantId(tenantId);

        save(approveProcess);
        //初始化审批节点
        approveNodeService.initApproveNodes(approveID,0);
    }

    private String getApproverNames(String approverIds) {
        String[] idArray = approverIds.split(",");

        Integer[] ids = Arrays.stream(idArray)
                .map(Integer::parseInt)
                .toArray(Integer[]::new);
        List<String> names = new ArrayList<String>();

        for (Integer id : ids) {
            SysUser sysUser = sysUserMapper.selectUserById(id.longValue());
                 names.add(sysUser.getNickName());
        }

        return String.join(",", names);
    }


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

    @Override
    public IPage<ApproveProcess> listAll(Page page,String id) {
        // 1. 处理空值场景（参数校验）
        if (page == null) {
            page = Page.of(1, 10); // 默认第1页，每页10条数据
        }
        LambdaQueryWrapper<ApproveProcess> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ApproveProcess::getApproveDelete, 0);
        if (StringUtils.isNotBlank(id)) {
            queryWrapper.like(ApproveProcess::getApproveId, id);
        }
        return approveProcessMapper.selectPage(page, queryWrapper);
    }

    @Override
    public void delApprove(Long[] ids) {
        for (Long id : ids) {
            LambdaQueryWrapper<ApproveProcess> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ApproveProcess::getApproveId, id);
            ApproveProcess process = getOne(queryWrapper);
            process.setApproveDelete(1);
            saveOrUpdate(process);
        }
    }

    @Override
    public ApproveProcess getApproveById(String id) {
        LambdaQueryWrapper<ApproveProcess> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ApproveProcess::getApproveId, id);
        queryWrapper.eq(ApproveProcess::getApproveDelete, 0);
        return getOne(queryWrapper);
    }

    @Override
    public void updateApproveProcessStatus(ApproveNodeVo approveNodeVo) {
        ApproveNode node = approveNodeService.getById(approveNodeVo.getId());
        ApproveProcess approveProcess = getById(node.getApproveProcessId());

        String[] idArray = approveProcess.getApproveUserIds().split(",");
        String[] nameArray = approveProcess.getApproveUserNames().split(",");


        Integer noderOrder = approveNodeVo.getApproveNodeOrder();
        //设置当前审批人
        if (noderOrder ==idArray.length){
            approveProcess.setApproveUserCurrentId(null);
            approveProcess.setApproveUserCurrentName(null);
        }else {
            approveProcess.setApproveUserCurrentId(Long.parseLong(idArray[noderOrder]));
            approveProcess.setApproveUserCurrentName(nameArray[noderOrder]);
        }

        if(noderOrder.equals(1)){
            if(approveNodeVo.getApproveNodeStatus() == 1){
                approveProcess.setApproveStatus(1);
            }
        }
        if(noderOrder.equals(idArray.length)){
            if(approveNodeVo.getApproveNodeStatus() == 1){
                approveProcess.setApproveStatus(2);
                approveProcess.setApproveOverTime(new Date());
            }
        }
       // updateById(approveProcess);
        approveProcessMapper.updateApproveDeptId(approveProcess);


    }


    @Override
    public void updateByApproveId(ApproveGetAndUpdateVo approveGetAndUpdateVo) {
        ApproveProcess approve = getApproveById(approveGetAndUpdateVo.getId());
        approve.setApproveReason(approveGetAndUpdateVo.getApproveReason());
        updateById(approve);
    }


}