package com.klp.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.klp.common.core.page.TableDataInfo;
import com.klp.common.core.domain.PageQuery;
import com.klp.common.utils.StringUtils;
import com.klp.domain.WmsApprovalTask;
import com.klp.domain.bo.WmsApprovalTaskBo;
import com.klp.domain.vo.WmsApprovalTaskVo;
import com.klp.domain.vo.WmsApprovalVo;
import com.klp.domain.vo.WmsLeaveRequestVo;
import com.klp.domain.vo.WmsOutRequestVo;
import com.klp.mapper.WmsApprovalTaskMapper;
import com.klp.mapper.WmsApprovalMapper;
import com.klp.mapper.WmsLeaveRequestMapper;
import com.klp.mapper.WmsOutRequestMapper;
import com.klp.service.IWmsApprovalTaskService;
import com.klp.system.service.ISysUserService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

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

/**
 * 审批任务Service业务层处理
 *
 * @author klp
 * @date 2026-01-20
 */
@RequiredArgsConstructor
@Service
public class WmsApprovalTaskServiceImpl implements IWmsApprovalTaskService {

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

    @Override
    public WmsApprovalTaskVo queryById(Long taskId) {
        return baseMapper.selectVoById(taskId);
    }

    @Override
    public TableDataInfo<Map<String, Object>> queryPageList(WmsApprovalTaskBo bo, PageQuery pageQuery) {
        LambdaQueryWrapper<WmsApprovalTask> lqw = buildQueryWrapper(bo);
        Page<WmsApprovalTaskVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
        List<WmsApprovalTaskVo> taskList = result.getRecords();

        if (CollectionUtil.isEmpty(taskList)) {
            return TableDataInfo.build(new ArrayList<>());
        }

        // 收集所有approvalId，查询审批信息
        List<Long> approvalIds = taskList.stream()
            .map(WmsApprovalTaskVo::getApprovalId)
            .distinct()
            .collect(Collectors.toList());

        List<WmsApprovalVo> approvalList = approvalMapper.selectVoList(
            Wrappers.<com.klp.domain.WmsApproval>lambdaQuery()
                .in(com.klp.domain.WmsApproval::getApprovalId, approvalIds)
        );

        Map<Long, WmsApprovalVo> approvalMap = approvalList.stream()
            .collect(Collectors.toMap(WmsApprovalVo::getApprovalId, v -> v, (a, b) -> a));

        // 收集所有applyId，按类型分别查询
        Set<String> userNames = new HashSet<>();
        Map<String, Object> detailMap = new HashMap<>();

        for (WmsApprovalTaskVo task : taskList) {
            WmsApprovalVo approval = approvalMap.get(task.getApprovalId());
            if (approval == null) {
                continue;
            }

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

            if (StringUtils.isNotBlank(applyType) && applyId != null) {
                if ("leave".equalsIgnoreCase(applyType)) {
                    WmsLeaveRequestVo leaveDetail = leaveRequestMapper.selectVoById(applyId);
                    detailMap.put("leave_" + applyId, leaveDetail);
                    if (leaveDetail != null && StringUtils.isNotBlank(leaveDetail.getCreateBy())) {
                        userNames.add(leaveDetail.getCreateBy());
                    }
                } else if ("out".equalsIgnoreCase(applyType)) {
                    WmsOutRequestVo outDetail = outRequestMapper.selectVoById(applyId);
                    detailMap.put("out_" + applyId, outDetail);
                    if (outDetail != null && StringUtils.isNotBlank(outDetail.getCreateBy())) {
                        userNames.add(outDetail.getCreateBy());
                    }
                }
            }
        }

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

        // 组装返回结果
        List<Map<String, Object>> resultList = new ArrayList<>();
        for (WmsApprovalTaskVo task : taskList) {
            Map<String, Object> item = new HashMap<>();
            item.put("task", task);

            WmsApprovalVo approval = approvalMap.get(task.getApprovalId());
            if (approval != null) {
                item.put("approval", approval);

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

                if (StringUtils.isNotBlank(applyType) && applyId != null) {
                    if ("leave".equalsIgnoreCase(applyType)) {
                        WmsLeaveRequestVo leaveDetail = (WmsLeaveRequestVo) detailMap.get("leave_" + applyId);
                        if (leaveDetail != null) {
                            if (StringUtils.isNotBlank(leaveDetail.getCreateBy())) {
                                leaveDetail.setCreateByName(nickMap.getOrDefault(leaveDetail.getCreateBy(), leaveDetail.getCreateBy()));
                            }
                            item.put("detail", leaveDetail);
                            item.put("applyType", "leave");
                        }
                    } else if ("out".equalsIgnoreCase(applyType)) {
                        WmsOutRequestVo outDetail = (WmsOutRequestVo) detailMap.get("out_" + applyId);
                        if (outDetail != null) {
                            if (StringUtils.isNotBlank(outDetail.getCreateBy())) {
                                outDetail.setCreateByName(nickMap.getOrDefault(outDetail.getCreateBy(), outDetail.getCreateBy()));
                            }
                            item.put("detail", outDetail);
                            item.put("applyType", "out");
                        }
                    }
                }
            }
            resultList.add(item);
        }

        Page<Map<String, Object>> resultPage = new Page<>();
        resultPage.setRecords(resultList);
        resultPage.setTotal(result.getTotal());
        resultPage.setSize(result.getSize());
        resultPage.setCurrent(result.getCurrent());
        resultPage.setPages(result.getPages());

        return TableDataInfo.build(resultPage);
    }

    @Override
    public List<WmsApprovalTaskVo> queryList(WmsApprovalTaskBo bo) {
        LambdaQueryWrapper<WmsApprovalTask> lqw = buildQueryWrapper(bo);
        return baseMapper.selectVoList(lqw);
    }

    private LambdaQueryWrapper<WmsApprovalTask> buildQueryWrapper(WmsApprovalTaskBo bo) {
        LambdaQueryWrapper<WmsApprovalTask> lqw = Wrappers.lambdaQuery();
        lqw.eq(bo.getApprovalId() != null, WmsApprovalTask::getApprovalId, bo.getApprovalId());
        lqw.eq(bo.getApproverId() != null, WmsApprovalTask::getApproverId, bo.getApproverId());
        lqw.eq(bo.getApproverName() != null, WmsApprovalTask::getApproverName, bo.getApproverName());
        lqw.eq(bo.getTaskStatus() != null, WmsApprovalTask::getTaskStatus, bo.getTaskStatus());
        lqw.orderByDesc(WmsApprovalTask::getCreateTime);
        return lqw;
    }

    @Override
    public Boolean insertByBo(WmsApprovalTaskBo bo) {
        WmsApprovalTask add = BeanUtil.toBean(bo, WmsApprovalTask.class);
        validEntityBeforeSave(add);
        return baseMapper.insert(add) > 0;
    }

    private void validEntityBeforeSave(WmsApprovalTask entity) {
    }

    @Override
    public Boolean updateByBo(WmsApprovalTaskBo bo) {
        WmsApprovalTask update = BeanUtil.toBean(bo, WmsApprovalTask.class);
        validEntityBeforeSave(update);
        return baseMapper.updateById(update) > 0;
    }

    @Override
    public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
        if (isValid) {
        }
        return baseMapper.deleteBatchIds(ids) > 0;
    }

    @Override
    public List<WmsApprovalTaskVo> queryByApprovalId(Long approvalId) {
        return baseMapper.selectVoList(Wrappers.<WmsApprovalTask>lambdaQuery()
            .eq(WmsApprovalTask::getApprovalId, approvalId)
            .orderByAsc(WmsApprovalTask::getCreateTime));
    }

    @Override
    public Integer deleteByApprovalId(Long approvalId) {
        return baseMapper.delete(Wrappers.<WmsApprovalTask>lambdaQuery()
            .eq(WmsApprovalTask::getApprovalId, approvalId));
    }
}