package cn.iocoder.yudao.module.mes.service.pd.techconfirm;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.exception.ServiceException;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.bpm.api.task.BpmProcessInstanceApi;
import cn.iocoder.yudao.module.bpm.api.task.dto.BpmProcessInstanceCreateReqDTO;
import cn.iocoder.yudao.module.bpm.enums.task.BpmTaskStatusEnum;
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
import cn.iocoder.yudao.module.crm.api.customer.dto.CrmCustomerRespDTO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.techconfirm.vo.ProductTechConfirmImportExcelVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.techconfirm.vo.ProductTechConfirmImportRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.techconfirm.vo.ProductTechConfirmPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.techconfirm.vo.ProductTechConfirmSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.techconfirm.ProductTechConfirmDO;
import cn.iocoder.yudao.module.mes.dal.mysql.pd.techconfirm.ProductTechConfirmMapper;
import cn.iocoder.yudao.module.mes.enums.pd.MesPdTechConfirmStatusEnum;
import cn.iocoder.yudao.module.system.api.approval.ApprovalConfigApi;
import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;

/**
 * MES 产品技术确认函 Service 实现类
 *
 * 状态完全由业务流程驱动，前端不参与状态赋值。各状态的写入入口严格区分：
 * <ul>
 *     <li>草稿：{@link #createTechConfirm} 创建时写入；{@link #auditTechConfirm} 客户确认被驳回时回退</li>
 *     <li>待审核：{@link #submitTechConfirmAudit} 提交审核后写入，同时记录编制人指定的审核人</li>
 *     <li>已审核：{@link #auditTechConfirm} 审核通过时写入，同时记录审核时间与审核意见</li>
 *     <li>审核不通过：{@link #auditTechConfirm} 审核不通过时写入，保留不通过原因供编制人修改后重新提交</li>
 *     <li>客户已确认：{@link #confirmTechConfirmByCustomer} 客户确认后写入</li>
 * </ul>
 *
 * @author 超级管理员
 */
@Service
@Validated
@Slf4j
public class ProductTechConfirmServiceImpl implements ProductTechConfirmService {

    /**
     * 技术确认函审批的业务类型编码
     *
     * 与 system_approval_config.biz_type 对应，审核人在「系统管理 - 审批配置」中维护。
     */
    private static final String TECH_CONFIRM_APPROVE_BIZ_TYPE = "pd_tech_confirm_approve";

    /**
     * 技术确认函审批的 BPM 流程定义 Key
     */
    private static final String TECH_CONFIRM_APPROVE_PROCESS_KEY = "pd_tech_confirm_approve";

    @Resource
    private ProductTechConfirmMapper techConfirmMapper;

    @Resource
    private BpmProcessInstanceApi bpmProcessInstanceApi;

    @Resource
    private AdminUserApi adminUserApi;

    @Resource
    private ApprovalConfigApi approvalConfigApi;

    @Resource
    private CrmCustomerApi customerApi;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createTechConfirm(ProductTechConfirmSaveReqVO createReqVO) {
        // 校验确认函编号唯一
        validateConfirmNoUnique(createReqVO.getConfirmNo(), null);
        // 插入：状态固定为草稿，编制人 / 编制时间取当前登录用户与当前时间
        Long userId = getLoginUserId();
        ProductTechConfirmDO techConfirm = BeanUtils.toBean(createReqVO, ProductTechConfirmDO.class);
        techConfirm.setStatus(MesPdTechConfirmStatusEnum.DRAFT.getStatus());
        techConfirm.setDrafterId(userId);
        techConfirm.setDrafterName(getUserNickname(userId));
        techConfirm.setDraftTime(LocalDateTime.now());
        // 审核人由提交审核时指定，创建时清空，避免前端传参带入
        techConfirm.setReviewerId(null);
        techConfirm.setReviewerName(null);
        techConfirm.setReviewTime(null);
        techConfirm.setReviewRemark(null);
        techConfirm.setCustomerConfirmUser(null);
        techConfirm.setCustomerConfirmTime(null);
        techConfirmMapper.insert(techConfirm);
        return techConfirm.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateTechConfirm(ProductTechConfirmSaveReqVO updateReqVO) {
        // 校验存在
        ProductTechConfirmDO techConfirm = validateTechConfirmExists(updateReqVO.getId());
        // 校验状态为草稿或审核不通过
        validateTechConfirmEditable(techConfirm);
        // 校验确认函编号唯一（排除自身）
        validateConfirmNoUnique(updateReqVO.getConfirmNo(), updateReqVO.getId());
        // 更新：状态、编制人、审核人、客户确认人等流程字段一律不接收前端传参，此处只落业务字段
        ProductTechConfirmDO updateObj = BeanUtils.toBean(updateReqVO, ProductTechConfirmDO.class);
        techConfirmMapper.updateById(updateObj);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteTechConfirm(Long id) {
        // 校验存在
        ProductTechConfirmDO techConfirm = validateTechConfirmExists(id);
        // 校验状态为草稿或审核不通过
        validateTechConfirmEditable(techConfirm);
        // 删除
        techConfirmMapper.deleteById(id);
    }

    @Override
    public ProductTechConfirmDO getTechConfirm(Long id) {
        return techConfirmMapper.selectById(id);
    }

    @Override
    public PageResult<ProductTechConfirmDO> getTechConfirmPage(ProductTechConfirmPageReqVO pageReqVO) {
        return techConfirmMapper.selectPage(pageReqVO);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void submitTechConfirmAudit(Long id) {
        // 1. 校验存在 + 可提交状态（草稿 / 审核不通过）
        ProductTechConfirmDO techConfirm = validateTechConfirmExists(id);
        if (!MesPdTechConfirmStatusEnum.DRAFT.getStatus().equals(techConfirm.getStatus())
                && !MesPdTechConfirmStatusEnum.REJECTED.getStatus().equals(techConfirm.getStatus())) {
            throw exception(PD_TECH_CONFIRM_NOT_EDITABLE_FOR_SUBMIT);
        }
        // 2. 校验审批配置已启用且配置了有效审核人（未配置时抛出带明确提示的业务异常）
        approvalConfigApi.validateApprovalEnabledAndGetApprovers(TECH_CONFIRM_APPROVE_BIZ_TYPE);
        // 3. 更新状态为待审核，并清空上一轮审核结果
        //    用 UpdateWrapper 而非 updateById：MyBatis-Plus 默认更新策略会忽略 null，
        //    直接 updateById 无法把审核不通过后残留的审核人 / 审核时间 / 审核意见真正清空。
        techConfirmMapper.submitAndResetAuditInfo(id, MesPdTechConfirmStatusEnum.PENDING_AUDIT.getStatus());
        // 4. 创建 BPM 流程实例，使审批出现在「协同办公 - 我的流程」
        bpmProcessInstanceApi.createProcessInstance(getLoginUserId(),
                new BpmProcessInstanceCreateReqDTO()
                        .setProcessDefinitionKey(TECH_CONFIRM_APPROVE_PROCESS_KEY)
                        .setBusinessKey(String.valueOf(id)));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateTechConfirmAuditStatus(Long id, Integer bpmStatus, String reason) {
        // BPM 审批结果映射为确认函状态：通过=已审核 / 不通过=审核不通过（可修改后重新提交）
        Integer status;
        if (BpmTaskStatusEnum.APPROVE.getStatus().equals(bpmStatus)) {
            status = MesPdTechConfirmStatusEnum.AUDITED.getStatus();
        } else if (BpmTaskStatusEnum.REJECT.getStatus().equals(bpmStatus)) {
            status = MesPdTechConfirmStatusEnum.REJECTED.getStatus();
        } else {
            // 技术确认函没有「已取消」状态，其余 BPM 结果（如撤消）忽略
            log.warn("[updateTechConfirmAuditStatus] 忽略不支持的 BPM 状态({})，techConfirmId={}", bpmStatus, id);
            return;
        }
        if (techConfirmMapper.updateAuditStatusByBpm(id, status, reason) != 1) {
            log.warn("[updateTechConfirmAuditStatus] 技术确认函({}) 不处于待审核状态，忽略 BPM 结果({})", id, bpmStatus);
        }
    }

    @Override
    public Set<Long> getTechConfirmApproverUserIds() {
        return approvalConfigApi.getApproverUserIds(TECH_CONFIRM_APPROVE_BIZ_TYPE);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void auditTechConfirm(Long id, Boolean pass, String reviewRemark) {
        // 1. 校验存在
        ProductTechConfirmDO techConfirm = validateTechConfirmExists(id);
        // 2. 校验处于待审核状态
        if (!MesPdTechConfirmStatusEnum.PENDING_AUDIT.getStatus().equals(techConfirm.getStatus())) {
            throw exception(PD_TECH_CONFIRM_NOT_PENDING_AUDIT);
        }
        // 3. 校验当前登录用户是该业务类型的审核人（或签：任一人均可审核）
        Long userId = getLoginUserId();
        approvalConfigApi.validateApprover(TECH_CONFIRM_APPROVE_BIZ_TYPE, userId);
        // 4. 审核不通过：必须填写原因，状态置为审核不通过，退回编制人修改后可重新提交
        if (!Boolean.TRUE.equals(pass)) {
            if (StrUtil.isBlank(reviewRemark)) {
                throw exception(PD_TECH_CONFIRM_REJECT_REASON_REQUIRED);
            }
            techConfirmMapper.auditTechConfirm(id, MesPdTechConfirmStatusEnum.REJECTED.getStatus(),
                    userId, getUserNickname(userId), reviewRemark);
            return;
        }
        // 5. 审核通过：记录审核人与审核意见，状态置为已审核
        techConfirmMapper.auditTechConfirm(id, MesPdTechConfirmStatusEnum.AUDITED.getStatus(),
                userId, getUserNickname(userId), reviewRemark);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void confirmTechConfirmByCustomer(Long id, String customerConfirmUser) {
        // 1. 校验存在 + 已审核状态
        ProductTechConfirmDO techConfirm = validateTechConfirmExists(id);
        if (!MesPdTechConfirmStatusEnum.AUDITED.getStatus().equals(techConfirm.getStatus())) {
            throw exception(PD_TECH_CONFIRM_NOT_AUDITED_FOR_CUSTOMER_CONFIRM);
        }
        // 2. 更新状态为客户已确认，并记录客户确认人与确认时间
        techConfirmMapper.updateById(ProductTechConfirmDO.builder()
                .id(id)
                .status(MesPdTechConfirmStatusEnum.CUSTOMER_CONFIRMED.getStatus())
                .customerConfirmUser(customerConfirmUser)
                .customerConfirmTime(LocalDateTime.now())
                .build());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ProductTechConfirmImportRespVO importTechConfirmList(List<ProductTechConfirmImportExcelVO> importList, boolean updateSupport) {
        if (CollUtil.isEmpty(importList)) {
            throw exception(PD_TECH_CONFIRM_IMPORT_LIST_IS_EMPTY);
        }
        ProductTechConfirmImportRespVO respVO = ProductTechConfirmImportRespVO.builder()
                .createCodes(new ArrayList<>()).updateCodes(new ArrayList<>())
                .failureCodes(new LinkedHashMap<>()).build();
        AtomicInteger index = new AtomicInteger(1);
        importList.forEach(importItem -> {
            int currentIndex = index.getAndIncrement();
            String key = StrUtil.blankToDefault(importItem.getConfirmNo(), "第 " + currentIndex + " 行");
            if (StrUtil.isBlank(importItem.getConfirmNo())) {
                respVO.getFailureCodes().put(key, "确认函编号不能为空");
                return;
            }
            // 1. 解析客户名称
            Long customerId = null;
            if (StrUtil.isNotBlank(importItem.getCustomerName())) {
                CrmCustomerRespDTO customer = customerApi.getCustomerByName(importItem.getCustomerName().trim());
                if (customer == null) {
                    respVO.getFailureCodes().put(key, "客户名称[" + importItem.getCustomerName() + "]不存在");
                    return;
                }
                customerId = customer.getId();
            }
            // 2. 构建请求并创建/更新（复用现有 create/update 服务，状态由 create 固定为草稿）
            ProductTechConfirmSaveReqVO reqVO = BeanUtils.toBean(importItem, ProductTechConfirmSaveReqVO.class);
            reqVO.setCustomerId(customerId);
            try {
                ProductTechConfirmDO exist = techConfirmMapper.selectByConfirmNo(importItem.getConfirmNo().trim());
                if (exist == null) {
                    reqVO.setId(null);
                    createTechConfirm(reqVO);
                    respVO.getCreateCodes().add(importItem.getConfirmNo());
                } else if (updateSupport) {
                    reqVO.setId(exist.getId());
                    updateTechConfirm(reqVO);
                    respVO.getUpdateCodes().add(importItem.getConfirmNo());
                } else {
                    respVO.getFailureCodes().put(key, "确认函编号已存在");
                }
            } catch (ServiceException e) {
                respVO.getFailureCodes().put(key, e.getMessage());
            }
        });
        return respVO;
    }

    /**
     * 获取用户昵称
     *
     * @param userId 用户编号
     * @return 昵称，用户不存在时返回 null
     */
    private String getUserNickname(Long userId) {
        if (userId == null) {
            return null;
        }
        AdminUserRespDTO user = adminUserApi.getUser(userId);
        return user == null ? null : user.getNickname();
    }

    private void validateConfirmNoUnique(String confirmNo, Long excludeId) {
        // 确认函编号必填：VO 上的 @NotBlank 只覆盖接口入参，Service 内（含导入）仍需显式校验
        if (StrUtil.isBlank(confirmNo)) {
            throw exception(PD_TECH_CONFIRM_NO_REQUIRED);
        }
        ProductTechConfirmDO techConfirm = techConfirmMapper.selectOne(
                ProductTechConfirmDO::getConfirmNo, confirmNo);
        if (techConfirm != null && !techConfirm.getId().equals(excludeId)) {
            throw exception(PD_TECH_CONFIRM_NO_DUPLICATE);
        }
    }

    private ProductTechConfirmDO validateTechConfirmExists(Long id) {
        ProductTechConfirmDO techConfirm = techConfirmMapper.selectById(id);
        if (techConfirm == null) {
            throw exception(PD_TECH_CONFIRM_NOT_EXISTS);
        }
        return techConfirm;
    }

    /**
     * 校验技术确认函处于可修改状态
     *
     * 只有草稿与审核不通过允许修改与删除；待审核 / 已审核 / 客户已确认为锁定或终态。
     * 审核不通过的单据需退回给编制人修改后重新提交，因此同样放开。
     *
     * @param techConfirm 技术确认函
     */
    private void validateTechConfirmEditable(ProductTechConfirmDO techConfirm) {
        if (!MesPdTechConfirmStatusEnum.DRAFT.getStatus().equals(techConfirm.getStatus())
                && !MesPdTechConfirmStatusEnum.REJECTED.getStatus().equals(techConfirm.getStatus())) {
            throw exception(PD_TECH_CONFIRM_NOT_EDITABLE);
        }
    }

}