using System.Reflection;
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 ProcessVariable _ProcessVariable;
        private static PidController _PidController;


        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();

            while (true)
            {
                try
                {
                    // TODO I1, I2, I3 von Wallbox mit I1-3 von Zähler per Kombinatorik max vom Haus ausrechnen
                    // newLoadingCurrent = maxSicherung - maxHaus
                    var measurement = _EnergyManager.GetValue(_ProcessVariable);
                    var newLoadingCurrent = _PidController.Update(measurement);
                    //if (newLoadingCurrent < 6) { newLoadingCurrent = 0; }
                    _Driver?.SetLoadingCurrent(newLoadingCurrent);
                } catch (Exception ex)
                {
                    Console.WriteLine($"Error in main loop: {ex.Message}");
                }
                Thread.Sleep(1000);
            }
        }

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

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

            var fullDriverTypeName = "TestApp.Driver." + dirverName;
            var driverType = Assembly.GetExecutingAssembly().GetType(fullDriverTypeName);
            if (driverType is null)
            {
                throw new ArgumentException($"Charger driver type '{dirverName}' not found!");
            }

            if (_Driver is null || !_Driver.GetType().Equals(driverType))
            {
                var newDriverObject = Activator.CreateInstance(driverType);
                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;
        }

        private static void UpdateControllerSettings(Settings settings)
        {
            var allModeSettings = settings.ModeSettings ?? Array.Empty<ModeSettings>();
            if (!allModeSettings.Any()) {
                allModeSettings = new ModeSettings[]{
                    new ModeSettings() {
                        ProcessVariable = ProcessVariable.ActivePowerPositive,
                        SetPoint = 0,
                        PositivePid = new PidSetting(),
                        NegativePid = new PidSetting(),
                    }
                };
            }

            var mode = settings.Mode;
            if (mode < 0) { mode = 0; }
            if (mode >= allModeSettings.Length) { mode = allModeSettings.Length - 1; }

            var modeSetting = allModeSettings[mode];

            if (_ProcessVariable != modeSetting.ProcessVariable)
            {
                _PidController = new PidController();
                _ProcessVariable = modeSetting.ProcessVariable;
            }

            _PidController.SetPoint = modeSetting.SetPoint;
            _PidController.PositiveSettings = modeSetting.PositivePid ?? new PidSetting();
            _PidController.NegativeSettings = modeSetting.NegativePid ?? new PidSetting();
        }
    }
}