using InnovEnergy.App.SinexcelCommunication.DataTypes;
using InnovEnergy.Lib.Devices.Sinexcel_12K_TL;
using InnovEnergy.Lib.Devices.Sinexcel_12K_TL.DataType;
using InnovEnergy.Lib.Units;
using InnovEnergy.Lib.Units.Power;

namespace InnovEnergy.App.SinexcelCommunication.ESS;

public class InverterRecords
{
    
    public required Energy               SelfGeneratedElectricity  { get; init; }
    public required Energy               ElectricityPurchased      { get; init; }
    public required Energy               ElectricityFed            { get; init; }
    public required Energy               BatteryChargeEnergy       { get; init; }
    public required Energy               BatteryDischargeEnergy    { get; init; }
    public required Energy               LoadPowerConsumption      { get; init; }
    
    public required Energy               DailySelfGeneratedElectricity  { get; init; }
    public required Energy               DailyElectricityPurchased      { get; init; }
    public required Energy               DailyElectricityFed            { get; init; }
    public required Energy               BatteryDailyChargeEnergy       { get; init; }
    public required Energy               BatteryDailyDischargeEnergy    { get; init; }
    public required Energy               DailyLoadPowerConsumption      { get; init; }
    
   // public required ActivePower           TotalConsumptionPower     { get; init; } 
    public required ActivePower           TotalPhotovoltaicPower    { get; init; }
    public required ActivePower           TotalBatteryPower         { get; init; }
    public required ActivePower           TotalLoadPower            { get; init; }
    public required ActivePower           TotalGridPower            { get; init; }
    
    public required OperatingPriority     OperatingPriority         { get; init; } 
    public required Voltage               AvgBatteryVoltage         { get; init; }
    public required Current               TotalBatteryCurrent       { get; init; }
    public required Percent               AvgBatterySoc             { get; init; }
    public required Percent               AvgBatterySoh             { get; init; }
    public required Temperature           AvgBatteryTemp            { get; init; }
    public required Percent               MinSoc                     { get; init; }

    public required Current               MaxChargeCurrent             { get; init; }
    public required Current               MaxDischargingCurrent        { get; init; }
    public required ActivePower           GridPower                    { get; init; }
    public required Frequency             GridFrequency                { get; init; }
    public required ActivePower           InverterPower                { get; init; }
    public required EnablePowerLimitation EnableGridExport             { get; init; }
    public required ActivePower           GridExportPower              { get; init; }


    public required IReadOnlyList<SinexcelRecord> Devices { get; init; }
    
    public static InverterRecords? FromInverters(IReadOnlyList<SinexcelRecord>? records)
    {
        if (records is null || records.Count == 0)
            return null;


        return new InverterRecords
        {
            Devices                     = records,
            
            DailySelfGeneratedElectricity = records.Sum(r => r.DailySelfGeneratedElectricity),            
            DailyElectricityPurchased     = records.Sum(r => r.DailyElectricityPurchased),        
            DailyElectricityFed           = records.Sum(r => r.DailyElectricityFed),
            BatteryDailyChargeEnergy      = records.Sum(r => r.BatteryDailyChargeEnergy),        
            BatteryDailyDischargeEnergy   = records.Sum(r => r.BatteryDailyDischargeEnergy),        
            DailyLoadPowerConsumption     = records.Sum(r => r.DailyLoadPowerConsumption),      
            
            SelfGeneratedElectricity      = records.Sum(r => r.SelfGeneratedElectricity),            
            ElectricityPurchased          = records.Sum(r => r.TotalEnergyToUser),        
            ElectricityFed                = records.Sum(r => r.TotalEnergyToGrid),
            BatteryChargeEnergy           = records.Sum(r => r.BatteryCharge),    
            BatteryDischargeEnergy        = records.Sum(r => r.BatteryDischarge),        
            LoadPowerConsumption          = records.Sum(r => r.LoadPowerConsumption),        
            
           // TotalConsumptionPower       = records.Sum(r => r.ConsumptionPower), // consumption same as load
            TotalPhotovoltaicPower       = records.Sum(r => r.TotalPhotovoltaicPower),
            TotalBatteryPower            = records.Sum(r => r.TotalBatteryPower),
            TotalLoadPower               = records.Sum(r => r.TotalLoadPower),
            TotalGridPower               = records.Sum(b => b.TotalGridPower),
            OperatingPriority            = records.Select(r => r.WorkingMode).Distinct().Count() == 1 ? (OperatingPriority)records.First().WorkingMode: OperatingPriority.ModeNotSynched,
            AvgBatteryVoltage            = records.SelectMany(r => new[] { r.Battery1Voltage.Value, r.Battery2Voltage.Value }).Where(v => v > 0).DefaultIfEmpty(0).Average(),
            TotalBatteryCurrent          = records.SelectMany(r => new [] { r.Battery1Current.Value, r.Battery2Current.Value}).Sum(),
            AvgBatterySoc                = records.SelectMany(r => new[] { r.Battery1Soc.Value, r.Battery2Soc.Value }).Average(),
            AvgBatterySoh                = records.SelectMany(r => new[] { r.Battery1Soh.Value, r.Battery2Soh.Value }).Average(),
            MinSoc                       = records.SelectMany(r => new[] { r.Battery1BackupSoc, r.Battery2BackupSoc}).Min(),
            AvgBatteryTemp               = records.SelectMany(r => new[] { r.Battery1Temperature.Value, r.Battery2Temperature.Value }).Average(),
            MaxChargeCurrent             = records.SelectMany(r => new[] { r.Battery1MaxChargingCurrent, r.Battery2MaxChargingCurrent }).Min(),
            MaxDischargingCurrent        = records.SelectMany(r => new[] { r.Battery1MaxDischargingCurrent, r.Battery2MaxDischargingCurrent }).Max(),
            GridPower                    = records.Sum(r => r.TotalGridPower),
            GridFrequency                = records.Average(r => r.GridVoltageFrequency),
            InverterPower                = records.Sum( r => r.InverterActivePower ),
            EnableGridExport             = records.Select(r => r.EnableGridExport).Distinct().Count() == 1 ? records.First().EnableGridExport: EnablePowerLimitation.Prohibited,
            GridExportPower              = records.Sum(r => r.PowerGridExportLimit)
        };
    }
}