package com.klp.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.klp.common.core.service.UserService;
import com.klp.common.utils.StringUtils;
import com.klp.system.service.ISysUserService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.klp.domain.bo.WmsApprovalBo;
import com.klp.domain.vo.WmsApprovalVo;
import com.klp.domain.WmsApproval;
import com.klp.mapper.WmsApprovalMapper;
import com.klp.service.IWmsApprovalService;

import java.util.*;
import java.util.stream.Collectors;

import com.klp.mapper.WmsLeaveRequestMapper;
import com.klp.mapper.WmsOutRequestMapper;
import com.klp.domain.vo.WmsLeaveRequestVo;
import com.klp.domain.vo.WmsOutRequestVo;

/**
 * 通用审批（支持请假/外出等申请的审批）Service业务层处理
 *
 * @author klp
 * @date 2026-01-20
 */
@RequiredArgsConstructor
@Service
public class WmsApprovalServiceImpl implements IWmsApprovalService {

    private final WmsApprovalMapper baseMapper;
    private final WmsLeaveRequestMapper leaveRequestMapper;
    private final WmsOutRequestMapper outRequestMapper;
    private final ISysUserService userService;

    /**
     * 查询通用审批（支持请假/外出等申请的审批）
     */
    @Override
    public Map<String, Object> queryById(Long approvalId){
        Map<String, Object> result = new HashMap<>();
        WmsApprovalVo approval = baseMapper.selectVoById(approvalId);
        if (approval == null) {
            return result;
        }
        result.put("approval", approval);
        String type = approval.getApplyType();
        Long applyId = approval.getApplyId();
        if (StringUtils.isNotBlank(type) && applyId != null) {
            if ("leave".equalsIgnoreCase(type)) {
                WmsLeaveRequestVo detail = leaveRequestMapper.selectVoById(applyId);
                // 详情接口也可以补充昵称转换（可选）
                if (detail != null && StringUtils.isNotBlank(detail.getCreateBy())) {
                    Map<String, String> nickMap = userService.selectNickNameMapByUserNames(Collections.singletonList(detail.getCreateBy()));
                    detail.setCreateByName(nickMap.getOrDefault(detail.getCreateBy(), detail.getCreateBy()));
                }
                result.put("detail", detail);
                result.put("applyType", "leave");
            } else if ("out".equalsIgnoreCase(type)) {
                WmsOutRequestVo outDetail = outRequestMapper.selectVoById(applyId);
                // 详情接口也可以补充昵称转换（可选）
                if (outDetail != null && StringUtils.isNotBlank(outDetail.getCreateBy())) {
                    Map<String, String> nickMap = userService.selectNickNameMapByUserNames(Collections.singletonList(outDetail.getCreateBy()));
                    outDetail.setCreateByName(nickMap.getOrDefault(outDetail.getCreateBy(), outDetail.getCreateBy()));
                }
                result.put("detail", outDetail);
                result.put("applyType", "out");
            }
        }
        return result;
    }

    /**
     * 查询通用审批列表（含请假/外出详情+创建人昵称转换）
     */
    @Override
    public TableDataInfo<Map<String, Object>> queryPageList(WmsApprovalBo bo, PageQuery pageQuery) {
        LambdaQueryWrapper<WmsApproval> lqw = buildQueryWrapper(bo);
        // 1. 查询审批列表分页数据
        Page<WmsApprovalVo> approvalPage = baseMapper.selectVoPage(pageQuery.build(), lqw);
        List<WmsApprovalVo> approvalList = approvalPage.getRecords();

        if (CollectionUtil.isEmpty(approvalList)) {
            Page<Map<String, Object>> emptyResultPage = new Page<>();
            emptyResultPage.setRecords(new ArrayList<>());
            emptyResultPage.setTotal(approvalPage.getTotal());
            emptyResultPage.setSize(approvalPage.getSize());
            emptyResultPage.setCurrent(approvalPage.getCurrent());
            emptyResultPage.setPages(approvalPage.getPages());

            return TableDataInfo.build(emptyResultPage);
        }

        // 2. 处理审批列表，拼接请假/外出详情，并收集所有需要转换的创建人账号
        List<Map<String, Object>> resultList = new ArrayList<>();
        Set<String> userNames = new HashSet<>(); // 存储所有需要查询昵称的账号

        for (WmsApprovalVo approval : approvalList) {
            Map<String, Object> item = new HashMap<>();
            item.put("approval", approval); // 审批基础信息

            String applyType = approval.getApplyType();
            Long applyId = approval.getApplyId();
            Object detail = null;

            // 3. 查询请假/外出详情，并收集创建人账号
            if (StringUtils.isNotBlank(applyType) && applyId != null) {
                if ("leave".equalsIgnoreCase(applyType)) {
                    WmsLeaveRequestVo leaveDetail = leaveRequestMapper.selectVoById(applyId);
                    detail = leaveDetail;
                    // 收集请假申请的创建人账号
                    if (leaveDetail != null && StringUtils.isNotBlank(leaveDetail.getCreateBy())) {
                        userNames.add(leaveDetail.getCreateBy());
                    }
                    item.put("applyType", "leave");
                } else if ("out".equalsIgnoreCase(applyType)) {
                    WmsOutRequestVo outDetail = outRequestMapper.selectVoById(applyId);
                    detail = outDetail;
                    // 收集外出申请的创建人账号
                    if (outDetail != null && StringUtils.isNotBlank(outDetail.getCreateBy())) {
                        userNames.add(outDetail.getCreateBy());
                    }
                    item.put("applyType", "out");
                }
                item.put("detail", detail);
            }
            resultList.add(item);
        }

        // 4. 批量查询昵称映射
        Map<String, String> nickMap = Collections.emptyMap();
        if (!userNames.isEmpty()) {
            nickMap = userService.selectNickNameMapByUserNames(new ArrayList<>(userNames));
        }

        // 5. 遍历填充请假/外出申请的创建人昵称
        for (Map<String, Object> item : resultList) {
            Object detail = item.get("detail");
            if (detail == null || nickMap.isEmpty()) {
                continue;
            }

            // 区分请假/外出类型，填充创建人昵称
            if ("leave".equals(item.get("applyType"))) {
                WmsLeaveRequestVo leaveDetail = (WmsLeaveRequestVo) detail;
                if (StringUtils.isNotBlank(leaveDetail.getCreateBy())) {
                    // 填充创建人昵称
                    leaveDetail.setCreateByName(nickMap.getOrDefault(leaveDetail.getCreateBy(), leaveDetail.getCreateBy()));
                }
            } else if ("out".equals(item.get("applyType"))) {
                WmsOutRequestVo outDetail = (WmsOutRequestVo) detail;
                if (StringUtils.isNotBlank(outDetail.getCreateBy())) {
                    outDetail.setCreateByName(nickMap.getOrDefault(outDetail.getCreateBy(), outDetail.getCreateBy()));
                }
            }
        }

        // 6. 构建分页返回结果
        Page<Map<String, Object>> resultPage = new Page<>();
        resultPage.setRecords(resultList);
        resultPage.setTotal(approvalPage.getTotal());
        resultPage.setSize(approvalPage.getSize());
        resultPage.setCurrent(approvalPage.getCurrent());
        resultPage.setPages(approvalPage.getPages());

        return TableDataInfo.build(resultPage);
    }


    /**
     * 查询通用审批（支持请假/外出等申请的审批）列表
     */
    @Override
    public List<WmsApprovalVo> queryList(WmsApprovalBo bo) {
        LambdaQueryWrapper<WmsApproval> lqw = buildQueryWrapper(bo);
        return baseMapper.selectVoList(lqw);
    }

    private LambdaQueryWrapper<WmsApproval> buildQueryWrapper(WmsApprovalBo bo) {
        Map<String, Object> params = bo.getParams();
        LambdaQueryWrapper<WmsApproval> lqw = Wrappers.lambdaQuery();
        lqw.eq(StringUtils.isNotBlank(bo.getApplyType()), WmsApproval::getApplyType, bo.getApplyType());
        lqw.eq(bo.getApplyId() != null, WmsApproval::getApplyId, bo.getApplyId());
        lqw.like(StringUtils.isNotBlank(bo.getApproverName()), WmsApproval::getApproverName, bo.getApproverName());
        lqw.eq(StringUtils.isNotBlank(bo.getApprovalStatus()), WmsApproval::getApprovalStatus, bo.getApprovalStatus());
        lqw.eq(StringUtils.isNotBlank(bo.getApprovalOpinion()), WmsApproval::getApprovalOpinion, bo.getApprovalOpinion());
        lqw.eq(bo.getApprovalTime() != null, WmsApproval::getApprovalTime, bo.getApprovalTime());
        return lqw;
    }

    /**
     * 新增通用审批（支持请假/外出等申请的审批）
     */
    @Override
    public Boolean insertByBo(WmsApprovalBo bo) {
        WmsApproval add = BeanUtil.toBean(bo, WmsApproval.class);
        validEntityBeforeSave(add);
        boolean flag = baseMapper.insert(add) > 0;
        if (flag) {
            bo.setApprovalId(add.getApprovalId());
        }
        return flag;
    }

    /**
     * 修改通用审批（支持请假/外出等申请的审批）
     */
    @Override
    public Boolean updateByBo(WmsApprovalBo bo) {
        WmsApproval update = BeanUtil.toBean(bo, WmsApproval.class);
        validEntityBeforeSave(update);
        return baseMapper.updateById(update) > 0;
    }

    /**
     * 保存前的数据校验
     */
    private void validEntityBeforeSave(WmsApproval entity){
        //TODO 做一些数据校验,如唯一约束
    }

    /**
     * 批量删除通用审批（支持请假/外出等申请的审批）
     */
    @Override
    public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
        if(isValid){
            //TODO 做一些业务上的校验,判断是否需要校验
        }
        return baseMapper.deleteBatchIds(ids) > 0;
    }

}