using Microsoft.Extensions.Logging.Abstractions;
using ZB.MOM.WW.ScadaBridge.SiteRuntime.Persistence;
using ZB.MOM.WW.ScadaBridge.SiteRuntime.Repositories;

namespace ZB.MOM.WW.ScadaBridge.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);
    }

    // ── ExternalSystemGateway-011: name-keyed repository lookups ──

    /// <summary>
    /// ExternalSystemGateway-011: the site repository's name-keyed external-system
    /// lookup returns the matching row, and the same synthetic ID as the by-ID path.
    /// </summary>
    [Fact]
    public async Task ExternalSystemRepository_GetByName_ReturnsMatchingDefinition()
    {
        var storage = NewStorage();
        await storage.InitializeAsync();
        await storage.StoreExternalSystemAsync(
            "Alpha", "https://alpha.test", "ApiKey", "{\"key\":\"x\"}", null);
        await storage.StoreExternalSystemAsync(
            "Beta", "https://beta.test", "Basic", null, null);

        var repo = new SiteExternalSystemRepository(storage);

        var found = await repo.GetExternalSystemByNameAsync("Beta");
        Assert.NotNull(found);
        Assert.Equal("Beta", found!.Name);
        Assert.Equal("https://beta.test", found.EndpointUrl);

        // The by-name path must produce the same synthetic ID as the by-id path.
        var byId = await repo.GetExternalSystemByIdAsync(found.Id);
        Assert.NotNull(byId);
        Assert.Equal("Beta", byId!.Name);
    }

    /// <summary>
    /// ExternalSystemGateway-011: a missing name resolves to <c>null</c>.
    /// </summary>
    [Fact]
    public async Task ExternalSystemRepository_GetByName_MissingName_ReturnsNull()
    {
        var storage = NewStorage();
        await storage.InitializeAsync();
        await storage.StoreExternalSystemAsync(
            "Alpha", "https://alpha.test", "ApiKey", null, null);

        var repo = new SiteExternalSystemRepository(storage);

        Assert.Null(await repo.GetExternalSystemByNameAsync("DoesNotExist"));
    }

    /// <summary>
    /// ExternalSystemGateway-011: the site repository's name-keyed method lookup
    /// returns the method scoped to its parent system, or <c>null</c> for a miss.
    /// </summary>
    [Fact]
    public async Task ExternalSystemRepository_GetMethodByName_ResolvesScopedToSystem()
    {
        var storage = NewStorage();
        await storage.InitializeAsync();
        var methodDefs = "[{\"Name\":\"getData\",\"HttpMethod\":\"GET\",\"Path\":\"/data\"}]";
        await storage.StoreExternalSystemAsync(
            "WeatherApi", "https://api.example.com", "ApiKey", null, methodDefs);

        var repo = new SiteExternalSystemRepository(storage);
        var system = await repo.GetExternalSystemByNameAsync("WeatherApi");
        Assert.NotNull(system);

        var method = await repo.GetMethodByNameAsync(system!.Id, "getData");
        Assert.NotNull(method);
        Assert.Equal("getData", method!.Name);
        Assert.Equal("GET", method.HttpMethod);

        Assert.Null(await repo.GetMethodByNameAsync(system.Id, "noSuchMethod"));
    }

    /// <summary>
    /// ExternalSystemGateway-011: the site repository's name-keyed database-connection
    /// lookup returns the matching row, or <c>null</c> for a miss.
    /// </summary>
    [Fact]
    public async Task DatabaseConnectionRepository_GetByName_ReturnsMatchingDefinition()
    {
        var storage = NewStorage();
        await storage.InitializeAsync();
        await storage.StoreDatabaseConnectionAsync(
            "Plant", "Server=plant;Database=p;", maxRetries: 3, retryDelay: TimeSpan.FromSeconds(2));
        await storage.StoreDatabaseConnectionAsync(
            "Historian", "Server=hist;Database=h;", maxRetries: 0, retryDelay: TimeSpan.FromSeconds(5));

        var repo = new SiteExternalSystemRepository(storage);

        var found = await repo.GetDatabaseConnectionByNameAsync("Historian");
        Assert.NotNull(found);
        Assert.Equal("Historian", found!.Name);
        Assert.Equal("Server=hist;Database=h;", found.ConnectionString);
        Assert.Equal(0, found.MaxRetries);

        Assert.Null(await repo.GetDatabaseConnectionByNameAsync("DoesNotExist"));
    }

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