FrameTour-BE/src/main/java/com/ycwl/basic/biz/OrderBiz.java

package com.ycwl.basic.biz;

import com.ycwl.basic.enums.StatisticEnum;
import com.ycwl.basic.integration.common.manager.ScenicConfigManager;
import com.ycwl.basic.mapper.OrderMapper;
import com.ycwl.basic.mapper.SourceMapper;
import com.ycwl.basic.mapper.StatisticsMapper;
import com.ycwl.basic.mapper.VideoMapper;
import com.ycwl.basic.model.mobile.order.IsBuyRespVO;
import com.ycwl.basic.model.mobile.order.PriceObj;
import com.ycwl.basic.model.mobile.statistic.req.StatisticsRecordAddReq;
import com.ycwl.basic.model.pc.coupon.entity.CouponEntity;
import com.ycwl.basic.model.pc.couponRecord.resp.CouponRecordQueryResp;
import com.ycwl.basic.model.pc.face.entity.FaceEntity;
import com.ycwl.basic.model.pc.order.entity.OrderEntity;
import com.ycwl.basic.model.pc.order.entity.OrderItemEntity;
import com.ycwl.basic.model.pc.order.resp.OrderAppRespVO;
import com.ycwl.basic.model.pc.order.resp.OrderItemVO;
import com.ycwl.basic.model.pc.scenic.entity.ScenicConfigEntity;
import com.ycwl.basic.model.pc.source.entity.SourceEntity;
import com.ycwl.basic.model.pc.task.entity.TaskEntity;
import com.ycwl.basic.model.pc.template.resp.TemplateRespVO;
import com.ycwl.basic.model.pc.video.entity.VideoEntity;
import com.ycwl.basic.pricing.dto.PriceCalculationRequest;
import com.ycwl.basic.pricing.dto.PriceCalculationResult;
import com.ycwl.basic.pricing.dto.ProductItem;
import com.ycwl.basic.pricing.enums.ProductType;
import com.ycwl.basic.pricing.service.IPriceCalculationService;
import com.ycwl.basic.profitsharing.biz.ProfitSharingBiz;
import com.ycwl.basic.repository.FaceRepository;
import com.ycwl.basic.repository.OrderRepository;
import com.ycwl.basic.repository.ScenicRepository;
import com.ycwl.basic.repository.SourceRepository;
import com.ycwl.basic.repository.TemplateRepository;
import com.ycwl.basic.repository.VideoRepository;
import com.ycwl.basic.repository.VideoTaskRepository;
import com.ycwl.basic.service.printer.PrinterService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Optional;

@Component
public class OrderBiz {

    @Autowired
    private VideoMapper videoMapper;
    @Autowired
    private ScenicRepository scenicRepository;
    @Autowired
    private TemplateRepository templateRepository;
    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private FaceRepository faceRepository;
    @Autowired
    private SourceRepository sourceRepository;
    @Autowired
    private VideoRepository videoRepository;
    @Autowired
    private StatisticsMapper statisticsMapper;
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private SourceMapper sourceMapper;
    @Autowired
    private ProfitSharingBiz profitSharingBiz;
    @Autowired
    private VideoTaskRepository videoTaskRepository;
    @Autowired
    private BrokerBiz brokerBiz;
    @Autowired
    private CouponBiz couponBiz;
    @Autowired
    @Lazy
    private PrinterService printerService;
    @Autowired
    private IPriceCalculationService iPriceCalculationService;

    public PriceObj queryPrice(Long scenicId, int goodsType, Long goodsId) {
        PriceObj priceObj = new PriceObj();
        priceObj.setGoodsType(goodsType);
        priceObj.setGoodsId(goodsId);
        ScenicConfigEntity scenicConfig = scenicRepository.getScenicConfig(scenicId);
        if (scenicConfig != null) {
            if (Boolean.TRUE.equals(scenicConfig.getAllFree())) {
                // 景区全免
                priceObj.setFree(true);
                priceObj.setPrice(BigDecimal.ZERO);
                priceObj.setSlashPrice(BigDecimal.ZERO);
                return priceObj;
            }
        }
        switch (goodsType) {
            case 0: // video
                VideoEntity video = videoRepository.getVideo(goodsId);
                if (video == null) {
                    return null;
                }
                TaskEntity task = videoTaskRepository.getTaskById(video.getTaskId());
                if (task != null) {
                    priceObj.setFaceId(task.getFaceId());
                }
                TemplateRespVO template = templateRepository.getTemplate(video.getTemplateId());
                if (template == null) {
                    return priceObj;
                }
                PriceCalculationRequest vlogCalculationRequest = new PriceCalculationRequest();
                ProductItem vlogProductItem = new ProductItem();
                vlogProductItem.setProductType(ProductType.VLOG_VIDEO);
                vlogProductItem.setProductId(template.getId().toString());
                vlogProductItem.setQuantity(videoTaskRepository.getTaskLensNum(video.getTaskId()));
                vlogProductItem.setScenicId(scenicId.toString());
                vlogCalculationRequest.setProducts(Collections.singletonList(vlogProductItem));
                vlogCalculationRequest.setFaceId(priceObj.getFaceId());
                vlogCalculationRequest.setPreviewOnly(true); // 仅查询价格，不实际使用优惠
                PriceCalculationResult vlogCalculationResult = iPriceCalculationService.calculatePrice(vlogCalculationRequest);
                priceObj.setPrice(vlogCalculationResult.getFinalAmount());
                priceObj.setSlashPrice(vlogCalculationResult.getOriginalAmount());
                priceObj.setFaceId(goodsId);
                priceObj.setScenicId(video.getScenicId());
                break;
            case 1: // source
            case 2: // source
                FaceEntity face = faceRepository.getFace(goodsId);
                PriceCalculationRequest calculationRequest = new PriceCalculationRequest();
                ProductItem productItem = new ProductItem();
                productItem.setProductType(goodsType == 1 ? ProductType.RECORDING_SET : ProductType.PHOTO_SET);
                productItem.setProductId(scenicId.toString());
                productItem.setPurchaseCount(1);
                productItem.setScenicId(scenicId.toString());
                calculationRequest.setProducts(Collections.singletonList(productItem));
                if (face != null) {
                    calculationRequest.setUserId(face.getMemberId());
                }
                calculationRequest.setFaceId(goodsId);
                calculationRequest.setPreviewOnly(true); // 仅查询价格，不实际使用优惠
                PriceCalculationResult priceCalculationResult = iPriceCalculationService.calculatePrice(calculationRequest);
                priceObj.setPrice(priceCalculationResult.getFinalAmount());
                priceObj.setSlashPrice(priceCalculationResult.getOriginalAmount());
                priceObj.setFaceId(goodsId);
                break;
        }
        return priceObj;
    }

    public OrderEntity hasTypeOrder(Long userId, Long faceId, Long scenicId, int orderType, Integer configId) {
        OrderEntity orderEntity = orderMapper.queryTypeOrder(userId, faceId, scenicId, orderType, configId);
        if (orderEntity == null) {
            return null;
        }
        if (Integer.valueOf(1).equals(orderEntity.getStatus())) {
            return orderEntity;
        } else {
            return null;
        }
    }
    public IsBuyRespVO isBuy(Long scenicId, Long memberId, Long faceId, int goodsType, Long goodsId) {
        IsBuyRespVO respVO = new IsBuyRespVO();
        OrderEntity orderEntity = orderMapper.getUserBuyFaceItem(memberId, faceId, goodsType, goodsId);
        if (orderEntity != null) {
            respVO.setOrderId(orderEntity.getId());
            respVO.setBuy(true);
            respVO.setFree(false);
            return respVO;
        }
        ScenicConfigManager scenicConfig = scenicRepository.getScenicConfigManager(scenicId);
        if (Boolean.TRUE.equals(scenicConfig.getBoolean("all_free"))) {
            // 景区全免
            respVO.setFree(true);
            respVO.setOrigPrice(BigDecimal.ZERO);
            respVO.setSlashPrice(BigDecimal.ZERO);
            return respVO;
        }
        respVO.setBuy(false);
        return respVO;
    }

    public IsBuyRespVO isBuy(Long userId, Long scenicId, int goodsType, Long goodsId) {
        IsBuyRespVO respVO = new IsBuyRespVO();
        boolean isBuy = orderRepository.checkUserBuyItem(userId, goodsType, goodsId);
        // 模板购买逻辑
        if (!isBuy) {
            if (goodsType == 0) {
                VideoEntity video = videoRepository.getVideo(goodsId);
                if (video == null) {
                    return respVO;
                }
                TaskEntity task = videoTaskRepository.getTaskById(video.getTaskId());
                Long templateId = video.getTemplateId();
                // -1为整个模板购买
                OrderEntity orderEntity = orderRepository.getUserBuyItem(userId, -1, templateId);
                if (orderEntity != null && task != null) {
                    respVO.setOrderId(orderEntity.getId());
                    if (orderEntity.getFaceId() != null && task.getFaceId() != null) {
                        isBuy = orderEntity.getFaceId().equals(task.getFaceId());
                    }
                }
            }
        }
        // 免费送逻辑，之前已经赠送了的
        if (!isBuy) {
            isBuy = switch (goodsType) {
                case 0 -> videoRepository.getUserIsBuy(userId, goodsId);
                case 1, 2 -> sourceRepository.getUserIsBuy(userId, goodsType, goodsId);
                default -> false;
            };
        } else {
            OrderEntity orderEntity = orderRepository.getUserBuyItem(userId, goodsType, goodsId);
            if (orderEntity != null) {
                respVO.setOrderId(orderEntity.getId());
            }
        }
        respVO.setBuy(isBuy);
        // 还是没买
        if (!isBuy) {
            PriceObj priceObj = queryPrice(scenicId, goodsType, goodsId);
            if (priceObj == null) {
                return respVO;
            }
            FaceEntity face = faceRepository.getFace(priceObj.getFaceId());
            respVO.setShare(true);
            if (face != null && face.getMemberId().equals(userId)) {
                respVO.setShare(false);
            }
            respVO.setFree(priceObj.isFree());
            respVO.setGoodsType(goodsType);
            respVO.setGoodsId(goodsId);
            respVO.setOrigPrice(priceObj.getPrice());
            respVO.setSlashPrice(priceObj.getSlashPrice());
            switch (goodsType) {
                case 0: // vlog
                    VideoEntity video = videoRepository.getVideo(goodsId);
                    TaskEntity taskById = videoTaskRepository.getTaskById(video.getTaskId());
                    if (taskById != null) {
                        CouponRecordQueryResp recordQueryResp = couponBiz.queryUserCouponRecord(scenicId, userId, taskById.getFaceId(), taskById.getTemplateId().toString());
                        if (recordQueryResp.isUsable()) {
                            respVO.setCouponId(recordQueryResp.getCouponId());
                            respVO.setCouponRecordId(recordQueryResp.getId());
                            CouponEntity coupon = recordQueryResp.getCoupon();
                            if (coupon != null) {
                                respVO.setCouponPrice(coupon.calculateDiscountPrice(priceObj.getPrice()));
                            }
                        }
                    }
                    break;
                case 1:
                case 2:
                    CouponRecordQueryResp recordQueryResp = couponBiz.queryUserCouponRecord(scenicId, userId, goodsId, String.valueOf(goodsType));
                    if (recordQueryResp.isUsable()) {
                        respVO.setCouponId(recordQueryResp.getCouponId());
                        respVO.setCouponRecordId(recordQueryResp.getId());
                        CouponEntity coupon = recordQueryResp.getCoupon();
                        if (coupon != null) {
                            respVO.setCouponPrice(coupon.calculateDiscountPrice(priceObj.getPrice()));
                        }
                    }
                    break;

            }
        }
        return respVO;
    }

    public void paidOrder(Long orderId) {
        orderRepository.clearOrderCache(orderId); // 检查支付呢，还缓存
        OrderEntity order = orderRepository.getOrder(orderId);
        List<OrderItemEntity> orderItems = orderRepository.getOrderItems(orderId);
        OrderEntity orderUpdate = new OrderEntity();
        orderUpdate.setPayAt(new Date());
        orderUpdate.setStatus(1);
        orderRepository.updateOrder(orderId, orderUpdate);
        orderItems.forEach(item -> {
            switch (item.getGoodsType()) {
                case 0: // vlog视频
                    videoRepository.setUserIsBuyItem(order.getMemberId(), item.getGoodsId(), order.getId());
                    break;
                case 1: // 视频原素材
                case 2: // 照片原素材
                    sourceRepository.setUserIsBuyItem(order.getMemberId(), item.getGoodsType(), item.getGoodsId(), order.getId());
                    break;
                case 3:
                    printerService.setUserIsBuyItem(order.getMemberId(), item.getGoodsId(), order.getId());
                    break;
            }
        });
        orderRepository.clearOrderCache(orderId); // 更新完了，清理下
        Integer couponRecordId = order.getCouponRecordId();
        if (couponRecordId != null) {
            couponBiz.userUseCoupon(order.getMemberId(), order.getFaceId(), couponRecordId, orderId);
        }
        StatisticsRecordAddReq statisticsRecordAddReq = new StatisticsRecordAddReq();
        statisticsRecordAddReq.setMemberId(order.getMemberId());
        Long enterType = statisticsMapper.getUserRecentEnterType(order.getMemberId(), order.getCreateAt());
        if(!Long.valueOf(1014).equals(enterType)){//
            statisticsRecordAddReq.setType(StatisticEnum.ON_SITE_PAYMENT.code);
        }else {
            statisticsRecordAddReq.setType(StatisticEnum.POST_PAYMENT.code);
        }
        statisticsRecordAddReq.setScenicId(order.getScenicId());
        statisticsRecordAddReq.setMorphId(orderId);
        statisticsMapper.addStatisticsRecord(statisticsRecordAddReq);
        profitSharingBiz.processProfitSharing(order.getScenicId(), orderId, order.getPayPrice());
        brokerBiz.processOrder(orderId);
    }

    public void cancelOrder(Long orderId) {
        orderRepository.clearOrderCache(orderId); // 检查支付呢，还缓存
        OrderEntity order = orderRepository.getOrder(orderId);
        List<OrderItemEntity> orderItems = orderRepository.getOrderItems(orderId);
        OrderEntity orderUpdate = new OrderEntity();
        orderUpdate.setCancelAt(new Date());
        orderUpdate.setStatus(9);
        orderRepository.updateOrder(orderId, orderUpdate);
        orderItems.forEach(item -> {
            switch (item.getGoodsType()) {
                case 0: // vlog视频
                    videoRepository.setUserNotBuyItem(order.getMemberId(), item.getGoodsId());
                case 1: // 视频原素材
                case 2: // 照片原素材
                    sourceRepository.setUserNotBuyItem(order.getMemberId(), item.getGoodsType(), item.getGoodsId());
            }
        });
        orderRepository.clearOrderCache(orderId); // 更新完了，清理下
        profitSharingBiz.revokeProfitSharing(order.getScenicId(), orderId, "订单被取消");
    }

    public void refundOrder(Long orderId) {
        orderRepository.clearOrderCache(orderId);
        OrderEntity order = orderRepository.getOrder(orderId);
        List<OrderItemEntity> orderItems = orderRepository.getOrderItems(orderId);
        OrderEntity orderUpdate = new OrderEntity();
        orderUpdate.setRefundAt(new Date());
        orderUpdate.setStatus(2);
        orderUpdate.setRefundStatus(1);
        orderRepository.updateOrder(orderId, orderUpdate);
        orderItems.forEach(item -> {
            switch (item.getGoodsType()) {
                case 0: // vlog视频
                    videoRepository.setUserNotBuyItem(order.getMemberId(), item.getGoodsId());
                case 1: // 视频原素材
                case 2: // 照片原素材
                    sourceRepository.setUserNotBuyItem(order.getMemberId(), item.getGoodsType(), item.getGoodsId());
            }
        });
        orderRepository.clearOrderCache(orderId); // 更新完了，清理下
        profitSharingBiz.revokeProfitSharing(order.getScenicId(), orderId, "订单已退款");
    }

    /**
     * 检查用户是否购买了指定商品
     * 提供给PriceBiz使用，避免循环调用
     */
    public boolean checkUserBuyItem(Long userId, int goodsType, Long goodsId) {
        return orderRepository.checkUserBuyItem(userId, goodsType, goodsId);
    }
}