package com.tourguide.modules.order.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tourguide.common.api.PageResponse;
import com.tourguide.common.exception.BusinessException;
import com.tourguide.modules.order.domain.OrderStatus;
import com.tourguide.modules.order.dto.MiniOrderListResponse;
import com.tourguide.modules.order.dto.MiniOrderSummaryResponse;
import com.tourguide.modules.order.entity.TourOrder;
import com.tourguide.modules.order.mapper.TourOrderMapper;
import com.tourguide.modules.review.entity.OrderReview;
import com.tourguide.modules.review.mapper.OrderReviewMapper;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/** 游客小程序个人订单查询服务。 */
@Service
public class MiniTourOrderService {
    private static final String TAB_ALL = "all";
    private static final String TAB_PENDING_PAY = "pendingPay";
    private static final String TAB_PENDING_GUIDE = "pendingGuide";
    private static final String TAB_SERVING = "serving";
    private static final String TAB_COMPLETED = "completed";

    private final TourOrderMapper orderMapper;
    private final OrderReviewMapper reviewMapper;

    public MiniTourOrderService(TourOrderMapper orderMapper, OrderReviewMapper reviewMapper) {
        this.orderMapper = orderMapper;
        this.reviewMapper = reviewMapper;
    }

    public PageResponse<MiniOrderListResponse> page(Long visitorId, String tab, long page, long size) {
        String normalizedTab = StringUtils.hasText(tab) ? tab.trim() : TAB_ALL;
        LambdaQueryWrapper<TourOrder> query = new LambdaQueryWrapper<TourOrder>()
                .eq(TourOrder::getVisitorId, visitorId);
        applyTabFilter(query, normalizedTab);
        query.orderByDesc(TourOrder::getPlacedAt).orderByDesc(TourOrder::getId);
        Page<TourOrder> result = orderMapper.selectPage(new Page<TourOrder>(page, size), query);
        Set<Long> reviewedOrderIds = reviewedOrderIds(result.getRecords());
        List<MiniOrderListResponse> records = result.getRecords().stream()
                .map(order -> MiniOrderListResponse.from(order, reviewedOrderIds.contains(order.getId())))
                .collect(Collectors.toList());
        return new PageResponse<MiniOrderListResponse>(records, result.getTotal(), result.getCurrent(), result.getSize());
    }

    public MiniOrderSummaryResponse summary(Long visitorId) {
        return new MiniOrderSummaryResponse(
                count(visitorId, Collections.singletonList(OrderStatus.PENDING_PAYMENT.getCode())),
                count(visitorId, Collections.singletonList(OrderStatus.PENDING_MEETING.getCode())),
                count(visitorId, Collections.singletonList(OrderStatus.IN_SERVICE.getCode())),
                count(visitorId, Collections.singletonList(OrderStatus.COMPLETED.getCode())));
    }

    private void applyTabFilter(LambdaQueryWrapper<TourOrder> query, String tab) {
        if (TAB_ALL.equals(tab)) { return; }
        if (TAB_PENDING_PAY.equals(tab)) {
            query.eq(TourOrder::getStatus, OrderStatus.PENDING_PAYMENT.getCode());
            return;
        }
        if (TAB_PENDING_GUIDE.equals(tab)) {
            query.eq(TourOrder::getStatus, OrderStatus.PENDING_MEETING.getCode());
            return;
        }
        if (TAB_SERVING.equals(tab)) {
            query.eq(TourOrder::getStatus, OrderStatus.IN_SERVICE.getCode());
            return;
        }
        if (TAB_COMPLETED.equals(tab)) {
            query.eq(TourOrder::getStatus, OrderStatus.COMPLETED.getCode());
            return;
        }
        throw new BusinessException(400, "订单筛选状态不合法");
    }

    private Set<Long> reviewedOrderIds(List<TourOrder> orders) {
        if (orders.isEmpty()) { return Collections.emptySet(); }
        List<Long> orderIds = orders.stream().map(TourOrder::getId).collect(Collectors.toList());
        return reviewMapper.selectList(new LambdaQueryWrapper<OrderReview>()
                        .select(OrderReview::getOrderId)
                        .eq(OrderReview::getStatus, 1)
                        .in(OrderReview::getOrderId, orderIds))
                .stream().map(OrderReview::getOrderId).collect(Collectors.toSet());
    }

    private long count(Long visitorId, List<String> statuses) {
        return orderMapper.selectCount(new LambdaQueryWrapper<TourOrder>()
                .eq(TourOrder::getVisitorId, visitorId)
                .in(TourOrder::getStatus, statuses));
    }
}