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

import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
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.Set;

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";

    @Resource
    private ProductTechConfirmMapper techConfirmMapper;

    @Resource
    private AdminUserApi adminUserApi;

    @Resource
    private ApprovalConfigApi approvalConfigApi;

    @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());
    }

    @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());
    }

    /**
     * 获取用户昵称
     *
     * @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) {
        if (confirmNo == null) {
            return;
        }
        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);
        }
    }

}