package org.dromara.crm.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.exception.ServiceException;
import org.dromara.crm.domain.CrmQuote;
import org.dromara.crm.domain.CrmQuoteApproval;
import org.dromara.crm.domain.vo.CrmQuoteApprovalVo;
import org.dromara.crm.mapper.CrmQuoteApprovalMapper;
import org.dromara.crm.mapper.CrmQuoteMapper;
import org.dromara.crm.service.ICrmQuoteApprovalService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * 报价单审批Service实现
 *
 * @author 系统管理员
 * @date 2025-01-03
 */
@Slf4j
@RequiredArgsConstructor
@Service
public class CrmQuoteApprovalServiceImpl implements ICrmQuoteApprovalService {

    private final CrmQuoteApprovalMapper baseMapper;
    private final CrmQuoteMapper quoteMapper;

    @Override
    public List<CrmQuoteApprovalVo> queryListByQuoteId(Long quoteId) {
        // 使用关联查询获取用户昵称
        return baseMapper.selectVoListWithUserInfo(quoteId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean approveQuote(Long id, String approvalResult, String approvalOpinion, String remark) {
        CrmQuoteApproval entity = baseMapper.selectById(id);
        if (entity == null) {
            throw new ServiceException("审批记录不存在");
        }
        if (!"pending".equals(entity.getApprovalResult())) {
            throw new ServiceException("该审批已处理");
        }

        // 更新审批记录
        entity.setApprovalResult(approvalResult);
        entity.setApprovalOpinion(approvalOpinion);
        entity.setApprovalTime(LocalDateTime.now());
        entity.setRemark(remark);
        baseMapper.updateById(entity);

        // 更新报价单状态
        CrmQuote quote = quoteMapper.selectById(entity.getQuoteId());
        if (quote != null) {
            if ("approved".equals(approvalResult)) {
                // 检查是否所有审批都通过
                LambdaQueryWrapper<CrmQuoteApproval> lqw = Wrappers.lambdaQuery();
                lqw.eq(CrmQuoteApproval::getQuoteId, entity.getQuoteId());
                lqw.eq(CrmQuoteApproval::getApprovalResult, "pending");
                long pendingCount = baseMapper.selectCount(lqw);

                if (pendingCount == 0) {
                    // 所有审批都通过,报价单状态变更为已接受
                    quote.setStatus("accepted");
                    quoteMapper.updateById(quote);
                }
            } else if ("rejected".equals(approvalResult)) {
                // 任一审批拒绝,报价单状态变更为已拒绝
                quote.setStatus("rejected");
                quote.setRejectReason("审批拒绝: " + approvalOpinion);
                quoteMapper.updateById(quote);
            }
        }

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean withdrawApproval(Long quoteId, String remark) {
        CrmQuote quote = quoteMapper.selectById(quoteId);
        if (quote == null) {
            throw new ServiceException("报价单不存在");
        }
        if (!"submitted".equals(quote.getStatus())) {
            throw new ServiceException("只能撤回已提交的报价单");
        }

        // 删除所有待审批的记录
        LambdaQueryWrapper<CrmQuoteApproval> lqw = Wrappers.lambdaQuery();
        lqw.eq(CrmQuoteApproval::getQuoteId, quoteId);
        lqw.eq(CrmQuoteApproval::getApprovalResult, "pending");
        baseMapper.delete(lqw);

        // 报价单状态改为草稿
        quote.setStatus("draft");
        quote.setRemark(remark);
        quoteMapper.updateById(quote);

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean createApprovalRecords(Long quoteId, List<Long> approverIds) {
        CrmQuote quote = quoteMapper.selectById(quoteId);
        if (quote == null) {
            throw new ServiceException("报价单不存在");
        }

        int step = 1;
        for (Long approverId : approverIds) {
            CrmQuoteApproval approval = new CrmQuoteApproval();
            approval.setQuoteId(quoteId);
            approval.setQuoteNo(quote.getQuoteNo());
            approval.setStep(step++);
            approval.setApproverId(approverId);

            // 查询审批人昵称
            String nickName = baseMapper.selectNickNameByUserId(approverId);
            if (nickName != null) {
                approval.setApproverName(nickName);
            } else {
                // 如果查询不到用户，使用默认格式
                approval.setApproverName("用户" + approverId);
                log.warn("未找到用户昵称, userId: {}", approverId);
            }

            approval.setApprovalResult("pending");
            baseMapper.insert(approval);
        }

        return true;
    }

    @Override
    public Boolean deletePendingApprovals(Long quoteId) {
        LambdaQueryWrapper<CrmQuoteApproval> lqw = Wrappers.lambdaQuery();
        lqw.eq(CrmQuoteApproval::getQuoteId, quoteId);
        lqw.eq(CrmQuoteApproval::getApprovalResult, "pending");
        int count = baseMapper.delete(lqw);
        log.info("删除待审批记录: quoteId={}, count={}", quoteId, count);
        return count >= 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Integer refreshApproverNames(Long quoteId) {
        // 构建查询条件
        LambdaQueryWrapper<CrmQuoteApproval> lqw = Wrappers.lambdaQuery();
        if (quoteId != null) {
            lqw.eq(CrmQuoteApproval::getQuoteId, quoteId);
        }
        // 只更新"审批人xxx"或"用户xxx"格式的记录
        lqw.and(wrapper -> wrapper
                .likeRight(CrmQuoteApproval::getApproverName, "审批人")
                .or()
                .likeRight(CrmQuoteApproval::getApproverName, "用户"));

        // 查询需要更新的记录
        List<CrmQuoteApproval> approvalList = baseMapper.selectList(lqw);
        if (approvalList.isEmpty()) {
            log.info("没有需要刷新的审批记录");
            return 0;
        }

        int updateCount = 0;
        for (CrmQuoteApproval approval : approvalList) {
            // 查询用户昵称
            String nickName = baseMapper.selectNickNameByUserId(approval.getApproverId());
            if (nickName != null && !nickName.equals(approval.getApproverName())) {
                approval.setApproverName(nickName);
                baseMapper.updateById(approval);
                updateCount++;
                log.info("刷新审批人姓名成功: id={}, approverId={}, newName={}",
                        approval.getId(), approval.getApproverId(), nickName);
            } else {
                log.warn("未找到用户昵称或姓名相同: approvalId={}, approverId={}",
                        approval.getId(), approval.getApproverId());
            }
        }

        log.info("刷新审批人姓名完成: quoteId={}, 总数={}, 成功={}", quoteId, approvalList.size(), updateCount);
        return updateCount;
    }

    @Override
    public Boolean canUserApprove(Long quoteId, Long userId) {
        if (quoteId == null || userId == null) {
            return false;
        }

        // 查询该报价单的所有审批记录（按步骤升序）
        LambdaQueryWrapper<CrmQuoteApproval> lqw = Wrappers.lambdaQuery();
        lqw.eq(CrmQuoteApproval::getQuoteId, quoteId);
        lqw.orderByAsc(CrmQuoteApproval::getStep);
        List<CrmQuoteApproval> approvalList = baseMapper.selectList(lqw);

        if (approvalList.isEmpty()) {
            return false;
        }

        // 查找当前用户的审批记录
        CrmQuoteApproval userApproval = null;
        for (CrmQuoteApproval approval : approvalList) {
            if (userId.equals(approval.getApproverId())) {
                userApproval = approval;
                break;
            }
        }

        // 如果用户不是审批人
        if (userApproval == null) {
            return false;
        }

        // 如果用户的审批记录不是待审批状态
        if (!"pending".equals(userApproval.getApprovalResult())) {
            return false;
        }

        // 关键：检查所有前置步骤是否都已完成
        for (CrmQuoteApproval approval : approvalList) {
            // 如果是用户自己的步骤，跳过
            if (approval.getStep().equals(userApproval.getStep())) {
                break;
            }
            // 如果前置步骤不是已通过状态，则不能审批
            if (!"approved".equals(approval.getApprovalResult())) {
                return false;
            }
        }

        return true;
    }

}