package com.gyee.power.fitting.dispersionanalysis;

import com.alibaba.fastjson.JSONObject;
import com.gyee.power.fitting.common.alg.PolynomialCurveFitting;
import com.gyee.power.fitting.common.result.JsonResult;
import com.gyee.power.fitting.common.result.ResultCode;
import com.gyee.power.fitting.model.custom.PhotovoltaicInfo;
import com.gyee.power.fitting.service.impl.IvPvCurveFittingService;
import org.apache.commons.math3.fitting.WeightedObservedPoints;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.stream.Collectors;

//逆变器单位装机输出功率离散率分析
@CrossOrigin
@RequestMapping("/discreteness")
@RestController
public class InverterPowerAnalysis2 {

    @Resource
    private IvPvCurveFittingService curveFittingService;
    @Resource
    private PolynomialCurveFitting pncf;

    // 模拟生成逆变器数据
    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 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();
        }
    }

    @GetMapping("/rate")
    private JSONObject getFileList(
            @RequestParam(value = "station", required = true) String station,
            @RequestParam(value = "inverters", required = false) List<String> inverters,
            @RequestParam(value = "startdate", required = true) long startdate,
            @RequestParam(value = "interval", required = false) Integer interval,
            @RequestParam(value = "enddate", required = true) long enddate) {

        Map<String, List<PhotovoltaicInfo>> datasInfos = curveFittingService.getDatas2File1(station, startdate, enddate, interval);

        /*List<PhotovoltaicInfo> infos = new ArrayList<>();
        //单台拟合
        if (inverters.size() == 1) {
            infos = datasInfos.get(inverters.get(0));
        //多台拟合
        } else if (inverters.size() > 1) {
            infos = inverters.stream().flatMap(inverter -> datasInfos.get(inverter).stream()).collect(Collectors.toList());
        //全场拟合
        } else {
            infos = datasInfos.values().stream().flatMap(List::stream).collect(Collectors.toList());
        }*/

        List<InverterData2> inverterData2s = new ArrayList<>();
        datasInfos.forEach((k, v) -> {

            WeightedObservedPoints points = new WeightedObservedPoints();
            for (PhotovoltaicInfo info : v) {
                if (info.getS() < 1) {
                    points.add(0, 0);
                }
                points.add(info.getS(), info.getActualP());
            }

            double[] run = pncf.run(points);

            inverterData2s.add(analyzeInverterPerformance(v, run, k));
        });

        return JsonResult.successData(ResultCode.SUCCESS, inverterData2s);
    }

    // 分析逆变器性能，包括计算离散率和平均功率
    private InverterData2 analyzeInverterPerformance(List<PhotovoltaicInfo> infos, double[] run, String inverterId) {

        List<Double> collect = infos.stream().map(info -> info.getS()).collect(Collectors.toList());
        // 计算功率离散率
        double powerDeviation = calculatePowerDeviation(collect, run);
        // 计算平均功率
        double averagePower = calculateAveragePower(collect);
        // 分析逆变器状态
        String inverterStatus = analyzeInverterStatus(powerDeviation, averagePower);

        return new InverterData2(inverterId, powerDeviation, averagePower, inverterStatus, "离散率");
    }

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

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