using System.Diagnostics.CodeAnalysis;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Reactive.Linq;
using System.Reactive.Threading.Tasks;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using Flurl.Http;
using InnovEnergy.App.SaliMax.Devices;
using InnovEnergy.App.SaliMax.Ess;
using InnovEnergy.App.SaliMax.MiddlewareClasses;
using InnovEnergy.App.SaliMax.SaliMaxRelays;
using InnovEnergy.App.SaliMax.System;
using InnovEnergy.App.SaliMax.SystemConfig;
using InnovEnergy.Lib.Devices.AMPT;
using InnovEnergy.Lib.Devices.Battery48TL;
using InnovEnergy.Lib.Devices.EmuMeter;
using InnovEnergy.Lib.Devices.Trumpf.SystemControl;
using InnovEnergy.Lib.Devices.Trumpf.SystemControl.DataTypes;
using InnovEnergy.Lib.Devices.Trumpf.TruConvertAc;
using InnovEnergy.Lib.Devices.Trumpf.TruConvertAc.DataTypes;
using InnovEnergy.Lib.Devices.Trumpf.TruConvertDc;
using InnovEnergy.Lib.Devices.Trumpf.TruConvertDc.Control;
using InnovEnergy.Lib.Protocols.Modbus.Channels;
using InnovEnergy.Lib.Units;
using InnovEnergy.Lib.Utils;
using System.Text.Json;
using RabbitMQ.Client;
using static System.Double;
using static InnovEnergy.Lib.Devices.Trumpf.SystemControl.DataTypes.SystemConfig;
using DeviceState = InnovEnergy.App.SaliMax.Devices.DeviceState;


#pragma warning disable IL2026

namespace InnovEnergy.App.SaliMax;

internal static class Program
{
    private static readonly TimeSpan UpdateInterval = TimeSpan.FromSeconds(2);
    
    private static readonly IReadOnlyList<Byte> BatteryNodes;
    
    private static readonly Channel TruConvertAcChannel ;
    private static readonly Channel TruConvertDcChannel ;
    private static readonly Channel GridMeterChannel    ;
    private static readonly Channel IslandBusLoadChannel;
    private static readonly Channel PvOnDc              ;
    private static readonly Channel PvOnAcGrid          ;
    private static readonly Channel PvOnAcIsland        ;
    private static readonly Channel RelaysChannel       ;
    private static readonly Channel BatteriesChannel    ;

    //private const String VpnServerIp = "194.182.190.208";
    private const String VpnServerIp = "10.2.0.11";
    
    private static IPAddress?          _controllerIpAddress;
    private static UdpClient           _udpListener = null!;
    private static ConnectionFactory?  _factory ;
    private static IConnection ?       _connection;
    private static IModel?             _channel;
    private static Boolean             _subscribedToQueue = false;
    private static Boolean             _subscribeToQueueForTheFirstTime = false;
    private static SalimaxAlarmState   _prevSalimaxState = SalimaxAlarmState.Green;
    private static Int32               _heartBitInterval = 0;
    
    static Program()
    {
        var config = Config.Load();
        var d = config.Devices;

        Channel CreateChannel(SalimaxDevice device) => device.DeviceState == DeviceState.Disabled 
                                                     ? new NullChannel()
                                                     : new TcpChannel(device);

        TruConvertAcChannel  = CreateChannel(d.TruConvertAcIp);
        TruConvertDcChannel  = CreateChannel(d.TruConvertDcIp);
        GridMeterChannel     = CreateChannel(d.GridMeterIp);
        IslandBusLoadChannel = CreateChannel(d.IslandBusLoadMeterIp);
        PvOnDc               = CreateChannel(d.PvOnDc);
        PvOnAcGrid           = CreateChannel(d.PvOnAcGrid);
        PvOnAcIsland         = CreateChannel(d.PvOnAcIsland);
        RelaysChannel        = CreateChannel(d.RelaysIp);
        BatteriesChannel     = CreateChannel(d.BatteryIp);
        
        BatteryNodes         = config
                                .Devices
                                .BatteryNodes
                                .Select(n => n.ConvertTo<Byte>())
                                .ToArray(config.Devices.BatteryNodes.Length);
    }

    public static async Task Main(String[] args)
    {
        //Do not await
        HourlyDataAggregationManager();
        InitializeCommunicationToMiddleware();
        while (true)
        {
            try
            {
                await Run();
            }
            catch (Exception e)
            {
                e.LogError();
            }    
        }
    }

    private static void InitializeCommunicationToMiddleware()
    {
        _controllerIpAddress = FindVpnIp();
        if (Equals(IPAddress.None, _controllerIpAddress))
        {
            Console.WriteLine("There is no VPN interface, exiting...");
        }

        const Int32 udpPort = 9000;
        var endPoint = new IPEndPoint(_controllerIpAddress, udpPort);

        _udpListener = new UdpClient();
        _udpListener.Client.Blocking = false;
        _udpListener.Client.Bind(endPoint);
    }

    private static async Task Run()
    {
        "Starting SaliMax".LogInfo();
        
        Watchdog.NotifyReady();

        var battery48TlDevices = BatteryNodes
                                .Select(n => new Battery48TlDevice(BatteriesChannel, n))
                                .ToList();
        
        var batteryDevices      = new Battery48TlDevices(battery48TlDevices);
        var acDcDevices         = new TruConvertAcDcDevices(TruConvertAcChannel);
        var dcDcDevices         = new TruConvertDcDcDevices(TruConvertDcChannel);
        var gridMeterDevice     = new EmuMeterDevice(GridMeterChannel);
        var acIslandLoadMeter   = new EmuMeterDevice(IslandBusLoadChannel); 
        var pvOnDcDevice        = new AmptDevices(PvOnDc);
        var pvOnAcGridDevice    = new AmptDevices(PvOnAcGrid);
        var pvOnAcIslandDevice  = new AmptDevices(PvOnAcIsland);
        var saliMaxRelaysDevice = new RelaysDevice(RelaysChannel);

        StatusRecord ReadStatus()
        {
            var config             = Config.Load();
            var devices            = config.Devices;
            var acDc               = acDcDevices.Read();
            var dcDc               = dcDcDevices.Read();
            var relays             = saliMaxRelaysDevice.Read();
            var loadOnAcIsland     = acIslandLoadMeter.Read();
            var gridMeter          = gridMeterDevice.Read();
            var pvOnDc             = pvOnDcDevice.Read();
            var battery            = batteryDevices.Read();

            var pvOnAcGrid         = pvOnAcGridDevice.Read();   
            var pvOnAcIsland       = pvOnAcIslandDevice.Read(); 

            var gridBusToIslandBus = Topology.CalculateGridBusToIslandBusPower(pvOnAcIsland, loadOnAcIsland, acDc);

            var gridBusLoad = devices.LoadOnAcGrid.DeviceState == DeviceState.Disabled
                                                                 ? new AcPowerDevice { Power = 0 }
                                                                 : Topology.CalculateGridBusLoad(gridMeter, pvOnAcGrid, gridBusToIslandBus);

            var dcLoad = devices.LoadOnDc.DeviceState == DeviceState.Disabled
                                                        ? new DcPowerDevice { Power = 0 }
                                                        : Topology.CalculateDcLoad(acDc, pvOnDc, dcDc);

            var acDcToDcLink = devices.LoadOnDc.DeviceState == DeviceState.Disabled ?
                                                              Topology.CalculateAcDcToDcLink(pvOnDc, dcDc, acDc) 
                                                              : new DcPowerDevice{ Power = acDc.Dc.Power}; 

            return new StatusRecord
            {
                AcDc             = acDc,
                DcDc             = dcDc,
                Battery          = battery,
                Relays           = relays,
                GridMeter        = gridMeter,
                PvOnAcGrid       = pvOnAcGrid,
                PvOnAcIsland     = pvOnAcIsland,
                PvOnDc           = pvOnDc,
                AcGridToAcIsland = gridBusToIslandBus,
                AcDcToDcLink     = acDcToDcLink,
                LoadOnAcGrid     = gridBusLoad,
                LoadOnAcIsland   = loadOnAcIsland,
                LoadOnDc         = dcLoad,

                StateMachine     = StateMachine.Default,
                EssControl       = EssControl.Default,
                Log              = new SystemLog { SalimaxAlarmState = SalimaxAlarmState.Green, Message = null }, //TODO: Put real stuff
                Config           = config // load from disk every iteration, so config can be changed while running
            };
        }

        void WriteControl(StatusRecord r)
        {
            if (r.Relays is not null)
                saliMaxRelaysDevice.Write(r.Relays);

            acDcDevices.Write(r.AcDc);
            dcDcDevices.Write(r.DcDc);
        }

        Console.WriteLine("press ctrl-c to stop");

        while (true)
        {
            await Observable
                 .Interval(UpdateInterval)
                 .Select(_ => RunIteration())
                 .SelectMany(r => UploadCsv(r, DateTime.Now.Round(UpdateInterval)))
                 .SelectError()
                 .ToTask();
        }
        

        StatusRecord RunIteration()
        {
            Watchdog.NotifyAlive();

            var record = ReadStatus();
            
            var currentSalimaxState = GetSalimaxStateAlarm(record);
            
            SendSalimaxStateAlarm(currentSalimaxState,record);

            record.ControlConstants();
            record.ControlSystemState();

            var essControl = record.ControlEss().WriteLine().LogInfo();

            record.EssControl = essControl;

            record.AcDc.SystemControl.ApplyAcDcDefaultSettings();
            record.DcDc.SystemControl.ApplyDcDcDefaultSettings();

            DistributePower(record, essControl);

            WriteControl(record);

            $"{DateTime.Now.Round(UpdateInterval).ToUnixTime()} : {record.StateMachine.State}: {record.StateMachine.Message}".WriteLine()
                .LogInfo();
            
            record.CreateTopologyTextBlock().WriteLine();
            
            (record.Relays is null ? "No relay Data available" : record.Relays.FiWarning ? "Alert: Fi Warning Detected" : "No Fi Warning Detected").WriteLine();
            (record.Relays is null ? "No relay Data available" : record.Relays.FiError   ? "Alert: Fi Error Detected"   : "No Fi Error Detected")  .WriteLine();

            //record.ApplyConfigFile(minSoc:22, gridSetPoint:1);
            
            record.Config.Save();
                
            "===========================================".LogInfo();

            return record;
        }

        // ReSharper disable once FunctionNeverReturns
    }

    private static void SendSalimaxStateAlarm(StatusMessage currentSalimaxState, StatusRecord record)
    {
        var s3Bucket = Config.Load().S3?.Bucket;
        
        //Every 15 iterations(30 seconds), the installation sends a heartbit message to the queue
        _heartBitInterval++;

        //When the controller boots, it tries to subscribe to the queue
        if (_subscribeToQueueForTheFirstTime==false)
        {
            _subscribeToQueueForTheFirstTime = true;
            SubscribeToQueue(currentSalimaxState, s3Bucket);
        }
        //If already subscribed to the queue and the status has been changed, update the queue
        if (_subscribedToQueue && currentSalimaxState.Status != _prevSalimaxState)
        {
            _prevSalimaxState = currentSalimaxState.Status;
            if (s3Bucket != null)
                InformMiddleware(currentSalimaxState);
        }
        else if (_subscribedToQueue && _heartBitInterval>=15)
        {
            //Send a heartbit to the backend
            Console.WriteLine("----------------------------------------Sending Heartbit----------------------------------------");
            _heartBitInterval = 0;
            currentSalimaxState.Type = MessageType.Heartbit;
                
            if (s3Bucket != null)
                InformMiddleware(currentSalimaxState);
        }

        //If there is an available message from the RabbitMQ Broker, apply the configuration file
        if (_udpListener.Available > 0)
        {
            IPEndPoint? serverEndpoint = null;
        
            var replyMessage  = "ACK";
            var replyData     = Encoding.UTF8.GetBytes(replyMessage);
        
            var udpMessage = _udpListener.Receive(ref serverEndpoint);
            var message    = Encoding.UTF8.GetString(udpMessage);
            
            Configuration config = JsonSerializer.Deserialize<Configuration>(message);
        
            Console.WriteLine($"Received a configuration message: GridSetPoint is "+config.GridSetPoint +", MinimumSoC is "+config.MinimumSoC+ " and ForceCalibrationCharge is "+config.ForceCalibrationCharge);

            // Send the reply to the sender's endpoint
            _udpListener.Send(replyData, replyData.Length, serverEndpoint);
            Console.WriteLine($"Replied to {serverEndpoint}: {replyMessage}");
            
            record.ApplyConfigFile(config);
            
        }
    }

    private static void SubscribeToQueue(StatusMessage currentSalimaxState, String? s3Bucket)
    {
        try
        {
            //_factory    = new ConnectionFactory { HostName = VpnServerIp };
            
            _factory = new ConnectionFactory
            {
                HostName = VpnServerIp,
                Port = 5672,
                VirtualHost = "/",
                UserName = "producer",
                Password = "b187ceaddb54d5485063ddc1d41af66f",
               
            };
            
            _connection = _factory.CreateConnection();
            _channel    = _connection.CreateModel();
            _channel.QueueDeclare(queue: "statusQueue", durable: true, exclusive: false, autoDelete: false, arguments: null);
            
            Console.WriteLine("The controller sends its status to the middleware for the first time");
            if (s3Bucket != null) InformMiddleware(currentSalimaxState);
    
            _subscribedToQueue = true;
        }
        catch (Exception ex)
        {
            Console.WriteLine("An error occurred while connecting to the RabbitMQ queue: " + ex.Message);
        }
    }

    private static IPAddress FindVpnIp()
    {
        const String interfaceName = "innovenergy";
        
        var networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
        
        foreach (var networkInterface in networkInterfaces)
        {
            if (networkInterface.Name == interfaceName)
            {
                var ipProps         = networkInterface.GetIPProperties();
                var uniCastIPs      = ipProps.UnicastAddresses;
                var controllerIpAddress = uniCastIPs[0].Address;

                Console.WriteLine("VPN IP is: "+ uniCastIPs[0].Address);
                return controllerIpAddress;
            }
        }

        return IPAddress.None;
    }

    private static void  InformMiddleware(StatusMessage status)
    {        
        var message = JsonSerializer.Serialize(status);
        var body    = Encoding.UTF8.GetBytes(message);

        _channel.BasicPublish(exchange: string.Empty,
                              routingKey: "statusQueue",
                              basicProperties: null,
                              body: body);
        
        Console.WriteLine($"Producer sent message: {message}");
    }

    private static StatusMessage GetSalimaxStateAlarm(StatusRecord record)
    {
       var alarmCondition = record.DetectAlarmStates();
       var s3Bucket = Config.Load().S3?.Bucket;

       var alarmList   = new List<AlarmOrWarning>();
       var warningList = new List<AlarmOrWarning>();

        if (alarmCondition is not null)
        {
            alarmCondition.LogInfo();

            alarmList.Add(new AlarmOrWarning
            {
                Date = DateTime.Now.ToString("yyyy-MM-dd"),
                Time = DateTime.Now.ToString("HH:mm:ss"),
                CreatedBy = "Salimax",
                Description = alarmCondition
            });
        }
          
       foreach (var alarm in record.AcDc.Alarms)
       {
           alarmList.Add(new AlarmOrWarning
           {
               Date = DateTime.Now.ToString("yyyy-MM-dd"),
               Time = DateTime.Now.ToString("HH:mm:ss"),
               CreatedBy = "AcDc",
               Description = alarm.ToString()
           });
       }
       
       foreach (var alarm in record.DcDc.Alarms)
       {
           alarmList.Add(new AlarmOrWarning
           {
               Date = DateTime.Now.ToString("yyyy-MM-dd"),
               Time = DateTime.Now.ToString("HH:mm:ss"),
               CreatedBy = "DcDc",
               Description = alarm.ToString()
           });
       }

       if (record.Battery != null)
       {
           var i = 0;
           
           foreach (var battery in record.Battery.Devices)
           {
               i++;
               foreach (var alarm in battery.Alarms)
               {
                   alarmList.Add(new AlarmOrWarning
                   {
                       Date = DateTime.Now.ToString("yyyy-MM-dd"),
                       Time = DateTime.Now.ToString("HH:mm:ss"),
                       CreatedBy = "Battery" + i,
                       Description = alarm
                   });
               }
           }
           
       }
       
       foreach (var warning in record.AcDc.Warnings)
       {
           warningList.Add(new AlarmOrWarning
           {
               Date = DateTime.Now.ToString("yyyy-MM-dd"),
               Time = DateTime.Now.ToString("HH:mm:ss"),
               CreatedBy = "AcDc",
               Description = warning.ToString()
           });
       }
       
       foreach (var warning in record.DcDc.Warnings)
       {
           warningList.Add(new AlarmOrWarning
           {
               Date = DateTime.Now.ToString("yyyy-MM-dd"),
               Time = DateTime.Now.ToString("HH:mm:ss"),
               CreatedBy = "DcDc",
               Description = warning.ToString()
           });
       }

       if (record.Battery != null)
       {
           foreach (var warning in record.Battery.Warnings)
           {
               warningList.Add(new AlarmOrWarning
               {
                   Date = DateTime.Now.ToString("yyyy-MM-dd"),
                   Time = DateTime.Now.ToString("HH:mm:ss"),
                   CreatedBy = "Battery",
                   Description = warning
               });
           }
       }

       var salimaxAlarmsState = (record.Battery is not null && record.Battery.Warnings.Any())
                                | record.AcDc.Warnings.Any()
                                | record.AcDc.SystemControl.Warnings.Any()
                                | record.DcDc.Warnings.Any()
                                ? SalimaxAlarmState.Orange
                                : SalimaxAlarmState.Green; // this will be replaced by LedState

       salimaxAlarmsState = (record.Battery is not null && record.Battery.Alarms.Any())
                                | record.AcDc.Alarms.Any()
                                | record.AcDc.SystemControl.Alarms.Any()
                                | record.DcDc.Alarms.Any()
                                | alarmCondition is not null
                                ? SalimaxAlarmState.Red
                                : salimaxAlarmsState; // this will be replaced by LedState

       int.TryParse(s3Bucket?.Split("-")[0], out var installationId);

       var returnedStatus = new StatusMessage
       {
           InstallationId = installationId,
           Status         =  salimaxAlarmsState,
           Type           =  MessageType.AlarmOrWarning,
           Alarms         = alarmList,
           Warnings       = warningList
       };

       return returnedStatus;     
    }

    private static String? DetectAlarmStates(this StatusRecord r) => r.Relays switch
    {
        { K2ConnectIslandBusToGridBus: false, K2IslandBusIsConnectedToGridBus: true } => " Contradiction: R0 is opening the K2 but the K2 is still close ",
        { K1GridBusIsConnectedToGrid : false, K2IslandBusIsConnectedToGridBus: true } => " Contradiction: K1 is open but the K2 is still close ",
        { FiError: true, K2IslandBusIsConnectedToGridBus: true                      } => " Contradiction: Fi error occured but the K2 is still close ",
        _                                                                             => null
    };

    private static void ControlConstants(this StatusRecord r)
    {
        var inverters     = r.AcDc.Devices;
        var dcDevices     = r.DcDc.Devices;
        var configFile    = r.Config;

        var devicesConfig = r.AcDc.Devices.All(d => d.Control.Ac.GridType == GridType.GridTied400V50Hz) ? configFile.GridTie : configFile.IslandMode; // TODO if any of the grid tie mode
        
        inverters.ForEach(d => d.Control.Dc.MaxVoltage                               = devicesConfig.AcDc.MaxDcLinkVoltage);
        inverters.ForEach(d => d.Control.Dc.MinVoltage                               = devicesConfig.AcDc.MinDcLinkVoltage);
        inverters.ForEach(d => d.Control.Dc.ReferenceVoltage                         = devicesConfig.AcDc.ReferenceDcLinkVoltage);
        
        inverters.ForEach(d => d.Control.Dc.PrechargeConfig                          = DcPrechargeConfig.PrechargeDcWithInternal);
       
        dcDevices.ForEach(d => d.Control.DroopControl.UpperVoltage                   = devicesConfig.DcDc.UpperDcLinkVoltage);
        dcDevices.ForEach(d => d.Control.DroopControl.LowerVoltage                   = devicesConfig.DcDc.LowerDcLinkVoltage);
        dcDevices.ForEach(d => d.Control.DroopControl.ReferenceVoltage               = devicesConfig.DcDc.ReferenceDcLinkVoltage);
        
        dcDevices.ForEach(d => d.Control.CurrentControl.MaxBatteryChargingCurrent    = configFile.MaxBatteryChargingCurrent);
        dcDevices.ForEach(d => d.Control.CurrentControl.MaxBatteryDischargingCurrent = configFile.MaxBatteryDischargingCurrent);
        dcDevices.ForEach(d => d.Control.MaxDcPower                                  = configFile.MaxDcPower);

        dcDevices.ForEach(d => d.Control.VoltageLimits.MaxBatteryVoltage             = configFile.MaxChargeBatteryVoltage);
        dcDevices.ForEach(d => d.Control.VoltageLimits.MinBatteryVoltage             = configFile.MinDischargeBatteryVoltage);
        dcDevices.ForEach(d => d.Control.ControlMode                                 = DcControlMode.VoltageDroop);

        r.DcDc.ResetAlarms();
        r.AcDc.ResetAlarms();
    }


    // why this is not in Controller?
    private static void DistributePower(StatusRecord record, EssControl essControl)
    {
        var nInverters = record.AcDc.Devices.Count;
        
        var powerPerInverterPhase = nInverters > 0
                                  ? essControl.PowerSetpoint / nInverters / 3
                                  : 0;
                
        record.AcDc.Devices.ForEach(d =>
        {
            d.Control.Ac.PhaseControl = PhaseControl.Asymmetric;
            d.Control.Ac.Power.L1 = powerPerInverterPhase;
            d.Control.Ac.Power.L2 = powerPerInverterPhase;
            d.Control.Ac.Power.L3 = powerPerInverterPhase;
        });
    }

    private static void ApplyAcDcDefaultSettings(this SystemControlRegisters? sc)
    {
        if (sc is null)
            return;
        
        sc.ReferenceFrame          = ReferenceFrame.Consumer;
        sc.SystemConfig            = AcDcAndDcDc;

        #if DEBUG
        sc.CommunicationTimeout    = TimeSpan.FromMinutes(2);    
        #else
        sc.CommunicationTimeout    = TimeSpan.FromSeconds(20);
        #endif
        
        sc.PowerSetPointActivation = PowerSetPointActivation.Immediate;
        sc.UseSlaveIdForAddressing = true;
        sc.SlaveErrorHandling      = SlaveErrorHandling.Relaxed;
        sc.SubSlaveErrorHandling   = SubSlaveErrorHandling.Off;
        
        sc.ResetAlarmsAndWarnings  = true;
    }
    
    private static void ApplyDcDcDefaultSettings(this SystemControlRegisters? sc)
    {

        if (sc is null)
            return;
        
        sc.SystemConfig            = DcDcOnly;
        #if DEBUG
        sc.CommunicationTimeout    = TimeSpan.FromMinutes(2);    
        #else
        sc.CommunicationTimeout    = TimeSpan.FromSeconds(20);
        #endif
        
        sc.PowerSetPointActivation = PowerSetPointActivation.Immediate;
        sc.UseSlaveIdForAddressing = true;
        sc.SlaveErrorHandling      = SlaveErrorHandling.Relaxed;
        sc.SubSlaveErrorHandling   = SubSlaveErrorHandling.Off;
                
        sc.ResetAlarmsAndWarnings  = true; 
    }

    private static async Task<Boolean> UploadCsv(StatusRecord status, DateTime timeStamp)
    {
        var s3Config = status.Config.S3;
        var csv      = status.ToCsv().LogInfo();
        if (s3Config is null)
            return false;

        var s3Path   = timeStamp.ToUnixTime() + ".csv";
        var request  = s3Config.CreatePutRequest(s3Path);
        var response = await request.PutAsync(new StringContent(csv));

        // This is temporary for Wittman
        //await File.WriteAllTextAsync("/var/www/html/status.csv", csv.SplitLines().Where(l => !l.Contains("Secret")).JoinLines());
        
        if (response.StatusCode != 200)
        {
            Console.WriteLine("ERROR: PUT");
            var error = await response.GetStringAsync();
            Console.WriteLine(error);
        }
        
        return true; 
    }
    
    private static async Task HourlyDataAggregationManager()
    {
        DateTime currentDateTime = DateTime.Now;
        DateTime nextRoundedHour = currentDateTime.AddHours(1).AddMinutes(-currentDateTime.Minute).AddSeconds(-currentDateTime.Second);

        // Calculate the time until the next rounded hour
        TimeSpan timeUntilNextHour = nextRoundedHour - currentDateTime;

        // Output the current and next rounded hour times
        Console.WriteLine("Current Date and Time: " + currentDateTime);
        Console.WriteLine("Next Rounded Hour: " + nextRoundedHour);

        // Output the time until the next rounded hour
        Console.WriteLine("Waiting for " + timeUntilNextHour.TotalMinutes + " minutes...");

        // Wait until the next rounded hour
        await Task.Delay(timeUntilNextHour);
        
        while (true)
        {
            try
            {
                CreateHourlyAverage();
            }
            catch (Exception e)
            {
                Console.WriteLine("An error has occured when calculating hourly aggregated data, exception is:\n" + e);
            }
            await Task.Delay(TimeSpan.FromHours(1));
        }
    }

    private static void CreateHourlyAverage()
    {
        var myDirectory = "LogDirectory";

        // Get all CSV files in the specified directory
        var csvFiles = Directory.GetFiles(myDirectory, "*.csv");

        var currentTimestamp       = DateTime.Now.ToUnixTime();
        Double socAverage          = 0;
        Double pvPowerAverage      = 0;
        Double batteryPowerAverage = 0;
        
        Console.WriteLine("-----------------------------------------------------------------------------------------------------------------");
        Console.WriteLine("File timestamp should start after "+ DateTime.Now.AddHours(-1));
        
        foreach (var csvFile in csvFiles)
        {

            if (csvFile == "LogDirectory/log.csv")
            {
                continue;
            }
            var fileTimestamp = long.Parse(Path.GetFileNameWithoutExtension(csvFile).Replace("log_", ""));
            var oneHourBefore = DateTime.Now.AddHours(-1).ToUnixTime();
            

            if (fileTimestamp >= oneHourBefore && fileTimestamp <= currentTimestamp)
            {
                Console.WriteLine("Check file created at "+ DateTimeOffset.FromUnixTimeSeconds(fileTimestamp).DateTime);
                using var reader = new StreamReader(csvFile);
                
                while (!reader.EndOfStream)
                {
                    var line = reader.ReadLine();
                    var lines = line?.Split(';');

                    // Assuming there are always three columns (variable name and its value)
                    if (lines is { Length: 3 })
                    {
                        var variableName  = lines[0].Trim();
                        
                        if (TryParse(lines[1].Trim(), out var value))
                        {
                            // Check if variableValue is a valid number
                            if (IsSoc(variableName))
                            {
                                if (socAverage == 0)
                                {
                                    socAverage =  value;
                                }
                                else
                                {
                                    socAverage = (socAverage + value) / 2;
                                }
                            }

                            if (IsPvPower(variableName))
                            {
                                if (pvPowerAverage == 0)
                                {
                                    pvPowerAverage = value;
                                }
                                else
                                {
                                    pvPowerAverage = (pvPowerAverage + value) / 2;
                                }
                            }

                            if (IsBatteryPower(variableName))
                            {
                                if (batteryPowerAverage == 0)
                                {
                                    batteryPowerAverage = value;
                                }
                                else
                                {
                                    batteryPowerAverage = (batteryPowerAverage + value) / 2;
                                }
                            }
                        }
                        else
                        {
                            // Handle cases where variableValue is not a valid number
                             Console.WriteLine($"Invalid numeric value for variable {variableName}:{lines[1].Trim()}");
                        }
                    }
                    else
                    {
                        // Handle invalid column format
                        Console.WriteLine("Invalid format in column");
                    }
                }
            }
        }
        
        // Print the stored CSV data for verification

        Console.WriteLine($"SOC:     {socAverage}");
        Console.WriteLine($"PvPower: {pvPowerAverage}");
        Console.WriteLine($"Battery: {batteryPowerAverage}");
        
        Console.WriteLine("CSV data reading and storage completed.");
        //Create a new file to folder "Hourly Aggregated Data and push it to S3"
        Console.WriteLine("-----------------------------------------------------------------------------------------------------------------");
        
    }
    
    // Custom method to check if a string is numeric
    private static bool IsSoc(string value)
    {
        return value == "/Battery/Soc";
    }
    
    private static bool IsPvPower(string value)
    {
        return value == "/PvOnDc/Dc/Power";
    }
    
    private static bool IsBatteryPower(string value)
    {
        return value == "/Battery/Dc/Power";
    }

    private static void ApplyConfigFile(this StatusRecord status, Configuration config)
    {
        status.Config.MinSoc                 = config.MinimumSoC;
        status.Config.GridSetPoint           = config.GridSetPoint * 1000; // converted from kW to W
        status.Config.ForceCalibrationCharge = config.ForceCalibrationCharge;
    }
    
}