package com.xiaopeng.order.service.impl;

import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaopeng.api.dto.account.UcUserInfo;
import com.xiaopeng.api.feignClient.account.UserResourcesClient;
import com.xiaopeng.api.feignClient.account.XpAppUserClient;
import com.xiaopeng.api.feignClient.operation.XpSystemSettingClient;
import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
import com.xiaopeng.api.model.order.XpOrder;
import com.xiaopeng.api.model.order.XpOrderEvaluate;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.utils.StringUtils;
import com.xiaopeng.common.core.web.page.PageInfo;
import com.xiaopeng.order.mapper.XpOrderEvaluateMapper;
import com.xiaopeng.order.model.query.OrderEvaluateManagementPageListQuery;
import com.xiaopeng.order.model.query.OrderEvaluatePageQuery;
import com.xiaopeng.order.model.vo.OrderEvaluateManagementPageListVO;
import com.xiaopeng.order.model.vo.OrderEvaluatePageVO;
import com.xiaopeng.order.service.IXpOrderEvaluateService;
import com.xiaopeng.order.service.IXpOrderService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * <p>
 * 订单评价 服务实现类
 * </p>
 *
 * @author mitao
 * @since 2026-02-03
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = @Lazy)
public class XpOrderEvaluateServiceImpl extends ServiceImpl<XpOrderEvaluateMapper, XpOrderEvaluate> implements IXpOrderEvaluateService {

    private final XpAppUserClient xpAppUserClient;
    private final XpVehicleClient xpVehicleClient;
    @Lazy
    @Autowired
    private IXpOrderService xpOrderService;
    private final UserResourcesClient userResourcesClient;
    private final XpSystemSettingClient systemSettingClient;

    @Override
    public PageInfo<OrderEvaluatePageVO> pageList(OrderEvaluatePageQuery query) {
        List<Long> vehicleIdsFilter = null;
        if (StringUtils.isNotBlank(query.getPlateNumber())) {
            R<List<XpVehicle>> vehicleResult = xpVehicleClient.listByPlateNumber(query.getPlateNumber());
            if (vehicleResult == null || CollectionUtils.isEmpty(vehicleResult.getData())) {
                return buildEmptyEvaluatePage(query);
            }
            vehicleIdsFilter = vehicleResult.getData().stream()
                    .map(XpVehicle::getId)
                    .filter(Objects::nonNull)
                    .distinct()
                    .collect(Collectors.toList());
            if (CollectionUtils.isEmpty(vehicleIdsFilter)) {
                return buildEmptyEvaluatePage(query);
            }
        }

        Long appUserIdFilter = null;
        if (StringUtils.isNotBlank(query.getPhoneNumber())) {
            UcUserInfo userByMobile = userResourcesClient.getUserByMobile(query.getPhoneNumber());
            if (userByMobile == null || userByMobile.getUid() == null) {
                return buildEmptyEvaluatePage(query);
            }
            appUserIdFilter = userByMobile.getUid();
        }

        // 1. 构建查询条件
        LambdaQueryWrapper<XpOrderEvaluate> wrapper = new LambdaQueryWrapper<>();

        // 时间范围查询
        if (Objects.nonNull(query.getStartTime())) {
            wrapper.ge(XpOrderEvaluate::getEvaluateTime, LocalDateTime.of(query.getStartTime(), LocalTime.MIN));

        }
        if (Objects.nonNull(query.getEndTime())) {
            wrapper.le(XpOrderEvaluate::getEvaluateTime, LocalDateTime.of(query.getEndTime(), LocalTime.MAX));
        }

        // 评价分数查询（可选）
        if (Objects.nonNull(query.getOrderRating())) {
            wrapper.eq(XpOrderEvaluate::getOrderRating, query.getOrderRating());
        }
        if (!CollectionUtils.isEmpty(vehicleIdsFilter)) {
            wrapper.in(XpOrderEvaluate::getVehicleId, vehicleIdsFilter);
        }
        if (Objects.nonNull(appUserIdFilter)) {
            wrapper.eq(XpOrderEvaluate::getAppUserId, appUserIdFilter);
        }

        // 排序：按评价时间降序
        wrapper.orderByDesc(XpOrderEvaluate::getEvaluateTime);

        // 2. 分页查询
        PageInfo<XpOrderEvaluate> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        Page<XpOrderEvaluate> evaluatePage = this.page(pageInfo, wrapper);

        if (CollectionUtils.isEmpty(evaluatePage.getRecords())) {
            return buildEmptyEvaluatePage(query);
        }

        // 3. 收集关联ID
        Set<Long> userIds = new HashSet<>();
        Set<Long> vehicleIds = new HashSet<>();
        Set<Long> orderIds = new HashSet<>();

        for (XpOrderEvaluate evaluate : evaluatePage.getRecords()) {
            if (Objects.nonNull(evaluate.getAppUserId())) {
                userIds.add(evaluate.getAppUserId());
            }
            if (Objects.nonNull(evaluate.getVehicleId())) {
                vehicleIds.add(evaluate.getVehicleId());
            }
            if (Objects.nonNull(evaluate.getOrderId())) {
                orderIds.add(evaluate.getOrderId());
            }
        }

        // 4. 批量查询关联数据
        Map<String, UcUserInfo> userInfoMap = batchGetUsers(userIds);
        Map<Long, XpVehicle> vehicleMap = batchGetVehicles(vehicleIds);
        Map<Long, XpOrder> orderMap = batchGetOrders(orderIds);

        // 5. 组装 VO
        List<OrderEvaluatePageVO> voList = evaluatePage.getRecords().stream()
                .map(evaluate -> convertToPageVO(evaluate, userInfoMap, vehicleMap, orderMap))
                .collect(Collectors.toList());

        // 6. 返回分页结果
        PageInfo<OrderEvaluatePageVO> resultPage = new PageInfo<>(query.getPageNum(), query.getPageSize());
        resultPage.setTotal(evaluatePage.getTotal());
        resultPage.setRecords(voList);
        return resultPage;
    }

    private PageInfo<OrderEvaluatePageVO> buildEmptyEvaluatePage(OrderEvaluatePageQuery query) {
        PageInfo<OrderEvaluatePageVO> resultPage = new PageInfo<>(query.getPageNum(), query.getPageSize());
        resultPage.setTotal(0L);
        resultPage.setRecords(new ArrayList<>());
        return resultPage;
    }

    @Override
    public PageInfo<OrderEvaluateManagementPageListVO> managementPageList(OrderEvaluateManagementPageListQuery query) {
        PageInfo<OrderEvaluateManagementPageListVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<OrderEvaluateManagementPageListVO> list = this.baseMapper.managementPageList(pageInfo, query);
        if (list.isEmpty()) {
            return new PageInfo<>();
        }
        List<Long> userIds = list.stream().map(OrderEvaluateManagementPageListVO::getUserId).collect(Collectors.toList());
        Map<String, UcUserInfo> userInfoMap = userResourcesClient.getUserListByUids(userIds, false);
        for (OrderEvaluateManagementPageListVO orderEvaluateManagementPageListVO : list) {
            if (userInfoMap != null && !userInfoMap.isEmpty()) {
                UcUserInfo userInfo = userInfoMap.get(orderEvaluateManagementPageListVO.getUserId().toString());
                if (userInfo != null) {
                    orderEvaluateManagementPageListVO.setPhoneNumber(userInfo.getMobile());
                    orderEvaluateManagementPageListVO.setNickName(userInfo.getNickName());
                    orderEvaluateManagementPageListVO.setHeadImage(userInfo.getHeadImg());
                }
            } else {
                orderEvaluateManagementPageListVO.setPhoneNumber("19983174515");
                orderEvaluateManagementPageListVO.setNickName("默认用户");
                orderEvaluateManagementPageListVO.setHeadImage("[]");
            }
            systemSettingClient.getFeedbackTypeById(orderEvaluateManagementPageListVO.getFeedbackTypeId());
        }

        pageInfo.setRecords(list);
        return pageInfo;
    }

    /**
     * 批量获取用户信息
     */
    private Map<String, UcUserInfo> batchGetUsers(Set<Long> userIds) {
        if (CollectionUtils.isEmpty(userIds)) {
            return new HashMap<>();
        }
        return userResourcesClient.getUserListByUids(new ArrayList<>(userIds), false);
    }

    /**
     * 批量获取车辆信息
     */
    private Map<Long, XpVehicle> batchGetVehicles(Set<Long> vehicleIds) {
        if (CollectionUtils.isEmpty(vehicleIds)) {
            return new HashMap<>();
        }
        try {
            R<List<XpVehicle>> result = xpVehicleClient.listByIds(new ArrayList<>(vehicleIds));
            if (Objects.nonNull(result) && Objects.nonNull(result.getData())) {
                return result.getData().stream()
                        .collect(Collectors.toMap(XpVehicle::getId, Function.identity(), (a, b) -> a));
            }
        } catch (Exception e) {
            log.error("批量获取车辆信息失败: {}", e.getMessage());
        }
        return new HashMap<>();
    }

    /**
     * 批量获取订单信息
     */
    private Map<Long, XpOrder> batchGetOrders(Set<Long> orderIds) {
        if (CollectionUtils.isEmpty(orderIds)) {
            return new HashMap<>();
        }
        List<XpOrder> orders = xpOrderService.listByIds(new ArrayList<>(orderIds));
        return orders.stream()
                .collect(Collectors.toMap(XpOrder::getId, Function.identity(), (a, b) -> a));
    }

    /**
     * VO转换
     */
    private OrderEvaluatePageVO convertToPageVO(XpOrderEvaluate evaluate,
                                                Map<String, UcUserInfo> userInfoMap,
                                                Map<Long, XpVehicle> vehicleMap,
                                                Map<Long, XpOrder> orderMap) {
        OrderEvaluatePageVO vo = new OrderEvaluatePageVO();
        vo.setId(evaluate.getId());
        vo.setOrderId(evaluate.getOrderId());
        vo.setVehicleId(evaluate.getVehicleId());
        vo.setAppUserId(evaluate.getAppUserId());
        vo.setOrderRating(evaluate.getOrderRating());
        vo.setEvaluateTime(evaluate.getEvaluateTime());

        // 用户信息
        if (Objects.nonNull(evaluate.getAppUserId()) && userInfoMap != null && userInfoMap.containsKey(evaluate.getAppUserId().toString())) {
            UcUserInfo userInfo = userInfoMap.get(evaluate.getAppUserId().toString());
            vo.setNickName(userInfo.getNickName());
            vo.setPhoneNumber(userInfo.getMobile());
        }

        // 车辆信息
        if (Objects.nonNull(evaluate.getVehicleId()) && vehicleMap.containsKey(evaluate.getVehicleId())) {
            XpVehicle vehicle = vehicleMap.get(evaluate.getVehicleId());
            vo.setPlateNumber(vehicle.getPlateNumber());
        }

        // 订单信息
        if (Objects.nonNull(evaluate.getOrderId()) && orderMap.containsKey(evaluate.getOrderId())) {
            XpOrder order = orderMap.get(evaluate.getOrderId());
            vo.setOrderNumber(order.getOrderNumber());
        }

        return vo;
    }
}