package com.ruoyi.order.service.impl;

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.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.constant.SecurityConstants;
import com.ruoyi.common.core.enums.AuditStatusEnum;
import com.ruoyi.common.core.enums.CouponUseEnum;
import com.ruoyi.common.core.enums.OrderStatusEnum;
import com.ruoyi.common.core.enums.PaymentMethodEnum;
import com.ruoyi.common.core.enums.PointStatusEnum;
import com.ruoyi.common.core.enums.RequestTypeEnum;
import com.ruoyi.common.core.enums.ReturnRequestStatusEnum;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.utils.page.BeanUtils;
import com.ruoyi.common.core.utils.page.PageDTO;
import com.ruoyi.order.controller.management.dto.MgtOrderReturnRequestQuery;
import com.ruoyi.order.controller.management.dto.MgtReturnRequestAuditDTO;
import com.ruoyi.order.controller.management.vo.MgtOrderReturnRequestVO;
import com.ruoyi.order.domain.OrderReturnRequest;
import com.ruoyi.order.domain.Paylog;
import com.ruoyi.order.mapper.OrderMapper;
import com.ruoyi.order.mapper.OrderReturnRequestMapper;
import com.ruoyi.order.service.IOrderReturnRequestService;
import com.ruoyi.order.util.SinataUtil;
import com.ruoyi.system.api.domain.CustomConfig;
import com.ruoyi.system.api.domain.Member;
import com.ruoyi.system.api.domain.Order;
import com.ruoyi.system.api.domain.dto.CouponMemberDTO;
import com.ruoyi.system.api.domain.dto.LogisticsDTO;
import com.ruoyi.system.api.domain.dto.MemberDTO;
import com.ruoyi.system.api.domain.dto.MemberPointsDTO;
import com.ruoyi.system.api.domain.dto.OrderReturnDTO;
import com.ruoyi.system.api.domain.dto.updMembeOneDTO;
import com.ruoyi.system.api.domain.vo.Express100VO;
import com.ruoyi.system.api.domain.vo.OrderReturnVO;
import com.ruoyi.system.api.feignClient.MemberClient;
import com.ruoyi.system.api.feignClient.PromotionClient;
import com.ruoyi.system.api.feignClient.SysUserClient;
import io.seata.spring.annotation.GlobalTransactional;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * <p>
 * 售后表 服务实现类
 * </p>
 *
 * @author mitao
 * @since 2024-05-16
 */
@Service
public class OrderReturnRequestServiceImpl extends ServiceImpl<OrderReturnRequestMapper, OrderReturnRequest> implements IOrderReturnRequestService {


    @Resource
    private SysUserClient sysUserClient;

    @Resource
    private OrderMapper orderMapper;
    @Resource
    private MemberClient memberClient;
    @Resource
    private LogisticsServiceImpl logisticsService;
    @Resource
    private PaylogServiceImpl paylogService;

    @Resource
    private PromotionClient promotionClient;
    
    @Override
    public OrderReturnVO saveOrderReturnRequest(OrderReturnDTO OrderReturnDTO) {

        Order order = orderMapper.selectById(OrderReturnDTO.getOrderId());
        if (order.getIsRequest()==2){
            throw new ServiceException("该订单已有售后");
        }
        order.setIsRequest(2);
        orderMapper.updateById(order);
        OrderReturnRequest orderReturnRequest = new OrderReturnRequest();
        orderReturnRequest.setOrderId(OrderReturnDTO.getOrderId());
        orderReturnRequest.setRequestTime(LocalDateTime.now());
        if (OrderReturnDTO.getRequestType().equals("REFUND")){
            orderReturnRequest.setRequestType(RequestTypeEnum.REFUND);
        }else{
            orderReturnRequest.setRequestType(RequestTypeEnum.REFUNDS_AND_RETURNS);
        }

        orderReturnRequest.setRequestReason(OrderReturnDTO.getRequestReason());
        orderReturnRequest.setStatus(ReturnRequestStatusEnum.TO_BE_REVIEWED);
        orderReturnRequest.setAuditStatus(AuditStatusEnum.TO_BE_REVIEWED);
        orderReturnRequest.setAlbum(OrderReturnDTO.getAlbum());
        orderReturnRequest.setRemark(OrderReturnDTO.getRemark());
        CustomConfig returnAddressUserName = sysUserClient.getconfig("RETURN_ADDRESS_USER_NAME").getData();
        orderReturnRequest.setRecipientName(returnAddressUserName.getConfigValue());
        CustomConfig returnAddressUserPhone = sysUserClient.getconfig("RETURN_ADDRESS_USER_PHONE").getData();
        orderReturnRequest.setRecipientPhone(returnAddressUserPhone.getConfigValue());
        CustomConfig returnAddressUserAddress = sysUserClient.getconfig("RETURN_ADDRESS_USER_ADDRESS").getData();
        orderReturnRequest.setDetailedAddress(returnAddressUserAddress.getConfigValue());
        this.save(orderReturnRequest);

        OrderReturnRequest one = this.getById(orderReturnRequest.getId());
        OrderReturnVO orderReturnVO = BeanUtils.copyBean(one, OrderReturnVO.class);
        return orderReturnVO;

    }

    @Override
    public void updOrderReturnRequest(OrderReturnDTO OrderReturnDTO) {
        OrderReturnRequest byId = this.getById(OrderReturnDTO.getId());
        byId.setCourierNumber(OrderReturnDTO.getCourierNumber());
        this.updateById(byId);
    }

    @Override
    public OrderReturnVO OrderReturnRequestInfo(OrderReturnDTO OrderReturnDTO) {
        LambdaQueryWrapper<OrderReturnRequest> wrapper= Wrappers.lambdaQuery();
        wrapper.eq(OrderReturnRequest::getOrderId,OrderReturnDTO.getOrderId());
        wrapper.orderByDesc(OrderReturnRequest::getCreateTime);
        List<OrderReturnRequest> list = this.list(wrapper);
        OrderReturnVO orderReturnVO =null;
        if(list.size()>0){
            orderReturnVO= BeanUtils.copyBean(list.get(0), OrderReturnVO.class);
        }
        return orderReturnVO;

    }

    @Override
    public void qxReturnRequest(OrderReturnDTO OrderReturnDTO) {
        OrderReturnRequest byId = this.getById(OrderReturnDTO.getId());
        byId.setStatus(ReturnRequestStatusEnum.QX);
        Order order = orderMapper.selectById(byId.getOrderId());
        order.setOrderStatus(OrderStatusEnum.FINISHED);
        order.setIsRequest(1);
        orderMapper.updateById(order);
        this.removeById(byId);
    }

    @Override
    public void wlReturnRequest(OrderReturnDTO OrderReturnDTO) {
        OrderReturnRequest byId = this.getById(OrderReturnDTO.getId());
        byId.setStatus(ReturnRequestStatusEnum.TO_BE_RECEIVED_BY_THE_PLATFORM);
        byId.setLogisticsNum(OrderReturnDTO.getLogistics());
        byId.setCourierNumber(OrderReturnDTO.getCourierNumber());
        this.updateById(byId);
    }

    /**
     * 获取售后管理列表分页数据
     *
     * @param query 售后管理查询对象
     * @return PageDTO<MgtOrderReturnRequestVO>
     */
    @Override
    public PageDTO<MgtOrderReturnRequestVO> getOrderReturnRequestPage(
            MgtOrderReturnRequestQuery query) {
        Set<Long> memberIdSet;
        Page<MgtOrderReturnRequestVO> page = new Page<>(query.getPageCurr(), query.getPageSize());
        if (StringUtils.isNotBlank(query.getNickname()) || StringUtils.isNotBlank(
                query.getPhone())) {
            MemberDTO memberDTO = new MemberDTO();
            memberDTO.setNickname(query.getNickname());
            memberDTO.setPhone(query.getPhone());
            List<Member> memberList = memberClient.getMemberListByCondition(memberDTO,
                    SecurityConstants.INNER).getData();
            if (StringUtils.isEmpty(memberList)) {
                return PageDTO.empty(page);
            }
            memberIdSet = memberList.stream().map(Member::getId)
                    .collect(Collectors.toSet());
            query.setMemberIdSet(memberIdSet);
        }
        page = baseMapper.getOrderReturnRequestPage(page, query);
        if (StringUtils.isEmpty(page.getRecords())) {
            return PageDTO.empty(page);
        }
        Set<Long> memIdSet = page.getRecords().stream().map(MgtOrderReturnRequestVO::getMemberId)
                .collect(Collectors.toSet());
        List<Member> members = memberClient.getMemberListByIds(memIdSet, SecurityConstants.INNER)
                .getData();
        Map<Long, Member> memberMap = members.stream()
                .collect(Collectors.toMap(Member::getId, Function.identity()));
        page.getRecords().forEach(item -> {
            Member member = memberMap.get(item.getMemberId());
            if (StringUtils.isNotNull(member)) {
                item.setNickname(member.getNickname());
                item.setPhone(member.getPhone());
            }
        });
        return PageDTO.of(page);
    }

    /**
     * 查看详情
     *
     * @param id 售后id
     * @return MgtOrderReturnRequestVO
     */
    @Override
    public MgtOrderReturnRequestVO getOrderReturnRequestDetail(Long id) {
        MgtOrderReturnRequestVO returnRequestVO = baseMapper.getOrderReturnRequestDetail(id);
        // 远程调用member服务，获取会员信息
        Member member = memberClient.getMembeOne(returnRequestVO.getMemberId(),
                SecurityConstants.INNER).getData();
        if (StringUtils.isNotNull(member)) {
            returnRequestVO.setNickname(member.getNickname());
            returnRequestVO.setPhone(member.getPhone());
        }
        if (returnRequestVO.getRequestType() == RequestTypeEnum.REFUNDS_AND_RETURNS
                && returnRequestVO.getStatus()
                == ReturnRequestStatusEnum.TO_BE_RECEIVED_BY_THE_PLATFORM
                && returnRequestVO.getAuditStatus() == AuditStatusEnum.PASSED) {
            LogisticsDTO logisticsDTO = new LogisticsDTO();
            logisticsDTO.setCompany(returnRequestVO.getLogisticsNum());
            logisticsDTO.setPostid(returnRequestVO.getCourierNumber());
            Express100VO logisticsList = logisticsService.getLogisticsList(logisticsDTO);
            if (StringUtils.isNotNull(logisticsList)) {
                returnRequestVO.setExpress100VO(logisticsList);
            }
        }
        return returnRequestVO;
    }

    /**
     * 审核
     *
     * @param dto 管理后台-售后审核传输对象
     */
    @Override
    public void auditReturnRequest(MgtReturnRequestAuditDTO dto) {
        OrderReturnRequest orderReturnRequest = getOrderReturnRequest(dto.getId());
        if (orderReturnRequest.getAuditStatus() != AuditStatusEnum.TO_BE_REVIEWED) {
            throw new ServiceException("该售后已被审核");
        }
        Order order = orderMapper.selectById(orderReturnRequest.getOrderId());
        if (dto.getAuditStatus() == AuditStatusEnum.PASSED) {
            if (orderReturnRequest.getRequestType()
                    .equals(RequestTypeEnum.REFUNDS_AND_RETURNS)) {
                orderReturnRequest.setStatus(ReturnRequestStatusEnum.TO_BE_RETURNED);
            } else {
                orderReturnRequest.setStatus(ReturnRequestStatusEnum.COMPLETED);

                if (Objects.nonNull(order)) {
                    Paylog paylog = paylogService.lambdaQuery()
                            .eq(Paylog::getOutTradeNo, order.getOrderNo())
                            .last("limit 1").one();
                    if (StringUtils.isNotNull(paylog)) {
                        PaymentMethodEnum paymentMethod = order.getPaymentMethod();
                        boolean result = handleRefund(paymentMethod, paylog,
                                paylog.getOutTradeNo());
                        if (result) {
                            paylog.setState(3);// 已退款
                            paylogService.updateById(paylog);
                        }
                    }
                }
            }
            orderReturnRequest.setAuditStatus(AuditStatusEnum.PASSED);
        } else {
            orderReturnRequest.setStatus(ReturnRequestStatusEnum.REJECTED);
            orderReturnRequest.setAuditStatus(AuditStatusEnum.REJECTED);
            orderReturnRequest.setRefuseReason(dto.getRefuseComment());
            if (Objects.nonNull(order)) {
                order.setIsRequest(1);
                orderMapper.updateById(order);
            }
        }
        orderReturnRequest.setAuditTime(LocalDateTime.now());
        this.updateById(orderReturnRequest);
    }

    private OrderReturnRequest getOrderReturnRequest(Long id) {
        OrderReturnRequest orderReturnRequest = this.getById(id);
        if (StringUtils.isNull(orderReturnRequest)) {
            throw new ServiceException("售后不存在");
        }
        return orderReturnRequest;
    }

    @Override
    @GlobalTransactional(rollbackFor = Exception.class)
    @Transactional
    public void confirmReturnRequest(Long id) {
        OrderReturnRequest orderReturnRequest = getOrderReturnRequest(id);
        if (orderReturnRequest.getStatus()
                != ReturnRequestStatusEnum.TO_BE_RECEIVED_BY_THE_PLATFORM
                || orderReturnRequest.getAuditStatus() != AuditStatusEnum.PASSED) {
            throw new ServiceException("该售后状态不允许确认收货");
        }
        orderReturnRequest.setStatus(ReturnRequestStatusEnum.COMPLETED);
        orderReturnRequest.setPlatformReceiptTime(LocalDateTime.now());
        this.updateById(orderReturnRequest);
        // 退款
        Order order = orderMapper.selectById(orderReturnRequest.getOrderId());

        if (StringUtils.isNull(order)) {
            throw new ServiceException("订单不存在");
        }
        String orderNo = order.getOrderNo();
        Paylog paylog = paylogService.lambdaQuery().eq(Paylog::getOutTradeNo, orderNo)
                .last("limit 1").one();
        if (StringUtils.isNotNull(paylog)) {
            PaymentMethodEnum paymentMethod = order.getPaymentMethod();
            boolean result = handleRefund(paymentMethod, paylog, orderNo);
            if (result) {
                paylog.setState(3);// 已退款
                paylogService.updateById(paylog);
            }
        }
        // 扣除订单积分
        Member member = memberClient.getMembeOne(order.getMemberId(), SecurityConstants.INNER)
                .getData();
        if (StringUtils.isNotNull(member)) {
            MemberPointsDTO memberPointsDTO = new MemberPointsDTO();
            memberPointsDTO.setMemberId(order.getMemberId());
            memberPointsDTO.setPointsType(1);
            memberPointsDTO.setPointsStatus(PointStatusEnum.INCREASE);
            memberPointsDTO.setPoints(order.getPoints());
            memberClient.addMemberPoints(memberPointsDTO);

            updMembeOneDTO updMembeOneDTO = new updMembeOneDTO();
            updMembeOneDTO.setMemberId(order.getMemberId());
            updMembeOneDTO.setType(2);
            updMembeOneDTO.setTotalPoints(Math.max(member.getTotalPoints() - order.getPoints(), 0));
            memberClient.updMembeOne(updMembeOneDTO, SecurityConstants.INNER);
        }
        if (Objects.nonNull(order.getCouponId())) {
            CouponMemberDTO dto = new CouponMemberDTO();
            dto.setId(order.getCouponId());
            dto.setCouponStatus(CouponUseEnum.UNUSED.getCode());
            promotionClient.updCouponMember(dto, SecurityConstants.INNER);
        }
    }

    private boolean handleRefund(PaymentMethodEnum paymentMethod, Paylog paylog, String orderNo) {
        boolean result = false;
        if (paymentMethod == PaymentMethodEnum.WECHAT) {
            String refundMoney = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100D);
            int refundFee = Integer.parseInt(
                    refundMoney.substring(0, refundMoney.length() - 3));
            String money = SinataUtil.doubleRetainTwo(paylog.getPayMoney() * 100D);
            Integer totalFee = Integer.parseInt(money.substring(0, money.length() - 3));
            String regEx = "[^0-9]";
            Pattern p = Pattern.compile(regEx);
            Matcher m = p.matcher(orderNo);
            String ma = m.replaceAll("").trim();
            result = paylogService.refundForWxpay(2, paylog.getTradeNo(),
                    paylog.getOutTradeNo(), "R" + ma, totalFee, refundFee, "4");
        } else if (paymentMethod == PaymentMethodEnum.ALIPAY) {
            result = paylogService.refundForAlipay(paylog.getOutTradeNo(), paylog.getTradeNo(),
                    paylog.getPayMoney());
        }
        return result;
    }
}