using Microsoft.Extensions.Logging.Abstractions;
using ScadaLink.SiteRuntime.Persistence;
using ScadaLink.SiteRuntime.Repositories;

namespace ScadaLink.SiteRuntime.Tests.Repositories;

/// <summary>
/// SiteRuntime-006 / SiteRuntime-007 regression tests for the site-local repositories.
///
/// SiteRuntime-006: the repositories must obtain a SQLite connection through
/// <see cref="SiteStorageService.CreateConnection"/>, not by reading a private field
/// via reflection.
///
/// SiteRuntime-007: the synthetic integer IDs derived from entity names must be stable
/// across process restarts (a freshly-constructed service/repository), so an ID handed
/// to a caller still resolves the same entity later.
/// </summary>
public class SiteRepositoryTests : IDisposable
{
    private readonly string _dbFile;

    public SiteRepositoryTests()
    {
        _dbFile = Path.Combine(Path.GetTempPath(), $"site-repo-test-{Guid.NewGuid():N}.db");
    }

    public void Dispose()
    {
        try { File.Delete(_dbFile); } catch { /* cleanup */ }
        GC.SuppressFinalize(this);
    }

    private SiteStorageService NewStorage()
        => new($"Data Source={_dbFile}", NullLogger<SiteStorageService>.Instance);

    /// <summary>
    /// SiteRuntime-006: an external system stored via <see cref="SiteStorageService"/>
    /// can be read back through the repository — proving the repository's connection
    /// (now obtained from <see cref="SiteStorageService.CreateConnection"/>) is valid.
    /// </summary>
    [Fact]
    public async Task ExternalSystemRepository_RoundTripsStoredDefinition()
    {
        var storage = NewStorage();
        await storage.InitializeAsync();
        await storage.StoreExternalSystemAsync(
            "WeatherApi", "https://api.example.com", "ApiKey", "{\"key\":\"x\"}", null);

        var repo = new SiteExternalSystemRepository(storage);
        var all = await repo.GetAllExternalSystemsAsync();

        Assert.Single(all);
        Assert.Equal("WeatherApi", all[0].Name);
        Assert.Equal("https://api.example.com", all[0].EndpointUrl);
    }

    /// <summary>
    /// SiteRuntime-007: the synthetic ID for an external system must be identical when
    /// the storage service and repository are re-created (simulating a process restart).
    /// With the old <see cref="string.GetHashCode()"/> the ID was randomized per process
    /// and a by-ID lookup after a restart would fail.
    /// </summary>
    [Fact]
    public async Task ExternalSystemRepository_SyntheticId_IsStableAcrossRestart()
    {
        var storage1 = NewStorage();
        await storage1.InitializeAsync();
        await storage1.StoreExternalSystemAsync(
            "StableSystem", "https://x", "None", null, null);

        var repo1 = new SiteExternalSystemRepository(storage1);
        var idBeforeRestart = (await repo1.GetAllExternalSystemsAsync())[0].Id;

        // Simulate a process restart — brand-new service + repository instances.
        var storage2 = NewStorage();
        var repo2 = new SiteExternalSystemRepository(storage2);
        var idAfterRestart = (await repo2.GetAllExternalSystemsAsync())[0].Id;

        Assert.Equal(idBeforeRestart, idAfterRestart);

        // And the by-ID lookup must succeed using the pre-restart ID.
        var found = await repo2.GetExternalSystemByIdAsync(idBeforeRestart);
        Assert.NotNull(found);
        Assert.Equal("StableSystem", found.Name);
    }

    /// <summary>
    /// SiteRuntime-007: the same stability guarantee for notification lists.
    /// </summary>
    [Fact]
    public async Task NotificationRepository_SyntheticId_IsStableAcrossRestart()
    {
        var storage1 = NewStorage();
        await storage1.InitializeAsync();
        await storage1.StoreNotificationListAsync(
            "OnCall", new[] { "a@example.com", "b@example.com" });

        var repo1 = new SiteNotificationRepository(storage1);
        var idBeforeRestart = (await repo1.GetAllNotificationListsAsync())[0].Id;

        var storage2 = NewStorage();
        var repo2 = new SiteNotificationRepository(storage2);
        var found = await repo2.GetNotificationListByIdAsync(idBeforeRestart);

        Assert.NotNull(found);
        Assert.Equal("OnCall", found.Name);
    }
}