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 dirverName = settings.ChargerDriver ?? Settings.DEFAULT_CHARGER_DRIVER;

            var sampleDriverType = typeof(VestelEvc04);
            var dirverNameSpace = sampleDriverType.Namespace;
            var fullDriverTypeName = dirverNameSpace + "." + dirverName;
            var driverType = sampleDriverType.Assembly.GetType(fullDriverTypeName);
            if (driverType is null)
            {
                throw new ArgumentException($"Charger driver type '{dirverName}' not found!");
            }

            if (_Driver is null || !_Driver.GetType().Equals(driverType))
            {
                var newDriverConstructor = driverType.GetConstructor(Array.Empty<Type>());
                if (newDriverConstructor is null) {
                    throw new InvalidOperationException($"Type {driverType} does not have a parameterless constructor!");
                }

                var newDriverObject = newDriverConstructor.Invoke(null, Array.Empty<object>());
                if (newDriverObject is null)
                {
                    throw new InvalidOperationException("Could not instantiate driver!");
                }
                if (newDriverObject is not IChargerDriver newDriver)
                {
                    throw new InvalidOperationException("New driver does not implement IChargerDriver!");
                }

                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;
        }
    }
}