Blog

using choinka.Triggers.SolarTime;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Serilog;

try
{
    var hostBuilder= Host.CreateDefaultBuilder();
    hostBuilder.Build().Run();
}
catch (Exception ex)
{
    Log.Fatal("Fatar error: {Message}", ex.Message);
}
finally
{
    Log.Information("Shutdown complete");
    Log.CloseAndFlush();
}

public class Places
{
    public IEnumerable<Coordinates> Coordinates { get; init; } = [
        new Coordinates()
        {
            Name = "Warsaw", Latitude = 52.2298, Longitude = 21.0117
        },
        new Coordinates()
        {
            Name = "Gdansk", Latitude = 54.35, Longitude = 18.6667
        },
    ];
}

public class Coordinates
{
    public string Name { get; init; } = null!;
    public Angle Latitude { get; init; } = Angle.Empty;
    public Angle Longitude { get; init; } = Angle.Empty;
}

internal class SolarCalculator : ISolarCalculator
{
    private readonly Coordinates _warsaw;
    private readonly Places _places;

    public SolarCalculator(Places places)
    {
        _places = places;
        _warsaw = _places.Coordinates.First(c => c.Name.Equals(
            "Warsaw", StringComparison.Ordinal));
    }

    public DateTime GetWarsawSunset(DateTimeOffset? date = null)
    {
        var time = new SolarTimes(date ?? DateTimeOffset.Now, _warsaw.Latitude, _warsaw.Longitude);
        return time.Sunset;
    }
}

internal interface ISolarCalculator
{
    DateTime GetWarsawSunset(DateTimeOffset? date = null);
}

internal class SolarNotifierService(
    ILogger<SolarNotifierService> logger,
    IServiceScopeFactory scopeFactory) : BackgroundService
{
    public event EventHandler SunsetOccurred;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await RunEventLoopAsync(
            "Zachód słońca",
            (calc, date) => calc.GetWarsawSunset(date),
            reason => InvokeSunsetEvent(reason),
            stoppingToken);
    }

    private async Task RunEventLoopAsync(
        string eventName,
        Func<ISolarCalculator, DateTimeOffset?, DateTime> getEventTime,
        Action<string> invokeEvent,
        CancellationToken token)
    {
        try
        {
            // Initial check + possible catch-up
            using (var scope = scopeFactory.CreateScope())
            {
                var calculator = scope.ServiceProvider.GetRequiredService<ISolarCalculator>();
                var todayTime = getEventTime(calculator, null);
                var now = DateTimeOffset.Now;

                if (now > todayTime)
                {
                    logger.LogWarning("Aplikacja uruchomiona po {EventName}. Wywołuję event natychmiast (catch-up).", eventName);
                    invokeEvent($"Zaległy {eventName} (start aplikacji po czasie)");
                }
                else
                {
                    logger.LogInformation("Czekam na dzisiejszy {EventName}: {EventTime}", eventName, todayTime);
                    await WaitUntil(todayTime, token);

                    if (!token.IsCancellationRequested)
                        invokeEvent($"Dzisiejszy {eventName}");
                }
            }

            // Daily loop
            while (!token.IsCancellationRequested)
            {
                try
                {
                    var tomorrow = DateTimeOffset.Now.AddDays(1);
                    using var scope = scopeFactory.CreateScope();
                    var calculator = scope.ServiceProvider.GetRequiredService<ISolarCalculator>();
                    var nextTime = getEventTime(calculator, tomorrow);

                    logger.LogInformation("Następny {EventName} zaplanowany na: {EventTime}", eventName, nextTime);

                    await WaitUntil(nextTime, token);

                    if (!token.IsCancellationRequested)
                        invokeEvent($"Planowy {eventName}");
                }
                catch (OperationCanceledException)
                {
                    // cancellation requested - exit loop
                    break;
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, "Unexpected error in {EventName} loop", eventName);
                    try
                    {
                        await Task.Delay(TimeSpan.FromSeconds(5), token);
                    }
                    catch (OperationCanceledException)
                    {
                        break;
                    }
                }
            }
        }
        catch (OperationCanceledException)
        {
            // cancelled before starting - ignore
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Fatal error while starting {EventName} loop", eventName);
        }
    }

    private async Task WaitUntil(DateTime targetTime, CancellationToken token)
    {
        var delay = targetTime - DateTime.Now;
        if (delay.TotalMilliseconds > 0)
        {
            try
            {
                await Task.Delay(delay, token);
            }
            catch (TaskCanceledException)
            {
                logger.LogWarning("Task cancelled");
                // ignore
            }
        }
    }

    private void InvokeSunsetEvent(string reason)
    {
        logger.LogInformation("EVENT: ZACHÓD SŁOŃCA ({reason})", reason);
        SafeInvoke(SunsetOccurred, EventArgs.Empty, "SunsetOccurred");
    }

    private void SafeInvoke(EventHandler? handler, EventArgs args, string eventName)
    {
        if (handler == null)
            return;

        var invocationList = handler.GetInvocationList();
        foreach (var @delegate in invocationList)
        {
            try
            {
                if (@delegate is EventHandler eventHandler)
                    eventHandler(this, args);
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Exception thrown by handler for {EventName}; continuing with other handlers", eventName);
            }
        }
    }
}

    public event EventHandler SunriseOccurred;
    public event EventHandler SunsetOccurred;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var sunriseTask = RunEventLoopAsync(
            "Wschód słońca",
            (calc, date) => calc.GetWarsawSunrise(date),
            reason => InvokeSunriseEvent(reason),
            stoppingToken);

        var sunsetTask = RunEventLoopAsync(
            "Zachód słońca",
            (calc, date) => calc.GetWarsawSunset(date),
            reason => InvokeSunsetEvent(reason),
            stoppingToken);

        await Task.WhenAll(sunriseTask, sunsetTask);

public class PinState(GpioPin pin, PinValue onClose, PinValue? value)
{
    public static PinState CreateState(GpioPin pin, PinValue onCloseValue, PinValue? value) =>
        new(pin, onCloseValue, value);

    public GpioPin Pin { get; set; } = pin;
    public PinValue OnCloseValue { get; set; } = onClose;
    public PinValue? Value { get; set; } = value;
}

public class GpioControllerWithPinRestore : GpioController, IDisposable
{
    private readonly ConcurrentDictionary<int, PinState?> _pins = [];
    private readonly ILogger<GpioControllerWithPinRestore>? _logger;

    public GpioControllerWithPinRestore(ILogger<GpioControllerWithPinRestore> logger) : base()
    {
        _logger = logger;
    }

    public GpioControllerWithPinRestore() : base()
    { }

    public GpioPin OpenPin(int pinNumber, PinMode mode, PinValue initialValue, PinValue onCloseValue)
    {
        var pin = base.OpenPin(pinNumber, mode, initialValue);
        _pins.TryAdd(pinNumber, PinState.CreateState(pin, onCloseValue, initialValue));
        return pin;
    }

    public new void Write(int pinNumber, PinValue value)
    {
        var isPinExisting = _pins.TryGetValue(pinNumber, out var pinState);
        if (isPinExisting)
        {
            pinState!.Value = value;
            _pins[pinNumber] = pinState;
        }
        base.Write(pinNumber, value);
    }

    // other commands omitted for brevity

    public new void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public new void Dispose(bool disposing)
    {
        foreach (var pin in _pins)
        {
            try
            {
                Write(pin.Key, pin.Value.OnCloseValue);
            }
            catch (Exception)
            {
                // ignore
            }
        }
        base.Dispose(disposing);
    }
}

internal class GpioWorker(
    ILogger<GpioWorker> logger,
    GpioControllerWithPinRestore gpioController,
    SolarNotifierService solarNotifier,
    AlarmClockService alarmClockService) : BackgroundService
{
    const int _pinChoinka= 26;
    const int _pinLevelConverter= 6;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        try
        {
            // subscribe to notifications and ensure level converter is enabled
            solarNotifier.SunsetOccurred += Choinka_OnEventOccurred;
            alarmClockService.Alarm2300Triggered += Choinka_OffEventOccurred;
       
            gpioController.OpenPin(_pinLevelConverter, PinMode.Output, PinValue.High, PinValue.Low);
            if (gpioController.Read(_pinLevelConverter) == PinValue.Low)
                gpioController.Write(_pinLevelConverter, PinValue.High);

            await Task.Delay(Timeout.Infinite, stoppingToken);
        }
        catch (OperationCanceledException)
        {
            logger.LogInformation("GpioWorker cancellation requested");
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Error initializing GpioWorker. In case of error 13, try to elevate privileges and run the application with 'sudo'.");
        }
    }

    public override Task StopAsync(CancellationToken cancellationToken)
    {
        logger.LogInformation("GpioWorker stopping, unsubscribing events and cleaning up pins");

        try
        {
            solarNotifier.SunsetOccurred -= Choinka_OnEventOccurred;
            alarmClockService.Alarm2300Triggered -= Choinka_OffEventOccurred;
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "Error while stopping GpioWorker");
        }

        return base.StopAsync(cancellationToken);
    }

    private void Choinka_OnEventOccurred(object? sender, EventArgs e)
    {
        if(!gpioController.IsPinOpen(_pinLevelConverter))
            gpioController.OpenPin(_pinLevelConverter, PinMode.Output, PinValue.High, PinValue.Low);

        if (gpioController.Read(_pinLevelConverter) == PinValue.Low)
            gpioController.Write(_pinLevelConverter, PinValue.High);

        if (!gpioController.IsPinOpen(_pinChoinka))
            gpioController.OpenPin(_pinChoinka, PinMode.Output, PinValue.Low, PinValue.Low);

        if (gpioController.Read(_pinChoinka) == PinValue.Low)
            gpioController.Write(_pinChoinka, PinValue.High);
    }

    private void Choinka_OffEventOccurred(object? sender, EventArgs e)
    {

        if (!gpioController.IsPinOpen(_pinChoinka))
            gpioController.OpenPin(_pinChoinka, PinMode.Output, PinValue.Low, PinValue.Low);
        else
            gpioController.Write(_pinChoinka, PinValue.Low);

        logger.LogInformation("Stan wyjścia: {StanChoinka}", gpioController.Read(_pinChoinka));
    }
}

    hostBuilder.ConfigureServices((ctx, services) =>
    {
        services.AddSingleton(sp => new Places());
        // sun time services
        services.AddSingleton(sp => new Places());
        services.AddScoped<ISolarCalculator, SolarCalculator>();
        services.AddSingleton<SolarNotifierService>();
        services.AddHostedService(sp => sp.GetRequiredService<SolarNotifierService>());
        // timed event service
        services.AddSingleton<AlarmClockService>();
        services.AddHostedService(sp => sp.GetRequiredService<AlarmClockService>());

        services.AddSingleton<GpioControllerWithPinRestore>();
        services.AddHostedService<GpioWorker>();
    });