package com.ard.work.domain.dto.converter.wayline;

import com.ard.common.utils.bean.BeanUtils;
import com.ard.work.domain.dto.state.PointData;
import com.ard.work.domain.dto.wayline.HangarPoint;
import com.ard.work.domain.dto.wayline.NormalModel;
import com.ard.work.domain.dto.wayline.PlanLineData;
import com.ard.work.domain.dto.wayline.SurroundModel;
import com.ard.work.component.netty.protobuf.TelemetryDataPB;

import java.util.List;
import java.util.stream.Collectors;

public class PlanLineDataConverter {

    // 将 Protobuf 对象转换为实体对象
    public static PlanLineData convertProtoToEntity(TelemetryDataPB.PlanLineData proto) {
        PlanLineData planLineData = new PlanLineData();
        
        // 使用 BeanUtils 复制属性
        BeanUtils.copyProperties(proto, planLineData);
        
        // 处理 repeated fields
        if (proto.getPointsCount() > 0) {
            List<PointData> points = proto.getPointsList().stream()
                .map(PointDataConverter::convertProtoToEntity)
                .collect(Collectors.toList());
            planLineData.setPoints(points);
        }
        
        if (proto.getInterestsCount() > 0) {
            List<PointData> interests = proto.getInterestsList().stream()
                .map(PointDataConverter::convertProtoToEntity)
                .collect(Collectors.toList());
            planLineData.setInterests(interests);
        }
        
        // 处理 HangarPoint
        if (proto.hasTakePoint()) {
            HangarPoint takePoint = HangarPointConverter.convertProtoToEntity(proto.getTakePoint());
            planLineData.setTakePoint(takePoint);
        }
        
        if (proto.hasLandPoint()) {
            HangarPoint landPoint = HangarPointConverter.convertProtoToEntity(proto.getLandPoint());
            planLineData.setLandPoint(landPoint);
        }
        
        // 处理 NormalModel 和 SurroundModel
        if (proto.hasNormalModel()) {
            NormalModel normalModel = NormalModelConverter.convertProtoToEntity(proto.getNormalModel());
            planLineData.setNormalModel(normalModel);
        }
        
        if (proto.hasSurroundModel()) {
            SurroundModel surroundModel = SurroundModelConverter.convertProtoToEntity(proto.getSurroundModel());
            planLineData.setSurroundModel(surroundModel);
        }
        
        // 处理起飞点
        if (proto.hasTakeOffPoint()) {
            PointData takeOffPoint = PointDataConverter.convertProtoToEntity(proto.getTakeOffPoint());
            planLineData.setTakeOffPoint(takeOffPoint);
        }

        return planLineData;
    }

    // 将实体对象转换为 Protobuf 对象
    public static TelemetryDataPB.PlanLineData convertEntityToProto(PlanLineData planLineData) {
        // 创建 Protobuf 的构建器
        TelemetryDataPB.PlanLineData.Builder builder = TelemetryDataPB.PlanLineData.newBuilder();

        // 复制基本属性
        builder.setFinishedAction(planLineData.getFinishedAction());
        builder.setMaxSpeed(planLineData.getMaxSpeed());
        builder.setAutoSpeed(planLineData.getAutoSpeed());
        builder.setLoseAction(planLineData.getLoseAction());
        builder.setHomeHeight(planLineData.getHomeHeight());
        builder.setIsSaveEnergyMode(planLineData.getIsSaveEnergyMode());

        // 处理 repeated fields
        if (planLineData.getPoints() != null) {
            List<TelemetryDataPB.PointData> points = planLineData.getPoints().stream()
                .map(PointDataConverter::convertEntityToProto)
                .collect(Collectors.toList());
            builder.addAllPoints(points);
        }
        
        if (planLineData.getInterests() != null) {
            List<TelemetryDataPB.PointData> interests = planLineData.getInterests().stream()
                .map(PointDataConverter::convertEntityToProto)
                .collect(Collectors.toList());
            builder.addAllInterests(interests);
        }
        
        // 处理 HangarPoint
        if (planLineData.getTakePoint() != null) {
            TelemetryDataPB.HangarPoint takePoint = HangarPointConverter.convertEntityToProto(planLineData.getTakePoint());
            builder.setTakePoint(takePoint);
        }
        
        if (planLineData.getLandPoint() != null) {
            TelemetryDataPB.HangarPoint landPoint = HangarPointConverter.convertEntityToProto(planLineData.getLandPoint());
            builder.setLandPoint(landPoint);
        }
        
        // 处理 NormalModel 和 SurroundModel
        if (planLineData.getNormalModel() != null) {
            TelemetryDataPB.NormalModel normalModel = NormalModelConverter.convertEntityToProto(planLineData.getNormalModel());
            builder.setNormalModel(normalModel);
        }
        
        if (planLineData.getSurroundModel() != null) {
            TelemetryDataPB.SurroundModel surroundModel = SurroundModelConverter.convertEntityToProto(planLineData.getSurroundModel());
            builder.setSurroundModel(surroundModel);
        }
        
        // 处理起飞点
        if (planLineData.getTakeOffPoint() != null) {
            TelemetryDataPB.PointData takeOffPoint = PointDataConverter.convertEntityToProto(planLineData.getTakeOffPoint());
            builder.setTakeOffPoint(takeOffPoint);
        }

        // 构建并返回 Protobuf 对象
        return builder.build();
    }
}