package zhangaiwu;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

/**
 * 割草机地块障碍物类
 * 用于保存和管理地块障碍物的相关信息
 */
public class Obstacledge {
    
    /**
     * 障碍物形状枚举
     */
    public enum ObstacleShape {
        CIRCLE(0, "圆形"),
        POLYGON(1, "多边形");
        
        private final int code;
        private final String description;
        
        ObstacleShape(int code, String description) {
            this.code = code;
            this.description = description;
        }
        
        public int getCode() {
            return code;
        }
        
        public String getDescription() {
            return description;
        }
        
        /**
         * 根据代码获取形状枚举
         * @param code 形状代码
         * @return 对应的形状枚举，如果找不到返回null
         */
        public static ObstacleShape getByCode(int code) {
            for (ObstacleShape shape : values()) {
                if (shape.getCode() == code) {
                    return shape;
                }
            }
            return null;
        }
    }
    
    /**
     * 坐标点类 - 用于存储度分格式的坐标
     */
    public static class DMCoordinate {
        private double degreeMinute; // 度分值，如2324.200273
        private char direction;      // 方向，N/S/E/W
        
        public DMCoordinate() {
        }
        
        public DMCoordinate(double degreeMinute, char direction) {
            this.degreeMinute = degreeMinute;
            this.direction = direction;
        }
        
        public double getDegreeMinute() {
            return degreeMinute;
        }
        
        public void setDegreeMinute(double degreeMinute) {
            this.degreeMinute = degreeMinute;
        }
        
        public char getDirection() {
            return direction;
        }
        
        public void setDirection(char direction) {
            this.direction = direction;
        }
        
        /**
         * 将度分格式转换为度格式
         * @return 十进制度数
         */
        public double toDecimalDegree() {
            // 分离度和分
            double dm = Math.abs(degreeMinute);
            int degrees = (int)(dm / 100); // 度在百位以上
            double minutes = dm - degrees * 100;
            
            // 计算十进制度数
            double decimalDegrees = degrees + minutes / 60.0;
            
            // 根据方向确定正负
            if (direction == 'S' || direction == 'W') {
                decimalDegrees = -decimalDegrees;
            }
            
            return decimalDegrees;
        }
        
        /**
         * 将坐标点转换为字符串格式
         * @return 格式如 "2324.200273,N"
         */
        @Override
        public String toString() {
            return String.format("%.6f,%c", degreeMinute, direction);
        }
        
        /**
         * 从字符串解析坐标点
         * @param coordStr 格式如 "2324.200273,N"
         * @return DMCoordinate对象
         */
        public static DMCoordinate fromString(String coordStr) {
            String[] parts = coordStr.split(",");
            if (parts.length != 2) {
                throw new IllegalArgumentException("Invalid coordinate format: " + coordStr);
            }
            
            DMCoordinate coord = new DMCoordinate();
            coord.setDegreeMinute(Double.parseDouble(parts[0]));
            coord.setDirection(parts[1].charAt(0));
            
            return coord;
        }
    }
    
    /**
     * XY坐标点类 - 用于存储相对于基准站的平面坐标
     */
    public static class XYCoordinate {
        private double x; // X坐标（东方向）
        private double y; // Y坐标（北方向）
        
        public XYCoordinate() {
        }
        
        public XYCoordinate(double x, double y) {
            this.x = x;
            this.y = y;
        }
        
        public double getX() {
            return x;
        }
        
        public void setX(double x) {
            this.x = x;
        }
        
        public double getY() {
            return y;
        }
        
        public void setY(double y) {
            this.y = y;
        }
        
        @Override
        public String toString() {
            return String.format("%.2f,%.2f", x, y);
        }
        
        /**
         * 从字符串解析XY坐标点
         * @param xyStr 格式如 "5.2,3.8"
         * @return XYCoordinate对象
         */
        public static XYCoordinate fromString(String xyStr) {
            String[] parts = xyStr.split(",");
            if (parts.length != 2) {
                throw new IllegalArgumentException("Invalid XY coordinate format: " + xyStr);
            }
            
            XYCoordinate coord = new XYCoordinate();
            coord.setX(Double.parseDouble(parts[0]));
            coord.setY(Double.parseDouble(parts[1]));
            
            return coord;
        }
    }
    
    /**
     * 障碍物类
     */
    public static class Obstacle {
        private String plotId;           // 地块编号
        private String obstacleName;     // 障碍物名称（唯一）
        private ObstacleShape shape;     // 障碍物形状
        private List<DMCoordinate> originalCoordinates = new ArrayList<>(); // 原始坐标列表
        private List<XYCoordinate> xyCoordinates = new ArrayList<>();      // XY坐标列表
        
        public Obstacle() {
        }
        
        public Obstacle(String plotId, String obstacleName, ObstacleShape shape) {
            this.plotId = plotId;
            this.obstacleName = obstacleName;
            this.shape = shape;
        }
        
        // Getter和Setter方法
        
        public String getPlotId() {
            return plotId;
        }
        
        public void setPlotId(String plotId) {
            this.plotId = plotId;
        }
        
        public String getObstacleName() {
            return obstacleName;
        }
        
        public void setObstacleName(String obstacleName) {
            this.obstacleName = obstacleName;
        }
        
        public ObstacleShape getShape() {
            return shape;
        }
        
        public void setShape(ObstacleShape shape) {
            this.shape = shape;
        }
        
        /**
         * 设置形状（通过代码）
         * @param shapeCode 形状代码（0=圆形，1=多边形）
         */
        public void setShapeByCode(int shapeCode) {
            this.shape = ObstacleShape.getByCode(shapeCode);
        }
        
        public List<DMCoordinate> getOriginalCoordinates() {
            return originalCoordinates;
        }
        
        public void setOriginalCoordinates(List<DMCoordinate> originalCoordinates) {
            this.originalCoordinates = originalCoordinates;
        }
        
        /**
         * 添加原始坐标点
         * @param coordinate 度分格式坐标点
         */
        public void addOriginalCoordinate(DMCoordinate coordinate) {
            this.originalCoordinates.add(coordinate);
        }
        
        /**
         * 添加原始坐标点
         * @param degreeMinute 度分值
         * @param direction 方向
         */
        public void addOriginalCoordinate(double degreeMinute, char direction) {
            this.originalCoordinates.add(new DMCoordinate(degreeMinute, direction));
        }
        
        public List<XYCoordinate> getXyCoordinates() {
            return xyCoordinates;
        }
        
        public void setXyCoordinates(List<XYCoordinate> xyCoordinates) {
            this.xyCoordinates = xyCoordinates;
        }
        
        /**
         * 添加XY坐标点
         * @param coordinate XY坐标点
         */
        public void addXyCoordinate(XYCoordinate coordinate) {
            this.xyCoordinates.add(coordinate);
        }
        
        /**
         * 添加XY坐标点
         * @param x X坐标
         * @param y Y坐标
         */
        public void addXyCoordinate(double x, double y) {
            this.xyCoordinates.add(new XYCoordinate(x, y));
        }
        
        /**
         * 获取原始坐标字符串
         * @return 格式如 "2324.200273,N,11330.666730,E;2324.200400,N,11330.666850,E"
         */
        public String getOriginalCoordsString() {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < originalCoordinates.size(); i++) {
                if (i > 0) {
                    sb.append(";");
                }
                sb.append(originalCoordinates.get(i).toString());
            }
            return sb.toString();
        }
        
        /**
         * 设置原始坐标字符串
         * @param coordsStr 格式如 "2324.200273,N,11330.666730,E;2324.200400,N,11330.666850,E"
         */
        public void setOriginalCoordsString(String coordsStr) {
            originalCoordinates.clear();
            String[] points = coordsStr.split(";");
            for (String point : points) {
                // 每个点可能是两个DMCoordinate的组合（纬度+经度）
                String[] coords = point.split(",");
                if (coords.length == 4) {
                    // 格式：纬度度分,纬度方向,经度度分,经度方向
                    double latDM = Double.parseDouble(coords[0]);
                    char latDir = coords[1].charAt(0);
                    double lonDM = Double.parseDouble(coords[2]);
                    char lonDir = coords[3].charAt(0);
                    
                    // 注意：实际存储时需要分别存储纬度和经度坐标点
                    // 这里简化处理，存储为两个DMCoordinate对象
                    addOriginalCoordinate(latDM, latDir);
                    addOriginalCoordinate(lonDM, lonDir);
                } else if (coords.length == 2) {
                    // 格式：度分,方向
                    originalCoordinates.add(DMCoordinate.fromString(point));
                }
            }
        }
        
        /**
         * 获取XY坐标字符串
         * @return 格式如 "5.2,3.8;7.5,6.2"
         */
        public String getXyCoordsString() {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < xyCoordinates.size(); i++) {
                if (i > 0) {
                    sb.append(";");
                }
                sb.append(xyCoordinates.get(i).toString());
            }
            return sb.toString();
        }
        
        /**
         * 设置XY坐标字符串
         * @param xyCoordsStr 格式如 "5.2,3.8;7.5,6.2"
         */
        public void setXyCoordsString(String xyCoordsStr) {
            xyCoordinates.clear();
            String[] points = xyCoordsStr.split(";");
            for (String point : points) {
                xyCoordinates.add(XYCoordinate.fromString(point));
            }
        }
        
        /**
         * 验证障碍物数据的有效性
         * @return 是否有效
         */
        public boolean isValid() {
            if (plotId == null || plotId.isEmpty()) {
                return false;
            }
            
            if (obstacleName == null || obstacleName.isEmpty()) {
                return false;
            }
            
            if (shape == null) {
                return false;
            }
            
            // 根据形状验证坐标点数量
            if (shape == ObstacleShape.CIRCLE) {
                // 圆形需要至少2个坐标点（圆心和圆上一点）
                return originalCoordinates.size() >= 2 && xyCoordinates.size() >= 2;
            } else if (shape == ObstacleShape.POLYGON) {
                // 多边形需要至少3个坐标点
                return originalCoordinates.size() >= 6 && xyCoordinates.size() >= 3; // 原始坐标每个点有纬度和经度，所以是2倍
            }
            
            return false;
        }
        
        /**
         * 计算圆形障碍物的半径（如果形状是圆形）
         * @return 半径（米），如果不是圆形返回-1
         */
        public double calculateRadius() {
            if (shape != ObstacleShape.CIRCLE || xyCoordinates.size() < 2) {
                return -1;
            }
            
            XYCoordinate center = xyCoordinates.get(0);
            XYCoordinate pointOnCircle = xyCoordinates.get(1);
            
            double dx = pointOnCircle.getX() - center.getX();
            double dy = pointOnCircle.getY() - center.getY();
            
            return Math.sqrt(dx * dx + dy * dy);
        }
        
        /**
         * 计算多边形障碍物的面积（如果形状是多边形）
         * @return 面积（平方米），如果不是多边形返回-1
         */
        public double calculateArea() {
            if (shape != ObstacleShape.POLYGON || xyCoordinates.size() < 3) {
                return -1;
            }
            
            double area = 0;
            int n = xyCoordinates.size();
            
            for (int i = 0; i < n; i++) {
                XYCoordinate current = xyCoordinates.get(i);
                XYCoordinate next = xyCoordinates.get((i + 1) % n);
                
                area += current.getX() * next.getY();
                area -= current.getY() * next.getX();
            }
            
            return Math.abs(area) / 2.0;
        }
        
        @Override
        public String toString() {
            return String.format("Obstacle{plotId='%s', name='%s', shape=%s, points=%d}",
                    plotId, obstacleName, shape.getDescription(), originalCoordinates.size() / 2);
        }
    }
    
    /**
     * 地块类
     */
    public static class Plot {
        private String plotId;                    // 地块编号（唯一）
        private DMCoordinate baseStationLat;      // 基准站纬度
        private DMCoordinate baseStationLon;      // 基准站经度
        private List<Obstacle> obstacles = new ArrayList<>(); // 地块内的障碍物列表
        
        public Plot() {
        }
        
        public Plot(String plotId) {
            this.plotId = plotId;
        }
        
        // Getter和Setter方法
        
        public String getPlotId() {
            return plotId;
        }
        
        public void setPlotId(String plotId) {
            this.plotId = plotId;
        }
        
        public DMCoordinate getBaseStationLat() {
            return baseStationLat;
        }
        
        public void setBaseStationLat(DMCoordinate baseStationLat) {
            this.baseStationLat = baseStationLat;
        }
        
        public DMCoordinate getBaseStationLon() {
            return baseStationLon;
        }
        
        public void setBaseStationLon(DMCoordinate baseStationLon) {
            this.baseStationLon = baseStationLon;
        }
        
        /**
         * 设置基准站坐标
         * @param lat 纬度度分坐标
         * @param lon 经度度分坐标
         */
        public void setBaseStation(DMCoordinate lat, DMCoordinate lon) {
            this.baseStationLat = lat;
            this.baseStationLon = lon;
        }

        /**
         * 清除基准站坐标
         */
        public void clearBaseStation() {
            this.baseStationLat = null;
            this.baseStationLon = null;
        }
        
        /**
         * 设置基准站坐标字符串
         * @param baseStationStr 格式如 "2324.200273,N,11330.666730,E"
         */
        public void setBaseStationString(String baseStationStr) {
            String[] parts = baseStationStr.split(",");
            if (parts.length != 4) {
                throw new IllegalArgumentException("Invalid base station format: " + baseStationStr);
            }
            
            double latDM = Double.parseDouble(parts[0]);
            char latDir = parts[1].charAt(0);
            double lonDM = Double.parseDouble(parts[2]);
            char lonDir = parts[3].charAt(0);
            
            this.baseStationLat = new DMCoordinate(latDM, latDir);
            this.baseStationLon = new DMCoordinate(lonDM, lonDir);
        }
        
        /**
         * 获取基准站坐标字符串
         * @return 格式如 "2324.200273,N,11330.666730,E"
         */
        public String getBaseStationString() {
            if (baseStationLat == null || baseStationLon == null) {
                return "";
            }
            return String.format("%s,%s", baseStationLat.toString(), baseStationLon.toString());
        }
        
        public List<Obstacle> getObstacles() {
            return obstacles;
        }
        
        public void setObstacles(List<Obstacle> obstacles) {
            this.obstacles = obstacles;
        }
        
        /**
         * 添加障碍物
         * @param obstacle 障碍物对象
         */
        public void addObstacle(Obstacle obstacle) {
            this.obstacles.add(obstacle);
        }
        
        /**
         * 根据障碍物名称获取障碍物
         * @param obstacleName 障碍物名称
         * @return 障碍物对象，如果找不到返回null
         */
        public Obstacle getObstacleByName(String obstacleName) {
            for (Obstacle obstacle : obstacles) {
                if (obstacle.getObstacleName().equals(obstacleName)) {
                    return obstacle;
                }
            }
            return null;
        }
        
        /**
         * 根据障碍物名称移除障碍物
         * @param obstacleName 障碍物名称
         * @return 是否成功移除
         */
        public boolean removeObstacleByName(String obstacleName) {
            return obstacles.removeIf(obstacle -> obstacle.getObstacleName().equals(obstacleName));
        }
        
        /**
         * 验证地块数据的有效性
         * @return 是否有效
         */
        public boolean isValid() {
            if (plotId == null || plotId.isEmpty()) {
                return false;
            }
            
            if (baseStationLat == null || baseStationLon == null) {
                return false;
            }
            
            // 验证所有障碍物
            for (Obstacle obstacle : obstacles) {
                if (!obstacle.isValid()) {
                    return false;
                }
            }
            
            return true;
        }
        
        /**
         * 获取地块中障碍物的数量
         * @return 障碍物数量
         */
        public int getObstacleCount() {
            return obstacles.size();
        }
        
        @Override
        public String toString() {
            return String.format("Plot{id='%s', baseStation=%s, obstacles=%d}",
                    plotId, getBaseStationString(), obstacles.size());
        }
    }
    
    /**
     * 配置文件管理器类
     */
    public static class ConfigManager {
        private List<Plot> plots = new ArrayList<>();
        
        public ConfigManager() {
        }
        
        // Getter和Setter方法
        
        public List<Plot> getPlots() {
            return plots;
        }
        
        public void setPlots(List<Plot> plots) {
            this.plots = plots;
        }
        
        /**
         * 添加地块
         * @param plot 地块对象
         */
        public void addPlot(Plot plot) {
            this.plots.add(plot);
        }
        
        /**
         * 根据地块编号获取地块
         * @param plotId 地块编号
         * @return 地块对象，如果找不到返回null
         */
        public Plot getPlotById(String plotId) {
            for (Plot plot : plots) {
                if (plot.getPlotId().equals(plotId)) {
                    return plot;
                }
            }
            return null;
        }
        
        /**
         * 根据地块编号移除地块
         * @param plotId 地块编号
         * @return 是否成功移除
         */
        public boolean removePlotById(String plotId) {
            return plots.removeIf(plot -> plot.getPlotId().equals(plotId));
        }
        
        /**
         * 获取所有地块中的障碍物总数
         * @return 障碍物总数
         */
        public int getTotalObstacleCount() {
            int count = 0;
            for (Plot plot : plots) {
                count += plot.getObstacleCount();
            }
            return count;
        }
        
        /**
         * 验证所有地块数据的有效性
         * @return 是否所有数据都有效
         */
        public boolean validateAll() {
            for (Plot plot : plots) {
                if (!plot.isValid()) {
                    return false;
                }
            }
            return true;
        }
        
        /**
         * 转换为properties文件格式字符串
         * @return properties格式字符串
         */
        public String toPropertiesString() {
            StringBuilder sb = new StringBuilder();
            sb.append("# 割草机地块障碍物配置文件\n");
            sb.append("# 生成时间：").append(java.time.LocalDateTime.now()).append("\n");
            sb.append("# 坐标系：WGS84（度分格式）\n\n");
            
            sb.append("# ============ 地块基准站配置 ============\n");
            sb.append("# 格式：plot.[地块编号].baseStation=[经度],[N/S],[纬度],[E/W]\n");
            
            // 添加基准站配置
            for (Plot plot : plots) {
                sb.append("plot.").append(plot.getPlotId())
                  .append(".baseStation=").append(plot.getBaseStationString())
                  .append("\n");
            }
            
            sb.append("\n# ============ 障碍物配置 ============\n");
            sb.append("# 格式：plot.[地块编号].obstacle.[障碍物名称].shape=[0|1]\n");
            sb.append("# 格式：plot.[地块编号].obstacle.[障碍物名称].originalCoords=[坐标串]\n");
            sb.append("# 格式：plot.[地块编号].obstacle.[障碍物名称].xyCoords=[坐标串]\n\n");
            
            // 添加障碍物配置
            for (Plot plot : plots) {
                if (plot.getObstacleCount() > 0) {
                    sb.append("# --- 地块").append(plot.getPlotId()).append("的障碍物 ---\n");
                    
                    for (Obstacle obstacle : plot.getObstacles()) {
                        sb.append("plot.").append(plot.getPlotId())
                          .append(".obstacle.").append(obstacle.getObstacleName())
                          .append(".shape=").append(obstacle.getShape().getCode())
                          .append("\n");
                        
                        sb.append("plot.").append(plot.getPlotId())
                          .append(".obstacle.").append(obstacle.getObstacleName())
                          .append(".originalCoords=").append(obstacle.getOriginalCoordsString())
                          .append("\n");
                        
                        sb.append("plot.").append(plot.getPlotId())
                          .append(".obstacle.").append(obstacle.getObstacleName())
                          .append(".xyCoords=").append(obstacle.getXyCoordsString())
                          .append("\n");
                    }
                    sb.append("\n");
                }
            }
            
            return sb.toString();
        }
        
        /**
         * 保存配置到文件
         * @param filePath 文件路径
         * @return 是否保存成功
         */
        public boolean saveToFile(String filePath) {
            try {
                String propertiesContent = toPropertiesString();
                java.nio.file.Files.write(
                    java.nio.file.Paths.get(filePath),
                    propertiesContent.getBytes(java.nio.charset.StandardCharsets.UTF_8)
                );
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        
        /**
         * 从properties文件加载配置
         * @param filePath 文件路径
         * @return 是否加载成功
         */
        public boolean loadFromFile(String filePath) {
            try {
                List<String> lines = java.nio.file.Files.readAllLines(
                    java.nio.file.Paths.get(filePath),
                    java.nio.charset.StandardCharsets.UTF_8
                );
                
                plots.clear();
                Plot currentPlot = null;
                Obstacle currentObstacle = null;
                
                for (String line : lines) {
                    line = line.trim();
                    
                    // 跳过空行和注释
                    if (line.isEmpty() || line.startsWith("#")) {
                        continue;
                    }
                    
                    // 解析键值对
                    if (line.contains("=")) {
                        String[] parts = line.split("=", 2);
                        String key = parts[0].trim();
                        String value = parts[1].trim();
                        
                        // 解析键的结构
                        String[] keyParts = key.split("\\.");
                        if (keyParts.length >= 3) {
                            String plotId = keyParts[1];
                            
                            // 查找或创建地块
                            if (currentPlot == null || !currentPlot.getPlotId().equals(plotId)) {
                                currentPlot = getPlotById(plotId);
                                if (currentPlot == null) {
                                    currentPlot = new Plot(plotId);
                                    addPlot(currentPlot);
                                }
                            }
                            
                            if ("baseStation".equals(keyParts[2])) {
                                // 基准站坐标
                                currentPlot.setBaseStationString(value);
                            } else if ("obstacle".equals(keyParts[2]) && keyParts.length >= 5) {
                                String obstacleName = keyParts[3];
                                String property = keyParts[4];
                                
                                // 查找或创建障碍物
                                if (currentObstacle == null || !currentObstacle.getObstacleName().equals(obstacleName)) {
                                    currentObstacle = currentPlot.getObstacleByName(obstacleName);
                                    if (currentObstacle == null) {
                                        currentObstacle = new Obstacle();
                                        currentObstacle.setPlotId(plotId);
                                        currentObstacle.setObstacleName(obstacleName);
                                        currentPlot.addObstacle(currentObstacle);
                                    }
                                }
                                
                                // 设置障碍物属性
                                switch (property) {
                                    case "shape":
                                        currentObstacle.setShapeByCode(Integer.parseInt(value));
                                        break;
                                    case "originalCoords":
                                        currentObstacle.setOriginalCoordsString(value);
                                        break;
                                    case "xyCoords":
                                        currentObstacle.setXyCoordsString(value);
                                        break;
                                }
                            }
                        }
                    }
                }
                
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    }    
   
    /**
     * 将路径规划使用的障碍物坐标字符串解析为障碍物列表。
     * @param payload 障碍物坐标字符串
     * @param landNumber 地块编号
     * @return 解析得到的障碍物列表
     */
    public static List<Obstacle> parsePlannerPayload(String payload, String landNumber) {
        return ObstaclePayloadConverter.parse(payload, landNumber);
    }

    /**
     * 将障碍物列表转换为路径规划使用的坐标字符串。
     * @param obstacles 障碍物列表
     * @return 坐标字符串，若列表为空返回null
     */
    public static String buildPlannerPayload(List<Obstacle> obstacles) {
        return ObstaclePayloadConverter.build(obstacles);
    }

    /**
     * 障碍物坐标字符串与数据对象之间的转换工具。
     */
    private static final class ObstaclePayloadConverter {
        private ObstaclePayloadConverter() {
        }

        private static List<Obstacle> parse(String payload, String landNumber) {
            List<Obstacle> obstacles = new ArrayList<>();
            if (payload == null) {
                return obstacles;
            }

            String normalizedPayload = stripInlineComment(payload.trim());
            if (normalizedPayload.isEmpty() || "-1".equals(normalizedPayload)) {
                return obstacles;
            }

            String normalizedLand = landNumber != null ? landNumber.trim() : null;
            List<String> entries = splitEntries(normalizedPayload);
            int defaultIndex = 1;

            for (String entry : entries) {
                String trimmedEntry = stripInlineComment(entry);
                if (trimmedEntry.isEmpty()) {
                    continue;
                }

                String nameToken = null;
                String shapeToken = null;
                String coordsSection = trimmedEntry;

                if (trimmedEntry.contains("::")) {
                    String[] parts = trimmedEntry.split("::", 3);
                    if (parts.length == 3) {
                        nameToken = parts[0].trim();
                        shapeToken = parts[1].trim();
                        coordsSection = parts[2].trim();
                    }
                } else if (trimmedEntry.contains("@")) {
                    String[] parts = trimmedEntry.split("@", 3);
                    if (parts.length == 3) {
                        nameToken = parts[0].trim();
                        shapeToken = parts[1].trim();
                        coordsSection = parts[2].trim();
                    } else if (parts.length == 2) {
                        shapeToken = parts[0].trim();
                        coordsSection = parts[1].trim();
                    }
                } else if (trimmedEntry.contains(":")) {
                    String[] parts = trimmedEntry.split(":", 3);
                    if (parts.length == 3) {
                        nameToken = parts[0].trim();
                        shapeToken = parts[1].trim();
                        coordsSection = parts[2].trim();
                    } else if (parts.length == 2) {
                        if (looksLikeShapeToken(parts[0])) {
                            shapeToken = parts[0].trim();
                            coordsSection = parts[1].trim();
                        } else {
                            nameToken = parts[0].trim();
                            coordsSection = parts[1].trim();
                        }
                    }
                }

                List<XYCoordinate> xyCoordinates = parseCoordinates(coordsSection);
                if (xyCoordinates.size() < 2) {
                    continue;
                }

                ObstacleShape shape = resolveShape(shapeToken, xyCoordinates.size());
                if (shape == null) {
                    continue;
                }

                String obstacleName;
                if (nameToken != null && !nameToken.isEmpty()) {
                    obstacleName = nameToken;
                } else {
                    obstacleName = "障碍物" + defaultIndex++;
                }

                Obstacle obstacle = new Obstacle(normalizedLand, obstacleName, shape);
                obstacle.setPlotId(normalizedLand);
                obstacle.setObstacleName(obstacleName);
                obstacle.setShape(shape);
                obstacle.setXyCoordinates(new ArrayList<>(xyCoordinates));
                populatePlaceholderOriginalCoords(obstacle, xyCoordinates.size());

                if (obstacle.isValid()) {
                    obstacles.add(obstacle);
                }
            }

            return obstacles;
        }

        private static String build(List<Obstacle> obstacles) {
            if (obstacles == null || obstacles.isEmpty()) {
                return null;
            }
            StringBuilder builder = new StringBuilder();
            for (Obstacle obstacle : obstacles) {
                if (obstacle == null) {
                    continue;
                }
                List<XYCoordinate> coords = obstacle.getXyCoordinates();
                if (coords == null || coords.isEmpty()) {
                    continue;
                }
                if (builder.length() > 0) {
                    builder.append(' ');
                }
                builder.append('(');
                for (int i = 0; i < coords.size(); i++) {
                    XYCoordinate coord = coords.get(i);
                    if (coord == null) {
                        continue;
                    }
                    if (i > 0) {
                        builder.append(';');
                    }
                    builder.append(formatDouble(coord.getX())).append(',').append(formatDouble(coord.getY()));
                }
                builder.append(')');
            }
            return builder.length() == 0 ? null : builder.toString();
        }

        private static boolean looksLikeShapeToken(String token) {
            if (token == null) {
                return false;
            }
            String normalized = token.trim().toLowerCase(Locale.ROOT);
            return "circle".equals(normalized)
                || "polygon".equals(normalized)
                || "圆形".equals(normalized)
                || "多边形".equals(normalized)
                || "0".equals(normalized)
                || "1".equals(normalized);
        }

        private static List<XYCoordinate> parseCoordinates(String coordsSection) {
            List<XYCoordinate> coords = new ArrayList<>();
            if (coordsSection == null) {
                return coords;
            }

            String sanitized = stripInlineComment(coordsSection.trim());
            if (sanitized.isEmpty() || "-1".equals(sanitized)) {
                return coords;
            }

            // Remove wrapper characters like parentheses that surround persisted payloads
            sanitized = sanitized.replace("(", "").replace(")", "");

            String[] pairs = sanitized.split(";");
            for (String pair : pairs) {
                if (pair == null) {
                    continue;
                }
                String trimmed = stripInlineComment(pair.trim());
                if (trimmed.isEmpty()) {
                    continue;
                }
                trimmed = trimmed.replace("(", "").replace(")", "");
                if (trimmed.isEmpty()) {
                    continue;
                }
                String[] parts = trimmed.split(",");
                if (parts.length < 2) {
                    continue;
                }
                try {
                    double x = Double.parseDouble(parts[0].trim());
                    double y = Double.parseDouble(parts[1].trim());
                    coords.add(new XYCoordinate(x, y));
                } catch (NumberFormatException ignored) {
                    // 忽略格式错误的坐标点
                }
            }

            return coords;
        }

        private static ObstacleShape resolveShape(String shapeToken, int coordinateCount) {
            if (shapeToken != null && !shapeToken.trim().isEmpty()) {
                String normalized = shapeToken.trim().toLowerCase(Locale.ROOT);
                if ("circle".equals(normalized) || "圆形".equals(normalized) || "0".equals(normalized)) {
                    return ObstacleShape.CIRCLE;
                }
                if ("polygon".equals(normalized) || "多边形".equals(normalized) || "1".equals(normalized)) {
                    return ObstacleShape.POLYGON;
                }
            }

            if (coordinateCount == 2) {
                return ObstacleShape.CIRCLE;
            }
            if (coordinateCount >= 3) {
                return ObstacleShape.POLYGON;
            }
            return null;
        }

        private static void populatePlaceholderOriginalCoords(Obstacle obstacle, int xyCount) {
            List<DMCoordinate> dmCoordinates = new ArrayList<>();
            int points = Math.max(1, xyCount);
            for (int i = 0; i < points; i++) {
                dmCoordinates.add(new DMCoordinate(0.0, 'N'));
                dmCoordinates.add(new DMCoordinate(0.0, 'E'));
            }
            obstacle.setOriginalCoordinates(dmCoordinates);
        }

        private static String stripInlineComment(String text) {
            if (text == null) {
                return "";
            }
            int hashIndex = text.indexOf('#');
            if (hashIndex >= 0) {
                return text.substring(0, hashIndex).trim();
            }
            return text.trim();
        }

        private static List<String> splitEntries(String data) {
            List<String> entries = new ArrayList<>();
            if (data.indexOf('|') >= 0) {
                String[] parts = data.split("\\|");
                for (String part : parts) {
                    if (part != null && !part.trim().isEmpty()) {
                        entries.add(part.trim());
                    }
                }
            } else if (data.contains("\n")) {
                String[] lines = data.split("\r?\n");
                for (String line : lines) {
                    if (line != null && !line.trim().isEmpty()) {
                        entries.add(line.trim());
                    }
                }
            } else {
                entries.add(data);
            }
            return entries;
        }

        private static String formatDouble(double value) {
            return String.format(Locale.ROOT, "%.2f", value);
        }
    }
}