package com.xiaopeng.maintenance.service.impl;

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xiaopeng.api.feignClient.account.XpOperationUserClient;
import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
import com.xiaopeng.api.model.account.XpOperationsUser;
import com.xiaopeng.api.model.maintenance.XpVehiclePreparation;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaopeng.api.vo.automaticPilot.VehiclePosition;
import com.xiaopeng.evi.oss.service.AliOssService;
import com.xiaopeng.maintenance.model.query.XpVehiclePreparationPageQuery;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
import com.xiaopeng.api.vo.maintenance.XpVehiclePreparationDetailVO;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.web.page.PageInfo;
import com.xiaopeng.maintenance.mapper.*;
import com.xiaopeng.maintenance.model.query.OperationRecordsQuery;
import com.xiaopeng.maintenance.model.vo.OperationRecordsVO;
import com.xiaopeng.maintenance.model.vo.XpVehiclePreparationVO;
import com.xiaopeng.maintenance.service.IXpVehiclePreparationService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * <p>
 * 车辆整备 服务实现类
 * </p>
 *
 * @author mitao
 * @since 2026-02-03
 */
@Service
public class XpVehiclePreparationServiceImpl extends ServiceImpl<XpVehiclePreparationMapper, XpVehiclePreparation> implements IXpVehiclePreparationService {

    @Autowired
    private XpVehiclePreparationMapper xpVehiclePreparationMapper;
    @Autowired
    private XpChargingRecordMapper xpChargingRecordMapper;
    @Autowired
    private XpVehicleDetectionMapper xpVehicleDetectionMapper;
    @Autowired
    private XpVehicleRepairMapper xpVehicleRepairMapper;
    @Autowired
    private XpVehicleCleanMapper xpVehicleCleanMapper;
    @Autowired
    private XpOperationUserClient xpOperationUserClient;
    @Autowired
    private XpVehicleClient xpVehicleClient;
    @Autowired
    private MongoTemplate mongoTemplate;
    @Autowired
    private AliOssService aliOssService;

    @Override
    public PageInfo<OperationRecordsVO> operationRecords(OperationRecordsQuery query) {
        PageInfo<OperationRecordsVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<OperationRecordsVO> operationRecords;
        switch (query.getOperationType()) {
            case 1:
                // 整备记录
                operationRecords = xpVehiclePreparationMapper.operationRecords(query,pageInfo);
                break;
            case 2:
                // 充电记录
                operationRecords = xpChargingRecordMapper.operationRecords(query,pageInfo);
                if(!CollectionUtils.isEmpty(operationRecords)){
                    for (OperationRecordsVO operationRecord : operationRecords) {
                        operationRecord.setStartMileageRange(Objects.isNull(operationRecord.getStartMileageRange())?0.0f:operationRecord.getStartMileageRange());
                        operationRecord.setEndMileageRange(Objects.isNull(operationRecord.getEndMileageRange())?0.0f:operationRecord.getEndMileageRange());
                    }
                }
                break;
            case 3:
                // 检测记录
                operationRecords = xpVehicleDetectionMapper.operationRecords(query,pageInfo);
                break;
            case 4:
                // 维修记录
                operationRecords = xpVehicleRepairMapper.operationRecords(query,pageInfo);
                break;
            default:
                // 清洁记录
                operationRecords = xpVehicleCleanMapper.operationRecords(query,pageInfo);
                break;
        }

        if(CollectionUtils.isEmpty(operationRecords)){
            return pageInfo;
        }

        List<Long> userIds = operationRecords.stream().map(OperationRecordsVO::getOperationsUserId).distinct().collect(Collectors.toList());
        // 查询操作人信息
        R<List<XpOperationsUser>> listR = xpOperationUserClient.listByIds(userIds);
        List<XpOperationsUser> xpOperationsUsers = listR.getData();
        if(!CollectionUtils.isEmpty(xpOperationsUsers)){
            for (OperationRecordsVO operationRecord : operationRecords) {
                List<XpOperationsUser> xpOperationsUserList = xpOperationsUsers.stream().filter(xpOperationsUser -> xpOperationsUser.getId().equals(operationRecord.getOperationsUserId())).collect(Collectors.toList());
                if(!CollectionUtils.isEmpty(xpOperationsUserList)){
                    XpOperationsUser xpOperationsUser = xpOperationsUserList.get(0);
                    operationRecord.setOperatorName(xpOperationsUser.getNickName());
                }
            }
        }
        List<Long> vehicleIds = operationRecords.stream().map(OperationRecordsVO::getVehicleId).collect(Collectors.toList());
        // 查询车辆信息
        List<XpVehicle> xpVehicles = xpVehicleClient.listByIds(vehicleIds).getData();
        if(!CollectionUtils.isEmpty(xpVehicles)){
            for (OperationRecordsVO operationRecord : operationRecords) {
                List<XpVehicle> xpVehicleList = xpVehicles.stream().filter(xpVehicle -> xpVehicle.getId().equals(operationRecord.getVehicleId())).collect(Collectors.toList());
                if(!CollectionUtils.isEmpty(xpVehicleList)){
                    XpVehicle xpVehicle = xpVehicleList.get(0);
                    operationRecord.setPlateNumber(xpVehicle.getPlateNumber());
                    operationRecord.setVehiclePictures(xpVehicle.getVehiclePictures());
                    operationRecord.setAcceptOrTest(xpVehicle.getAcceptOrTest());
                }
            }
        }
        pageInfo.setRecords(operationRecords);
        return pageInfo;
    }

    @Override
    public XpVehiclePreparationVO preparationDetail(Long id) {
        // 查询车辆充电记录
        XpVehiclePreparation xpVehiclePreparation = this.getById(id);
        XpVehiclePreparationVO xpVehiclePreparationVO = new XpVehiclePreparationVO();
        BeanUtils.copyProperties(xpVehiclePreparation, xpVehiclePreparationVO);
        xpVehiclePreparationVO.setOperationTime(xpVehiclePreparation.getCreateTime());

        // 查询车辆信息
        XpVehicle xpVehicle = xpVehicleClient.queryById(xpVehiclePreparation.getVehicleId()).getData();
        if (Objects.nonNull(xpVehicle)) {
            xpVehiclePreparationVO.setPlateNumber(xpVehicle.getPlateNumber());
            xpVehiclePreparationVO.setVehiclePictures(xpVehicle.getVehiclePictures());
            xpVehiclePreparationVO.setAcceptOrTest(xpVehicle.getAcceptOrTest());
            xpVehiclePreparationVO.setVehicleColor(xpVehicle.getVehicleColor());
        }
        // 查询操作人
        XpOperationsUser operationsUserStart = xpOperationUserClient.queryById(xpVehiclePreparationVO.getOperationsUserId()).getData();
        if (Objects.nonNull(operationsUserStart)) {
            xpVehiclePreparationVO.setOperatorStartName(operationsUserStart.getNickName());
        }

        // 图片封装
        try {
            // 大灯
            String headLight = xpVehiclePreparation.getHeadLight();
            if (StringUtils.isNotBlank(headLight)) {
                JSONArray jsonArray = JSONArray.parseArray(headLight);
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject jsonObject = jsonArray.getJSONObject(i);
                    if (Objects.isNull(jsonObject)) {
                        continue;
                    }
                    String downloadUrl = aliOssService.getDownloadUrl(jsonObject.getString("id"), jsonObject.getString("name"), true);
                    jsonObject.put("url", downloadUrl);
                }
                xpVehiclePreparationVO.setHeadLight(JSONArray.toJSONString(jsonArray));
            }
            // 转向灯
            String turnSignal = xpVehiclePreparation.getTurnSignal();
            if (StringUtils.isNotBlank(turnSignal)) {
                JSONArray jsonArray = JSONArray.parseArray(turnSignal);
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject jsonObject = jsonArray.getJSONObject(i);
                    if (Objects.isNull(jsonObject)) {
                        continue;
                    }
                    String downloadUrl = aliOssService.getDownloadUrl(jsonObject.getString("id"), jsonObject.getString("name"), true);
                    jsonObject.put("url", downloadUrl);
                }
                xpVehiclePreparationVO.setTurnSignal(JSONArray.toJSONString(jsonArray));
            }
            // 刹车灯
            String brakeLight = xpVehiclePreparation.getBrakeLight();
            if (StringUtils.isNotBlank(brakeLight)) {
                JSONArray jsonArray = JSONArray.parseArray(brakeLight);
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject jsonObject = jsonArray.getJSONObject(i);
                    if (Objects.isNull(jsonObject)) {
                        continue;
                    }
                    String downloadUrl = aliOssService.getDownloadUrl(jsonObject.getString("id"), jsonObject.getString("name"), true);
                    jsonObject.put("url", downloadUrl);
                }
                xpVehiclePreparationVO.setBrakeLight(JSONArray.toJSONString(jsonArray));
            }
            // 雾灯
            String fogLight = xpVehiclePreparation.getFogLight();
            if (StringUtils.isNotBlank(fogLight)) {
                JSONArray jsonArray = JSONArray.parseArray(fogLight);
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject jsonObject = jsonArray.getJSONObject(i);
                    if (Objects.isNull(jsonObject)) {
                        continue;
                    }
                    String downloadUrl = aliOssService.getDownloadUrl(jsonObject.getString("id"), jsonObject.getString("name"), true);
                    jsonObject.put("url", downloadUrl);
                }
                xpVehiclePreparationVO.setFogLight(JSONArray.toJSONString(jsonArray));
            }
            // 舱内清洁
            String cabinCleaning = xpVehiclePreparation.getCabinCleaning();
            if (StringUtils.isNotBlank(cabinCleaning)) {
                JSONArray jsonArray = JSONArray.parseArray(cabinCleaning);
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject jsonObject = jsonArray.getJSONObject(i);
                    if (Objects.isNull(jsonObject)) {
                        continue;
                    }
                    String downloadUrl = aliOssService.getDownloadUrl(jsonObject.getString("id"), jsonObject.getString("name"), true);
                    jsonObject.put("url", downloadUrl);
                }
                xpVehiclePreparationVO.setCabinCleaning(JSONArray.toJSONString(jsonArray));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return xpVehiclePreparationVO;
    }

    @Override
    public PageInfo<XpVehiclePreparationDetailVO> queryPreparationByVehicleId(XpVehiclePreparationPageQuery query) {
        // 1. 如果有操作人姓名过滤条件,先查询符合条件的用户ID列表
        List<Long> userIds = null;
        if (StringUtils.isNotBlank(query.getOperationsUserName())) {
            R<List<XpOperationsUser>> userResult = xpOperationUserClient.listByName(query.getOperationsUserName());
            List<XpOperationsUser> users = userResult.getData();

            // 如果没有匹配的用户,直接返回空结果
            if (CollectionUtils.isEmpty(users)) {
                return new PageInfo<>(query.getPageNum(), query.getPageSize());
            }

            // 提取用户ID列表
            userIds = users.stream()
                    .map(XpOperationsUser::getId)
                    .collect(Collectors.toList());
        }

        // 2. 使用 MyBatis-Plus Lambda 语法构建查询条件
        LambdaQueryWrapper<XpVehiclePreparation> wrapper = new LambdaQueryWrapper<>();

        // 必填条件: 车辆ID
        wrapper.eq(XpVehiclePreparation::getVehicleId, query.getVehicleId());

        // 可选条件: 操作人ID列表
        if (!CollectionUtils.isEmpty(userIds)) {
            wrapper.in(XpVehiclePreparation::getOperationsUserId, userIds);
        }

        // 可选条件: 开始时间
        if (query.getStartTime() != null) {
            wrapper.ge(XpVehiclePreparation::getCreateTime, query.getStartTime().atStartOfDay());
        }

        // 可选条件: 结束时间
        if (query.getEndTime() != null) {
            wrapper.le(XpVehiclePreparation::getCreateTime, query.getEndTime().atTime(23, 59, 59));
        }

        // 排序: 按创建时间倒序
        wrapper.orderByDesc(XpVehiclePreparation::getCreateTime);

        // 3. 执行分页查询
        Page<XpVehiclePreparation> page = new Page<>(query.getPageNum(), query.getPageSize());
        Page<XpVehiclePreparation> resultPage = this.page(page, wrapper);

        // 4. 转换为 VO 并填充操作人姓名
        List<XpVehiclePreparationDetailVO> records = new ArrayList<>();
        if (!CollectionUtils.isEmpty(resultPage.getRecords())) {
            // 提取所有操作人ID
            List<Long> allUserIds = resultPage.getRecords().stream()
                    .map(XpVehiclePreparation::getOperationsUserId)
                    .filter(Objects::nonNull)
                    .distinct()
                    .collect(Collectors.toList());

            // 批量查询操作人信息
            Map<Long, String> userNameMap = new HashMap<>();
            if (!CollectionUtils.isEmpty(allUserIds)) {
                R<List<XpOperationsUser>> userResult = xpOperationUserClient.listByIds(allUserIds);
                List<XpOperationsUser> users = userResult.getData();
                if (!CollectionUtils.isEmpty(users)) {
                    userNameMap = users.stream()
                            .collect(Collectors.toMap(XpOperationsUser::getId, XpOperationsUser::getNickName));
                }
            }

            // 转换并填充数据
            for (XpVehiclePreparation preparation : resultPage.getRecords()) {
                XpVehiclePreparationDetailVO vo = new XpVehiclePreparationDetailVO();
                BeanUtils.copyProperties(preparation, vo);
                vo.setOperationTime(preparation.getCreateTime());

                // 填充操作人姓名
                if (preparation.getOperationsUserId() != null) {
                    String userName = userNameMap.get(preparation.getOperationsUserId());
                    vo.setOperationsUserName(userName);
                }

                records.add(vo);
            }
        }

        // 5. 构建分页结果
        PageInfo<XpVehiclePreparationDetailVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        pageInfo.setRecords(records);
        pageInfo.setTotal(resultPage.getTotal());

        return pageInfo;
    }

}