package com.gyee.power.fitting.dispersionanalysis;

import java.io.FileWriter;
import java.io.IOException;
import java.util.*;

public class InverterPowerAnalysis {

    public static void main(String[] args) {
        List<InverterData> inverterDataList = generateInverterData();

        // 使用Map来存储每个逆变器的历史功率数据
        Map<String, List<Double>> historicalPowerData = new HashMap<>();

        for (InverterData inverterData : inverterDataList) {
            String inverterId = inverterData.getInverterId();
            double outputPower = inverterData.getOutputPower();

            // 更新历史功率数据
            historicalPowerData.computeIfAbsent(inverterId, k -> new ArrayList<>()).add(outputPower);

            // 更新历史数据并进行分析
            analyzeInverterPerformance(historicalPowerData, inverterId);
        }

        // 将数据存储到CSV文件
        saveDataToCSV(historicalPowerData, "historical_power_data.csv");
    }

    // 模拟生成逆变器数据
    private static List<InverterData> generateInverterData() {
        List<InverterData> data = new ArrayList<>();
        Random rand = new Random();
        for (int i = 1; i <= 10; i++) {
            String inverterId = "Inverter" + i;
            long timestamp = System.currentTimeMillis();
            double outputPower = rand.nextDouble() * 1000;
            double lightIntensity = rand.nextDouble() * 1000;
            data.add(new InverterData(inverterId, timestamp, outputPower, lightIntensity));
        }
        return data;
    }

    // 分析逆变器性能，包括计算离散率和平均功率
    private static void analyzeInverterPerformance(Map<String, List<Double>> historicalPowerData, String inverterId) {
        List<Double> powerData = historicalPowerData.get(inverterId);

        // 计算平均功率
        double averagePower = calculateAveragePower(powerData);

        // 计算功率离散率
        double powerDeviation = calculatePowerDeviation(powerData, averagePower);

        // 分析逆变器状态
        String inverterStatus = analyzeInverterStatus(powerDeviation, averagePower);
        System.out.println("逆变器ID: " + inverterId + "，离散率: " + powerDeviation + "，平均功率: " + averagePower + "，状态: " + inverterStatus);
    }

    // 计算功率离散率
    private static double calculatePowerDeviation(List<Double> powerData, double averagePower) {
        double sum = 0.0;

        // 计算标准差
        for (Double power : powerData) {
            sum += Math.pow(power - averagePower, 2);
        }
        return Math.sqrt(sum / powerData.size());
    }

    // 计算平均功率
    private static double calculateAveragePower(List<Double> powerData) {
        double sum = 0.0;
        for (Double power : powerData) {
            sum += power;
        }
        return sum / powerData.size();
    }

    // 根据复杂规则分析逆变器状态
    private static String analyzeInverterStatus(double powerDeviation, double averagePower) {
        if (powerDeviation < 0.1 && averagePower > 800) {
            return "运行稳定";
        } else if (powerDeviation < 0.2 && averagePower > 600) {
            return "运行良好";
        } else if (powerDeviation < 0.3 && averagePower > 400) {
            return "运行水平有待提高";
        } else {
            return "必须整改";
        }
    }

    // 将数据存储到CSV文件
    private static void saveDataToCSV(Map<String, List<Double>> historicalPowerData, String fileName) {
        try {
            FileWriter writer = new FileWriter(fileName);
            writer.append("InverterId,PowerData\n");
            for (Map.Entry<String, List<Double>> entry : historicalPowerData.entrySet()) {
                String inverterId = entry.getKey();
                List<Double> powerData = entry.getValue();
                StringBuilder powerDataStr = new StringBuilder();
                for (Double power : powerData) {
                    powerDataStr.append(power).append(",");
                }
                writer.append(inverterId).append(",").append(powerDataStr.toString()).append("\n");
            }
            writer.flush();
            writer.close();
            System.out.println("数据已保存到 " + fileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}