package dikuai;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * 地块信息类
 */
public class Dikuai {
    // 用户标识
    private String userId;
    // 地块编号
    private String landNumber;
    // 地块名称
    private String landName;
    // 边界原始坐标
    private String boundaryOriginalCoordinates;
    // 边界坐标（存储多边形坐标点集合）
    private String boundaryCoordinates;
    // 规划路径（存储路径坐标点集合）
    private String plannedPath;
    // 返回点坐标
    private String returnPointCoordinates;
    // 边界点间隔
    private String boundaryPointInterval;
    // 角度阈值
    private String angleThreshold;
    // 智能场景分析
    private String intelligentSceneAnalysis;
    // 地块面积，单位平方米
    private String landArea;
    // 基准站坐标
    private String baseStationCoordinates;
    // 创建时间
    private String createTime;
    // 最新更新时间
    private String updateTime;
    // 割草模式
    private String mowingTrack;
    // 割草实时轨迹
    private String mowingPattern;
    // 割草宽度
    private String mowingWidth;
    // 割草机割刀宽度（米），默认0.40米
    private String mowingBladeWidth;
    // 割草重叠距离（米），默认0.06米
    private String mowingOverlapDistance;

    // 存储多个地块的映射表，键为地块编号
    private static Map<String, Dikuai> dikuaiMap = new HashMap<>();

    /**
     * 初始化方法 - 从dikuai.properties文件加载所有地块数据
     */
    public static void initFromProperties() {
        Properties properties = new Properties();
        try {
            // 从根目录加载dikuai.properties文件，使用UTF-8编码
            FileInputStream input = new FileInputStream("dikuai.properties");
            InputStreamReader reader = new InputStreamReader(input, StandardCharsets.UTF_8);
            properties.load(reader);
            reader.close();
            input.close();
            
            // 清空现有地块数据
            dikuaiMap.clear();
            
            // 遍历所有属性，按地块编号分组
            Map<String, Properties> landProperties = new HashMap<>();
            
            for (String key : properties.stringPropertyNames()) {
                // 解析键名格式：landNumber.propertyName
                String[] parts = key.split("\\.", 2);
                if (parts.length == 2) {
                    String landNum = parts[0];
                    String propertyName = parts[1];
                    
                    if (!landProperties.containsKey(landNum)) {
                        landProperties.put(landNum, new Properties());
                    }
                    
                    landProperties.get(landNum).setProperty(propertyName, properties.getProperty(key));
                }
            }
            
            // 为每个地块创建Dikuai对象
            for (Map.Entry<String, Properties> entry : landProperties.entrySet()) {
                String landNum = entry.getKey();
                Properties landProps = entry.getValue();
                
                Dikuai dikuai = new Dikuai();
                dikuai.landNumber = landNum;
                dikuai.userId = landProps.getProperty("userId", "-1");
                dikuai.landName = landProps.getProperty("landName", "-1");
                dikuai.boundaryOriginalCoordinates = landProps.getProperty("boundaryOriginalCoordinates", "-1");
                dikuai.boundaryCoordinates = landProps.getProperty("boundaryCoordinates", "-1");
                dikuai.plannedPath = landProps.getProperty("plannedPath", "-1");
                dikuai.returnPointCoordinates = landProps.getProperty("returnPointCoordinates", "-1");
                dikuai.boundaryPointInterval = landProps.getProperty("boundaryPointInterval", "-1");
                dikuai.angleThreshold = landProps.getProperty("angleThreshold", "-1");
                dikuai.intelligentSceneAnalysis = landProps.getProperty("intelligentSceneAnalysis", "-1");
                dikuai.landArea = landProps.getProperty("landArea", "-1");
                dikuai.baseStationCoordinates = landProps.getProperty("baseStationCoordinates", "-1");
                dikuai.createTime = landProps.getProperty("createTime", "-1");
                dikuai.updateTime = landProps.getProperty("updateTime", "-1");
                dikuai.mowingPattern = landProps.getProperty("mowingPattern", "-1");
                dikuai.mowingWidth = landProps.getProperty("mowingWidth", "-1");
                dikuai.mowingTrack = landProps.getProperty("mowingTrack", "-1");
                dikuai.mowingBladeWidth = landProps.getProperty("mowingBladeWidth", "0.40");
                dikuai.mowingOverlapDistance = landProps.getProperty("mowingOverlapDistance", "0.06");
                
                dikuaiMap.put(landNum, dikuai);
            }
            
        } catch (IOException e) {
            // 如果文件不存在或读取失败，输出错误信息
            System.err.println("无法读取dikuai.properties文件: " + e.getMessage());
        }
    }

    /**
     * 根据地块编号获取地块对象
     * @param landNumber 地块编号
     * @return 地块对象，如果不存在则返回null
     */
    public static Dikuai getDikuai(String landNumber) {
        return dikuaiMap.get(landNumber);
    }

    /**
     * 获取所有地块
     * @return 所有地块的映射表
     */
    public static Map<String, Dikuai> getAllDikuai() {
        return new HashMap<>(dikuaiMap);
    }

    /**
     * 添加或更新地块
     * @param landNumber 地块编号
     * @param dikuai 地块对象
     */
    public static void putDikuai(String landNumber, Dikuai dikuai) {
        dikuaiMap.put(landNumber, dikuai);
    }

    /**
     * 删除指定地块
     * @param landNumber 地块编号
     * @return 是否删除成功
     */
    public static boolean removeDikuai(String landNumber) {
        return dikuaiMap.remove(landNumber) != null;
    }

    /**
     * 更新指定地块的字段值
     * @param landNumber 地块编号
     * @param fieldName 字段名
     * @param value 新值
     * @return 是否更新成功
     */
    public static boolean updateField(String landNumber, String fieldName, String value) {
        Dikuai dikuai = dikuaiMap.get(landNumber);
        if (dikuai == null) {
            System.err.println("未找到地块编号: " + landNumber);
            return false;
        }
        
        return dikuai.updateInstanceField(fieldName, value);
    }

    /**
     * 实例方法：更新当前地块对象的字段值
     * @param fieldName 字段名
     * @param value 新值
     * @return 是否更新成功
     */
    public boolean updateInstanceField(String fieldName, String value) {
        switch (fieldName) {
            case "userId":
                this.userId = value;
                return true;
            case "landNumber":
                this.landNumber = value;
                return true;
            case "landName":
                this.landName = value;
                return true;
            case "boundaryOriginalCoordinates":
                this.boundaryOriginalCoordinates = value;
                return true;
            case "boundaryCoordinates":
                this.boundaryCoordinates = value;
                return true;
            case "plannedPath":
                this.plannedPath = value;
                return true;
            case "returnPointCoordinates":
                this.returnPointCoordinates = value;
                return true;
            case "boundaryPointInterval":
                this.boundaryPointInterval = value;
                return true;
            case "angleThreshold":
                this.angleThreshold = value;
                return true;
            case "intelligentSceneAnalysis":
                this.intelligentSceneAnalysis = value;
                return true;
            case "landArea":
                this.landArea = value;
                return true;
            case "baseStationCoordinates":
                this.baseStationCoordinates = value;
                return true;
            case "createTime":
                this.createTime = value;
                return true;
            case "updateTime":
                this.updateTime = value;
                return true;
            case "mowingPattern":
                this.mowingPattern = value;
                return true;
            case "mowingWidth":
                this.mowingWidth = value;
                return true;
            case "mowingTrack":
                this.mowingTrack = value;
                return true;
            case "mowingBladeWidth":
                this.mowingBladeWidth = value;
                return true;
            case "mowingOverlapDistance":
                this.mowingOverlapDistance = value;
                return true;
            default:
                System.err.println("未知字段: " + fieldName);
                return false;
        }
    }

    /**
     * 保存所有地块数据到properties文件
     */
    public static void saveToProperties() {
        Properties properties = new Properties();
        
        // 将所有地块数据写入Properties对象
        for (Map.Entry<String, Dikuai> entry : dikuaiMap.entrySet()) {
            String landNumber = entry.getKey();
            Dikuai dikuai = entry.getValue();
            
            if (dikuai.userId != null) properties.setProperty(landNumber + ".userId", dikuai.userId);
            if (dikuai.landNumber != null) properties.setProperty(landNumber + ".landNumber", dikuai.landNumber);
            if (dikuai.landName != null) properties.setProperty(landNumber + ".landName", dikuai.landName);
            if (dikuai.boundaryOriginalCoordinates != null) properties.setProperty(landNumber + ".boundaryOriginalCoordinates", dikuai.boundaryOriginalCoordinates);
            if (dikuai.boundaryCoordinates != null) properties.setProperty(landNumber + ".boundaryCoordinates", dikuai.boundaryCoordinates);
            if (dikuai.plannedPath != null) properties.setProperty(landNumber + ".plannedPath", dikuai.plannedPath);
            if (dikuai.returnPointCoordinates != null) properties.setProperty(landNumber + ".returnPointCoordinates", dikuai.returnPointCoordinates);
            if (dikuai.boundaryPointInterval != null) properties.setProperty(landNumber + ".boundaryPointInterval", dikuai.boundaryPointInterval);
            if (dikuai.angleThreshold != null) properties.setProperty(landNumber + ".angleThreshold", dikuai.angleThreshold);
            if (dikuai.intelligentSceneAnalysis != null) properties.setProperty(landNumber + ".intelligentSceneAnalysis", dikuai.intelligentSceneAnalysis);
            if (dikuai.landArea != null) properties.setProperty(landNumber + ".landArea", dikuai.landArea);
            if (dikuai.baseStationCoordinates != null) properties.setProperty(landNumber + ".baseStationCoordinates", dikuai.baseStationCoordinates);
            if (dikuai.createTime != null) properties.setProperty(landNumber + ".createTime", dikuai.createTime);
            if (dikuai.updateTime != null) properties.setProperty(landNumber + ".updateTime", dikuai.updateTime);
            if (dikuai.mowingPattern != null) properties.setProperty(landNumber + ".mowingPattern", dikuai.mowingPattern);
            if (dikuai.mowingWidth != null) properties.setProperty(landNumber + ".mowingWidth", dikuai.mowingWidth);
            if (dikuai.mowingTrack != null) properties.setProperty(landNumber + ".mowingTrack", dikuai.mowingTrack);
            if (dikuai.mowingBladeWidth != null) properties.setProperty(landNumber + ".mowingBladeWidth", dikuai.mowingBladeWidth);
            if (dikuai.mowingOverlapDistance != null) properties.setProperty(landNumber + ".mowingOverlapDistance", dikuai.mowingOverlapDistance);
        }
        
        try {
            // 保存到文件，使用UTF-8编码
            FileOutputStream output = new FileOutputStream("dikuai.properties");
            OutputStreamWriter writer = new OutputStreamWriter(output, StandardCharsets.UTF_8);
            properties.store(writer, "Dikuai Properties");
            writer.close();
            output.close();
        } catch (IOException e) {
            System.err.println("无法保存dikuai.properties文件: " + e.getMessage());
        }
    }

    // Getter 和 Setter 方法
    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getLandNumber() {
        return landNumber;
    }

    public void setLandNumber(String landNumber) {
        this.landNumber = landNumber;
    }

    public String getLandName() {
        return landName;
    }

    public void setLandName(String landName) {
        this.landName = landName;
    }

    public String getBoundaryOriginalCoordinates() {
        return boundaryOriginalCoordinates;
    }

    public void setBoundaryOriginalCoordinates(String boundaryOriginalCoordinates) {
        this.boundaryOriginalCoordinates = boundaryOriginalCoordinates;
    }

    public String getBoundaryCoordinates() {
        return boundaryCoordinates;
    }

    public void setBoundaryCoordinates(String boundaryCoordinates) {
        this.boundaryCoordinates = boundaryCoordinates;
    }

    public String getPlannedPath() {
        return plannedPath;
    }

    public void setPlannedPath(String plannedPath) {
        this.plannedPath = plannedPath;
    }

    public String getReturnPointCoordinates() {
        return returnPointCoordinates;
    }

    public void setReturnPointCoordinates(String returnPointCoordinates) {
        this.returnPointCoordinates = returnPointCoordinates;
    }

    public String getBoundaryPointInterval() {
        return boundaryPointInterval;
    }

    public void setBoundaryPointInterval(String boundaryPointInterval) {
        this.boundaryPointInterval = boundaryPointInterval;
    }

    public String getAngleThreshold() {
        return angleThreshold;
    }

    public void setAngleThreshold(String angleThreshold) {
        this.angleThreshold = angleThreshold;
    }

    public String getIntelligentSceneAnalysis() {
        return intelligentSceneAnalysis;
    }

    public void setIntelligentSceneAnalysis(String intelligentSceneAnalysis) {
        this.intelligentSceneAnalysis = intelligentSceneAnalysis;
    }

    public String getLandArea() {
        return landArea;
    }

    public void setLandArea(String landArea) {
        this.landArea = landArea;
    }

    public String getBaseStationCoordinates() {
        return baseStationCoordinates;
    }

    public void setBaseStationCoordinates(String baseStationCoordinates) {
        this.baseStationCoordinates = baseStationCoordinates;
    }

    public String getCreateTime() {
        return createTime;
    }

    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }

    public String getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(String updateTime) {
        this.updateTime = updateTime;
    }

    public String getMowingPattern() {
        return mowingPattern;
    }

    public void setMowingPattern(String mowingPattern) {
        this.mowingPattern = mowingPattern;
    }

    public String getMowingWidth() {
        return mowingWidth;
    }

    public void setMowingWidth(String mowingWidth) {
        this.mowingWidth = mowingWidth;
    }

    public String getMowingTrack() {
        return mowingTrack;
    }

    public void setMowingTrack(String mowingTrack) {
        this.mowingTrack = mowingTrack;
    }

    public String getMowingBladeWidth() {
        return mowingBladeWidth;
    }

    public void setMowingBladeWidth(String mowingBladeWidth) {
        this.mowingBladeWidth = mowingBladeWidth;
    }

    public String getMowingOverlapDistance() {
        return mowingOverlapDistance;
    }

    public void setMowingOverlapDistance(String mowingOverlapDistance) {
        this.mowingOverlapDistance = mowingOverlapDistance;
    }

    @Override
    public String toString() {
        return "Dikuai{" +
                "userId='" + userId + '\'' +
                ", landNumber='" + landNumber + '\'' +
                ", landName='" + landName + '\'' +
                ", boundaryOriginalCoordinates='" + boundaryOriginalCoordinates + '\'' +
                ", boundaryCoordinates='" + boundaryCoordinates + '\'' +
                ", plannedPath='" + plannedPath + '\'' +
                ", returnPointCoordinates='" + returnPointCoordinates + '\'' +
                ", boundaryPointInterval='" + boundaryPointInterval + '\'' +
                ", angleThreshold='" + angleThreshold + '\'' +
                ", intelligentSceneAnalysis='" + intelligentSceneAnalysis + '\'' +
                ", landArea='" + landArea + '\'' +
                ", baseStationCoordinates='" + baseStationCoordinates + '\'' +
                ", createTime='" + createTime + '\'' +
                ", updateTime='" + updateTime + '\'' +
                ", mowingPattern='" + mowingPattern + '\'' +
                ", mowingWidth='" + mowingWidth + '\'' +
                '}';
    }
}