package cn.iocoder.yudao.module.aftersales.service.returnobj;

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo.AfterSaleReturnPageReqVO;
import cn.iocoder.yudao.module.aftersales.controller.admin.returnobj.vo.AfterSaleReturnSaveReqVO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.returnobj.AfterSaleReturnItemDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketDO;
import cn.iocoder.yudao.module.aftersales.dal.dataobject.ticket.AfterSaleTicketItemDO;
import cn.iocoder.yudao.module.aftersales.dal.mysql.returnobj.AfterSaleReturnItemMapper;
import cn.iocoder.yudao.module.aftersales.dal.mysql.returnobj.AfterSaleReturnMapper;
import cn.iocoder.yudao.module.aftersales.dal.mysql.ticket.AfterSaleTicketMapper;
import cn.iocoder.yudao.module.aftersales.dal.mysql.ticket.AfterSaleTicketItemMapper;
import cn.iocoder.yudao.module.aftersales.dal.redis.no.AfterSaleNoRedisDAO;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleBizTypeEnum;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleReturnStatusEnum;
import cn.iocoder.yudao.module.aftersales.enums.AfterSaleTicketStatusEnum;
import cn.iocoder.yudao.module.aftersales.enums.permission.AfterSalePermissionLevelEnum;
import cn.iocoder.yudao.module.aftersales.service.permission.AfterSalePermissionService;
import cn.iocoder.yudao.module.aftersales.service.permission.bo.AfterSalePermissionCreateReqBO;
import cn.iocoder.yudao.module.mes.api.returnsales.MesWmReturnSalesApi;
import cn.iocoder.yudao.module.mes.api.returnsales.dto.MesWmReturnSalesCreateReqDTO;
import cn.iocoder.yudao.module.mes.api.returnsales.dto.MesWmReturnSalesLineRespDTO;
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.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Objects;
import java.util.HashSet;
import java.util.function.Function;
import java.util.stream.Collectors;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.aftersales.enums.ErrorCodeConstants.*;

/**
 * 售后退货申请 Service 实现类
 */
@Service
@Validated
@Slf4j
public class AfterSaleReturnServiceImpl implements AfterSaleReturnService {

    @Resource
    private AfterSaleReturnMapper returnMapper;
    @Resource
    private AfterSaleReturnItemMapper returnItemMapper;
    @Resource
    private AfterSaleTicketMapper ticketMapper;
    @Resource
    private AfterSaleTicketItemMapper ticketItemMapper;

    @Resource
    private AfterSaleNoRedisDAO noRedisDAO;

    @Resource
    private AfterSalePermissionService permissionService;

    @Resource
    private MesWmReturnSalesApi mesWmReturnSalesApi;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createReturn(AfterSaleReturnSaveReqVO createReqVO, Long userId) {
        // 1. 校验工单存在，且必须关联销售订单（退货的订单与物料数据由工单反显带入）
        AfterSaleTicketDO ticket = ticketMapper.selectById(createReqVO.getTicketId());
        if (ticket == null) {
            throw exception(TICKET_NOT_EXISTS);
        }
        if (ticket.getSaleOrderId() == null) {
            throw exception(RETURN_TICKET_SALE_ORDER_REQUIRED);
        }
        if (!AfterSaleTicketStatusEnum.PROCESSING.getStatus().equals(ticket.getStatus())
                || !Objects.equals(ticket.getCustomerId(), createReqVO.getCustomerId())
                || ticket.getReturnId() != null || returnMapper.existsActiveByTicketId(ticket.getId())) {
            throw exception(RETURN_TICKET_INVALID);
        }
        if (CollUtil.isEmpty(createReqVO.getItems())) {
            throw exception(RETURN_ITEM_EMPTY);
        }
        if (createReqVO.getReturnType() == null || !List.of(1, 2, 3).contains(createReqVO.getReturnType())) {
            throw exception(RETURN_ITEM_INVALID);
        }
        Map<Long, AfterSaleTicketItemDO> ticketItems = ticketItemMapper.selectListByTicketId(ticket.getId())
                .stream().collect(Collectors.toMap(AfterSaleTicketItemDO::getId, Function.identity()));
        Set<Long> usedItems = new HashSet<>();
        for (AfterSaleReturnSaveReqVO.Item item : createReqVO.getItems()) {
            AfterSaleTicketItemDO ticketItem = ticketItems.get(item.getTicketItemId());
            if (ticketItem == null || !usedItems.add(item.getTicketItemId())
                    || item.getItemId() == null || !item.getItemId().equals(ticketItem.getItemId())
                    || (!Integer.valueOf(3).equals(createReqVO.getReturnType())
                        && !Boolean.TRUE.equals(ticketItem.getNeedReturn()))
                    || (ticketItem.getBatchId() != null && !Objects.equals(item.getBatchId(), ticketItem.getBatchId()))
                    || item.getReturnQuantity() == null || item.getReturnQuantity().signum() <= 0
                    || ticketItem.getSaleQuantity() == null
                    || item.getReturnQuantity().compareTo(ticketItem.getSaleQuantity()) > 0
                    || (ticketItem.getReturnQuantity() != null && ticketItem.getReturnQuantity().signum() > 0
                        && item.getReturnQuantity().compareTo(ticketItem.getReturnQuantity()) > 0)
                    || item.getUnitPrice() == null || item.getUnitPrice().signum() < 0
                    || item.getReturnPrice() == null || item.getReturnPrice().signum() < 0) {
                throw exception(RETURN_ITEM_INVALID);
            }
        }
        // 销售订单以工单为准，保证退货单与工单关联同一订单
        createReqVO.setSaleOrderId(ticket.getSaleOrderId());

        // 2. 生成单号
        String no = noRedisDAO.generate(AfterSaleNoRedisDAO.RETURN_NO_PREFIX);
        if (returnMapper.selectByNo(no) != null) {
            throw exception(RETURN_NO_EXISTS);
        }

        // 3. 计算应退总金额
        BigDecimal totalReturnPrice = BigDecimal.ZERO;
        if (CollUtil.isNotEmpty(createReqVO.getItems())) {
            totalReturnPrice = createReqVO.getItems().stream()
                    .map(item -> item.getReturnPrice() != null ? item.getReturnPrice() : BigDecimal.ZERO)
                    .reduce(BigDecimal.ZERO, BigDecimal::add);
        }

        // 4. 插入退货申请
        AfterSaleReturnDO returnDO = BeanUtils.toBean(createReqVO, AfterSaleReturnDO.class)
                .setNo(no)
                .setTotalReturnPrice(totalReturnPrice)
                .setStatus(AfterSaleReturnStatusEnum.DRAFT.getStatus());
        returnMapper.insert(returnDO);

        // 5. 插入退货明细行
        if (CollUtil.isNotEmpty(createReqVO.getItems())) {
            createReqVO.getItems().forEach(item -> {
                AfterSaleReturnItemDO itemDO = BeanUtils.toBean(item, AfterSaleReturnItemDO.class);
                itemDO.setReturnId(returnDO.getId());
                returnItemMapper.insert(itemDO);
            });
        }

        // 6. 创建数据权限
        AfterSalePermissionCreateReqBO permBO = new AfterSalePermissionCreateReqBO();
        permBO.setBizType(AfterSaleBizTypeEnum.AFTER_SALE_RETURN.getType());
        permBO.setBizId(returnDO.getId());
        permBO.setUserId(userId);
        permBO.setLevel(AfterSalePermissionLevelEnum.OWNER.getLevel());
        permissionService.createPermission(permBO);

        // 7. 更新工单状态为待退货
        int ticketUpdated = ticketMapper.update(null, new LambdaUpdateWrapper<AfterSaleTicketDO>()
                .eq(AfterSaleTicketDO::getId, ticket.getId())
                .eq(AfterSaleTicketDO::getStatus, AfterSaleTicketStatusEnum.PROCESSING.getStatus())
                .isNull(AfterSaleTicketDO::getReturnId)
                .set(AfterSaleTicketDO::getReturnId, returnDO.getId())
                .set(AfterSaleTicketDO::getStatus, AfterSaleTicketStatusEnum.WAITING_RETURN.getStatus()));
        if (ticketUpdated != 1) {
            throw exception(RETURN_TICKET_INVALID);
        }

        return returnDO.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void approveReturn(Long id) {
        // 1. 校验退货申请
        AfterSaleReturnDO returnDO = validateReturnExists(id);
        if (!AfterSaleReturnStatusEnum.DRAFT.getStatus().equals(returnDO.getStatus())) {
            throw exception(RETURN_APPROVE_FAIL);
        }

        // 2. 获取关联工单（用于获取销售订单号等冗余信息）
        AfterSaleTicketDO ticket = ticketMapper.selectById(returnDO.getTicketId());

        // 3. 仅退款不产生实物入库；其余类型将明细完整带入 MES
        if (Integer.valueOf(3).equals(returnDO.getReturnType())) {
            returnMapper.updateById(new AfterSaleReturnDO().setId(id)
                    .setStatus(AfterSaleReturnStatusEnum.APPROVED.getStatus())
                    .setAuditTime(LocalDateTime.now()));
            if (ticketMapper.update(null, new LambdaUpdateWrapper<AfterSaleTicketDO>()
                    .eq(AfterSaleTicketDO::getId, returnDO.getTicketId())
                    .eq(AfterSaleTicketDO::getReturnId, id)
                    .eq(AfterSaleTicketDO::getStatus, AfterSaleTicketStatusEnum.WAITING_RETURN.getStatus())
                    .set(AfterSaleTicketDO::getStatus, AfterSaleTicketStatusEnum.WAITING_REFUND.getStatus())) != 1) {
                throw exception(RETURN_TICKET_INVALID);
            }
            return;
        }
        MesWmReturnSalesCreateReqDTO mesReqDTO = new MesWmReturnSalesCreateReqDTO();
        mesReqDTO.setCode(returnDO.getNo());
        mesReqDTO.setName("售后退货-" + returnDO.getNo());
        mesReqDTO.setSaleOrderId(returnDO.getSaleOrderId());
        mesReqDTO.setSalesOrderCode(ticket != null ? ticket.getSaleOrderNo() : null);
        mesReqDTO.setClientId(returnDO.getCustomerId());
        mesReqDTO.setReturnDate(LocalDate.now());
        mesReqDTO.setReturnReason(returnDO.getReturnReason());
        mesReqDTO.setRemark("售后工单退货 - 工单号: " + (ticket != null ? ticket.getNo() : ""));
        mesReqDTO.setAfterSaleReturnId(returnDO.getId());
        mesReqDTO.setItems(returnItemMapper.selectListByReturnId(id).stream().map(item -> {
            MesWmReturnSalesCreateReqDTO.Item line = new MesWmReturnSalesCreateReqDTO.Item();
            line.setItemId(item.getItemId());
            line.setQuantity(item.getReturnQuantity());
            line.setBatchId(item.getBatchId());
            line.setBatchCode(item.getBatchCode());
            line.setRemark(item.getRemark());
            return line;
        }).toList());
        Long mesReturnId = mesWmReturnSalesApi.createReturnSales(mesReqDTO);

        // 4. 回写 MES 解析后的批次（原单未记录批次的商品由 MES 自动生成退货批次）
        syncReturnItemBatch(id, mesReturnId);

        // 5. 更新退货申请状态
        returnMapper.updateById(new AfterSaleReturnDO().setId(id)
                .setStatus(AfterSaleReturnStatusEnum.APPROVED.getStatus())
                .setMesReturnId(mesReturnId)
                .setMesReturnCode(returnDO.getNo())
                .setAuditTime(LocalDateTime.now()));
    }

    /**
     * 将 MES 退货单行上的批次回写到售后明细，便于页面展示与追溯
     */
    private void syncReturnItemBatch(Long returnId, Long mesReturnId) {
        List<MesWmReturnSalesLineRespDTO> mesLines = mesWmReturnSalesApi.getReturnSalesLineList(mesReturnId);
        if (CollUtil.isEmpty(mesLines)) {
            return;
        }
        Map<Long, MesWmReturnSalesLineRespDTO> lineMap = mesLines.stream()
                .filter(line -> line.getBatchId() != null)
                .collect(Collectors.toMap(MesWmReturnSalesLineRespDTO::getItemId, line -> line, (a, b) -> a));
        if (lineMap.isEmpty()) {
            return;
        }
        for (AfterSaleReturnItemDO item : returnItemMapper.selectListByReturnId(returnId)) {
            MesWmReturnSalesLineRespDTO line = lineMap.get(item.getItemId());
            if (line == null || item.getBatchId() != null) {
                continue;
            }
            returnItemMapper.updateById(new AfterSaleReturnItemDO().setId(item.getId())
                    .setBatchId(line.getBatchId()).setBatchCode(line.getBatchCode()));
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void cancelReturn(Long id) {
        AfterSaleReturnDO returnDO = validateReturnExists(id);
        if (!List.of(AfterSaleReturnStatusEnum.DRAFT.getStatus(), AfterSaleReturnStatusEnum.APPROVED.getStatus(),
                AfterSaleReturnStatusEnum.INSPECTING.getStatus(), AfterSaleReturnStatusEnum.INSPECTED.getStatus())
                .contains(returnDO.getStatus())) {
            throw exception(RETURN_STATUS_ERROR);
        }
        if (returnDO.getMesReturnId() != null) {
            mesWmReturnSalesApi.cancelReturnSales(returnDO.getMesReturnId());
        } else {
            onMesCanceled(id);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void onMesCanceled(Long returnId) {
        AfterSaleReturnDO returnDO = validateReturnExists(returnId);
        if (AfterSaleReturnStatusEnum.CANCELED.getStatus().equals(returnDO.getStatus())) {
            return;
        }
        if (!List.of(AfterSaleReturnStatusEnum.DRAFT.getStatus(), AfterSaleReturnStatusEnum.APPROVED.getStatus(),
                AfterSaleReturnStatusEnum.INSPECTING.getStatus(), AfterSaleReturnStatusEnum.INSPECTED.getStatus())
                .contains(returnDO.getStatus())) {
            throw exception(RETURN_STATUS_ERROR);
        }
        returnMapper.updateById(new AfterSaleReturnDO().setId(returnId)
                .setStatus(AfterSaleReturnStatusEnum.CANCELED.getStatus()));
        if (ticketMapper.update(null, new LambdaUpdateWrapper<AfterSaleTicketDO>()
                .eq(AfterSaleTicketDO::getId, returnDO.getTicketId())
                .eq(AfterSaleTicketDO::getReturnId, returnId)
                .set(AfterSaleTicketDO::getReturnId, null)
                .set(AfterSaleTicketDO::getStatus, AfterSaleTicketStatusEnum.PROCESSING.getStatus())) != 1) {
            throw exception(RETURN_TICKET_INVALID);
        }
    }

    @Override
    public AfterSaleReturnDO getReturn(Long id) {
        return validateReturnExists(id);
    }

    @Override
    public List<AfterSaleReturnDO> getReturnList(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return List.of();
        }
        return returnMapper.selectBatchIds(ids);
    }

    @Override
    public PageResult<AfterSaleReturnDO> getReturnPage(AfterSaleReturnPageReqVO pageReqVO, Long userId) {
        return returnMapper.selectPage(pageReqVO, userId, pageReqVO.getSceneType(),
                pageReqVO.getNo(), pageReqVO.getTicketId(),
                pageReqVO.getCustomerId(), pageReqVO.getStatus());
    }

    @Override
    public List<AfterSaleReturnItemDO> getReturnItemListByReturnId(Long returnId) {
        return returnItemMapper.selectListByReturnId(returnId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void onQualityFinished(Long returnId, String qualityResult, String reportUrl) {
        AfterSaleReturnDO returnDO = validateReturnExists(returnId);
        if (List.of(AfterSaleReturnStatusEnum.INSPECTED.getStatus(), AfterSaleReturnStatusEnum.INBOUND.getStatus(),
                AfterSaleReturnStatusEnum.REFUNDED.getStatus(), AfterSaleReturnStatusEnum.CLOSED.getStatus())
                .contains(returnDO.getStatus())) {
            return;
        }
        if (!AfterSaleReturnStatusEnum.APPROVED.getStatus().equals(returnDO.getStatus())
                && !AfterSaleReturnStatusEnum.INSPECTING.getStatus().equals(returnDO.getStatus())) {
            throw exception(RETURN_STATUS_ERROR);
        }
        returnMapper.updateById(new AfterSaleReturnDO().setId(returnId)
                .setQualityResult(qualityResult)
                .setQualityReportUrl(reportUrl)
                .setStatus(AfterSaleReturnStatusEnum.INSPECTED.getStatus()));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void onInboundFinished(Long returnId) {
        AfterSaleReturnDO returnDO = validateReturnExists(returnId);
        if (List.of(AfterSaleReturnStatusEnum.INBOUND.getStatus(), AfterSaleReturnStatusEnum.REFUNDED.getStatus(),
                AfterSaleReturnStatusEnum.CLOSED.getStatus()).contains(returnDO.getStatus())) {
            return;
        }
        if (!AfterSaleReturnStatusEnum.INSPECTED.getStatus().equals(returnDO.getStatus())) {
            throw exception(RETURN_STATUS_ERROR);
        }
        returnMapper.updateById(new AfterSaleReturnDO().setId(returnId)
                .setStatus(AfterSaleReturnStatusEnum.INBOUND.getStatus())
                .setReturnInboundTime(LocalDateTime.now()));
        if (ticketMapper.update(null, new LambdaUpdateWrapper<AfterSaleTicketDO>()
                .eq(AfterSaleTicketDO::getId, returnDO.getTicketId())
                .eq(AfterSaleTicketDO::getReturnId, returnId)
                .eq(AfterSaleTicketDO::getStatus, AfterSaleTicketStatusEnum.WAITING_RETURN.getStatus())
                .set(AfterSaleTicketDO::getStatus, AfterSaleTicketStatusEnum.WAITING_REFUND.getStatus())) != 1) {
            throw exception(RETURN_TICKET_INVALID);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void onRefundCompleted(Long returnId, BigDecimal actualRefundPrice) {
        completeRefund(returnId, actualRefundPrice, null, false);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void confirmRefundCompleted(Long returnId, BigDecimal actualRefundPrice, String voucherNo) {
        if (StrUtil.isBlank(voucherNo)) {
            throw exception(RETURN_REFUND_VOUCHER_REQUIRED);
        }
        completeRefund(returnId, actualRefundPrice, voucherNo.trim(), true);
    }

    private void completeRefund(Long returnId, BigDecimal actualRefundPrice, String voucherNo, boolean manual) {
        AfterSaleReturnDO returnDO = validateReturnExists(returnId);
        if (List.of(AfterSaleReturnStatusEnum.REFUNDED.getStatus(), AfterSaleReturnStatusEnum.CLOSED.getStatus())
                .contains(returnDO.getStatus())) {
            return;
        }
        boolean refundOnly = Integer.valueOf(3).equals(returnDO.getReturnType());
        if (!(refundOnly && AfterSaleReturnStatusEnum.APPROVED.getStatus().equals(returnDO.getStatus()))
                && !AfterSaleReturnStatusEnum.INBOUND.getStatus().equals(returnDO.getStatus())) {
            throw exception(RETURN_STATUS_ERROR);
        }
        if (actualRefundPrice == null || actualRefundPrice.signum() < 0) {
            throw exception(RETURN_ITEM_INVALID);
        }
        if (manual && returnDO.getTotalReturnPrice() != null
                && actualRefundPrice.compareTo(returnDO.getTotalReturnPrice()) > 0) {
            throw exception(RETURN_REFUND_EXCEEDS_TOTAL);
        }
        if (manual && !Integer.valueOf(2).equals(returnDO.getReturnType())
                && returnDO.getTotalReturnPrice() != null && returnDO.getTotalReturnPrice().signum() > 0
                && actualRefundPrice.signum() == 0) {
            throw exception(RETURN_ITEM_INVALID);
        }
        returnMapper.updateById(new AfterSaleReturnDO().setId(returnId)
                .setActualRefundPrice(actualRefundPrice)
                .setRefundVoucherNo(voucherNo)
                .setStatus(AfterSaleReturnStatusEnum.REFUNDED.getStatus())
                .setRefundTime(LocalDateTime.now()));

        // 退款或换货完成后工单才能完结
        if (ticketMapper.update(null, new LambdaUpdateWrapper<AfterSaleTicketDO>()
                .eq(AfterSaleTicketDO::getId, returnDO.getTicketId())
                .eq(AfterSaleTicketDO::getReturnId, returnId)
                .eq(AfterSaleTicketDO::getStatus, AfterSaleTicketStatusEnum.WAITING_REFUND.getStatus())
                .set(AfterSaleTicketDO::getStatus, AfterSaleTicketStatusEnum.COMPLETED.getStatus())
                .set(AfterSaleTicketDO::getResolvedTime, LocalDateTime.now())) != 1) {
            throw exception(RETURN_TICKET_INVALID);
        }
    }

    // ========== 内部方法 ==========

    private AfterSaleReturnDO validateReturnExists(Long id) {
        AfterSaleReturnDO returnDO = returnMapper.selectById(id);
        if (returnDO == null) {
            throw exception(RETURN_NOT_EXISTS);
        }
        return returnDO;
    }

}