using TestApp.Configuration;
using TestApp.Driver;

namespace TestApp
{
    internal class Program
    {
        private static ConfigurationManager _ConfigurationManager;
        private static IChargerDriver? _Driver;
        private static EnergyManager _EnergyManager;
        private static CurrentLimitter _CurrentLimitter;


        static async Task Main(string[] args)
        {
            _ConfigurationManager = new ConfigurationManager();
            _ConfigurationManager.SettingsChanged += OnSettingsChanged;
            try
            {
                OnSettingsChanged(_ConfigurationManager, _ConfigurationManager.Settings);
            } catch (Exception ex)
            {
                Console.WriteLine($"Error applying settings: {ex.Message}");
            }

            _EnergyManager = await EnergyManager.Create();
            _CurrentLimitter = new CurrentLimitter(_ConfigurationManager, _EnergyManager);

            while (true)
            {
                try
                {
                    if (_Driver is null) {
                        Thread.Sleep(1000);
                        continue;
                    }

                    var newCurrent = double.MaxValue;
                    if (_ConfigurationManager.Settings.Mode == 2) {
                        newCurrent = GetMode2LoadingCurrent();
                    }

                    newCurrent = _CurrentLimitter.GetLimitedCurrent(_Driver, newCurrent);
                    _Driver?.SetLoadingCurrent(newCurrent);
                } catch (Exception ex)
                {
                    Console.WriteLine($"Error in main loop: {ex.Message}");
                }
                Thread.Sleep(1000);
            }
        }

        private static double GetMode2LoadingCurrent()
        {
            var minNegativePower = _ConfigurationManager.Settings.MinNegativePower ?? Settings.DEFAULT_MIN_NEGATIVE_POWER;

            var negativePower = _EnergyManager.GetValue(EMVariable.ActivePowerNegative);

            if (negativePower < minNegativePower) { return 0; }

            var sparePower = negativePower - minNegativePower;

            var i1 = sparePower / _EnergyManager.GetValue(EMVariable.VoltageL1);
            var i2 = sparePower / _EnergyManager.GetValue(EMVariable.VoltageL2);
            var i3 = sparePower / _EnergyManager.GetValue(EMVariable.VoltageL3);

            return Math.Min(Math.Min(i1, i2), i3);
        }

        private static void OnSettingsChanged(object? sender, Settings settings)
        {
            UpdateDriverSettings(settings);
        }

        private static void UpdateDriverSettings(Settings settings) {
            var driverName = settings.ChargerDriver ?? Settings.DEFAULT_CHARGER_DRIVER;

            if (_Driver is null || !IsDriver(_Driver, driverName))
            {
                var newDriver = CreateDriver(driverName);
                if (newDriver is null)
                {
                    throw new InvalidOperationException($"New driver {driverName} could not be found!");
                }

                if (_Driver is IDisposable disposable)
                {
                    disposable.Dispose();
                }
                _Driver = newDriver;
            }

            _Driver.HostAddress = settings.ChargerAddress ?? Settings.DEFAULT_CHARGER_ADDRESS;
            _Driver.Port = settings.ChargerPort ?? Settings.DEFAULT_CHARGER_PORT;
        }

        private static bool IsDriver(IChargerDriver dirver, string name) {
            return name switch
            {
                "VestelEvc04" => dirver is VestelEvc04,
                _ => false
            };
        }

        private static IChargerDriver? CreateDriver(string name) {
            return name switch
            {
                "VestelEvc04" => new VestelEvc04(),
                _ => null
            };
        }
    }
}