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.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaopeng.api.dto.vehicleConvoy.UpdateVehicleStateDto;
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.XpChargingRecord;
import com.xiaopeng.api.model.maintenance.XpVehicleRepair;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.web.page.PageInfo;
import com.xiaopeng.evi.oss.service.AliOssService;
import com.xiaopeng.maintenance.dto.XpVehicleRepairReturnDTO;
import com.xiaopeng.maintenance.dto.XpVehicleRepairStartDTO;
import com.xiaopeng.maintenance.mapper.XpVehicleRepairMapper;
import com.xiaopeng.maintenance.model.query.XpVehicleRepairPageQuery;
import com.xiaopeng.maintenance.model.vo.XpVehicleRepairVO;
import com.xiaopeng.maintenance.service.IXpVehicleRepairService;
import com.xiaopeng.maintenance.vo.ChargingStatusVO;
import com.xiaopeng.maintenance.vo.RepairStatusVO;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.io.UnsupportedEncodingException;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * <p>
 * 车辆维修 服务实现类
 * </p>
 *
 * @author mitao
 * @since 2026-02-03
 */
@Service
public class XpVehicleRepairServiceImpl extends ServiceImpl<XpVehicleRepairMapper, XpVehicleRepair> implements IXpVehicleRepairService {
    @Autowired
    private XpVehicleClient xpVehicleClient;
    @Autowired
    private XpOperationUserClient xpOperationUserClient;

    @Autowired
    private AliOssService aliOssService;

    @Override
    public XpVehicleRepairVO repairDetail(Long id) {
        // 查询车辆充电记录
        XpVehicleRepair xpVehicleRepair = this.getById(id);
        XpVehicleRepairVO xpVehicleRepairVO = new XpVehicleRepairVO();
        BeanUtils.copyProperties(xpVehicleRepair, xpVehicleRepairVO);

        // 查询车辆信息
        XpVehicle xpVehicle = xpVehicleClient.queryById(xpVehicleRepair.getVehicleId()).getData();
        if (Objects.nonNull(xpVehicle)) {
            xpVehicleRepairVO.setPlateNumber(xpVehicle.getPlateNumber());
            xpVehicleRepairVO.setVehiclePictures(xpVehicle.getVehiclePictures());
            xpVehicleRepairVO.setAcceptOrTest(xpVehicle.getAcceptOrTest());
            xpVehicleRepairVO.setVehicleColor(xpVehicle.getVehicleColor());
        }
        // 查询操作人
        XpOperationsUser operationsUserStart = xpOperationUserClient.queryById(xpVehicleRepairVO.getSendUserId()).getData();
        if (Objects.nonNull(operationsUserStart)) {
            xpVehicleRepairVO.setOperatorStartName(operationsUserStart.getNickName());
        }
        XpOperationsUser operationsUserEnd = xpOperationUserClient.queryById(xpVehicleRepairVO.getReturnUserId()).getData();
        if (Objects.nonNull(operationsUserEnd)) {
            xpVehicleRepairVO.setOperatorEndName(operationsUserEnd.getNickName());
        }
        return xpVehicleRepairVO;
    }

    @Override
    public PageInfo<XpVehicleRepairVO> queryDetectionByVehicleId(XpVehicleRepairPageQuery query) {
        // 1. 如果有操作人姓名过滤条件,先查询符合条件的用户ID列表
        List<Long> userIds = null;
        if (StringUtils.isNotBlank(query.getSendUserName())) {
            R<List<XpOperationsUser>> userResult = xpOperationUserClient.listByName(query.getSendUserName());
            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<XpVehicleRepair> wrapper = new LambdaQueryWrapper<>();

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

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

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

        // 可选条件: 结束时间
        if (query.getEndTime() != null) {
            wrapper.le(XpVehicleRepair::getCreateTime, query.getEndTime().atTime(23, 59, 59));
        }
        // 可选条件: 维修原因
        if (query.getRepairReason() != null) {
            wrapper.like(XpVehicleRepair::getRepairReason, query.getRepairReason());
        }
        // 排序: 按创建时间倒序
        wrapper.orderByDesc(XpVehicleRepair::getCreateTime);

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

        // 4. 转换为 VO 并填充操作人姓名
        List<XpVehicleRepairVO> records = new ArrayList<>();
        if (!CollectionUtils.isEmpty(resultPage.getRecords())) {
            // 提取所有操作人ID
            List<Long> allUserIds = resultPage.getRecords().stream()
                    .flatMap(record -> Stream.of(
                            record.getSendUserId(),
                            record.getReturnUserId()
                    ))
                    .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 (XpVehicleRepair chargingRecord : resultPage.getRecords()) {
                XpVehicleRepairVO vo = new XpVehicleRepairVO();
                BeanUtils.copyProperties(chargingRecord, vo);
                vo.setOperationTime(chargingRecord.getCreateTime());

                // 填充操作人姓名
                if (chargingRecord.getSendUserId() != null) {
                    String userName = userNameMap.get(chargingRecord.getSendUserId());
                    vo.setOperatorStartName(userName);
                }
                if (chargingRecord.getReturnUserId() != null) {
                    String userName = userNameMap.get(chargingRecord.getReturnUserId());
                    vo.setOperatorEndName(userName);
                }




                String RepairMoneyDetail = vo.getRepairMoneyDetail();
                if (StringUtils.isNotBlank(RepairMoneyDetail)) {
                    JSONArray jsonArray = JSONArray.parseArray(RepairMoneyDetail);
                    for (int i = 0; i < jsonArray.size(); i++) {
                        JSONObject jsonObject = jsonArray.getJSONObject(i);
                        if (Objects.isNull(jsonObject)) {
                            continue;
                        }
                        String downloadUrl = jsonObject.getString("url");;
                        try {
                            downloadUrl = aliOssService.getDownloadUrl(jsonObject.getString("id"), jsonObject.getString("name"), true);
                        } catch (UnsupportedEncodingException e) {
                            log.error("获取图片下载地址失败", e);
                        }
                        jsonObject.put("url", downloadUrl);
                    }
                    vo.setRepairMoneyDetail(JSONArray.toJSONString(jsonArray));
                }





                String StartRepairPicture = vo.getStartRepairPicture();
                if (StringUtils.isNotBlank(StartRepairPicture)) {
                    JSONArray jsonArray = JSONArray.parseArray(StartRepairPicture);
                    for (int i = 0; i < jsonArray.size(); i++) {
                        JSONObject jsonObject = jsonArray.getJSONObject(i);
                        if (Objects.isNull(jsonObject)) {
                            continue;
                        }
                        String downloadUrl = jsonObject.getString("url");;
                        try {
                            downloadUrl = aliOssService.getDownloadUrl(jsonObject.getString("id"), jsonObject.getString("name"), true);
                        } catch (UnsupportedEncodingException e) {
                            log.error("获取图片下载地址失败", e);
                        }
                        jsonObject.put("url", downloadUrl);
                    }
                    vo.setStartRepairPicture(JSONArray.toJSONString(jsonArray));
                }




                records.add(vo);
            }
        }

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

        return pageInfo;
    }

    @Override
    public RepairStatusVO queryRepairStatus(Long vehicleId) {

        RepairStatusVO repairStatusVO = new RepairStatusVO();

        // 查询车辆当前维修信息
        XpVehicleRepair xpVehicleRepair = this.getOne(new LambdaQueryWrapper<XpVehicleRepair>()
                .eq(XpVehicleRepair::getVehicleId, vehicleId)
                .isNull(XpVehicleRepair::getReturnTime)
                .isNull(XpVehicleRepair::getTaskId)
                .orderByDesc(XpVehicleRepair::getCreateTime)
                .last("LIMIT 1"));

        if(Objects.nonNull(xpVehicleRepair)){
            repairStatusVO.setStatus(2);
            // 查询开始充电操作人名称
            XpOperationsUser operationsUser = xpOperationUserClient.queryById(xpVehicleRepair.getSendUserId()).getData();
            if(Objects.nonNull(operationsUser)){
                repairStatusVO.setSendUserName(operationsUser.getNickName());
            }
        }else{
            repairStatusVO.setStatus(1);
        }

        // 设置维修信息
        repairStatusVO.setXpVehicleRepair(xpVehicleRepair);

        return repairStatusVO;
    }

    @Override
    public void saveRepair(XpVehicleRepairStartDTO dto, Long id) {
        // 创建车辆维修记录
        XpVehicleRepair xpVehicleRepair = new XpVehicleRepair();
        xpVehicleRepair.setVehicleId(dto.getVehicleId());
        xpVehicleRepair.setStartTime(dto.getStartTime());
        xpVehicleRepair.setEndTime(dto.getEndTime());
        xpVehicleRepair.setRepairReason(dto.getRepairReason());
        xpVehicleRepair.setStartRepairPicture(dto.getStartRepairPicture());
        xpVehicleRepair.setSendUserId(id);
        xpVehicleRepair.setSendTime(LocalDateTime.now());
        this.save(xpVehicleRepair);
        // 查询车辆信息
        XpVehicle xpVehicle = xpVehicleClient.queryById(dto.getVehicleId()).getData();
        if(Objects.nonNull(xpVehicle)){
            // 修改车辆状态
            XpVehicle vehicle1 = new XpVehicle();
            vehicle1.setId(xpVehicle.getId());
            vehicle1.setOperatingStatus(2);
            xpVehicleClient.updateVehicleById(vehicle1);
        }
    }

    @Override
    public void saveReturnRepair(XpVehicleRepairReturnDTO dto, Long id) {
        XpVehicleRepair xpVehicleRepair = this.getById(dto.getId());
        // 查询车辆信息
        XpVehicle xpVehicle = xpVehicleClient.queryById(xpVehicleRepair.getVehicleId()).getData();
        if(Objects.nonNull(xpVehicle)){
            // 修改车辆状态
            XpVehicle vehicle1 = new XpVehicle();
            vehicle1.setId(xpVehicle.getId());
            vehicle1.setOperatingStatus(1);
            xpVehicleClient.updateVehicleById(vehicle1);
        }
        xpVehicleRepair.setVehicleId(null);
        // 修改车辆取回信息
        xpVehicleRepair.setRepairMoney(dto.getRepairMoney());
        xpVehicleRepair.setRepairMoneyDetail(dto.getRepairMoneyDetail());
        xpVehicleRepair.setReturnUserId(id);
        xpVehicleRepair.setReturnTime(LocalDateTime.now());
        this.updateById(xpVehicleRepair);
    }
}