using Omika.Core.Compatibility;
using Omika.Core.Runtime;

namespace Omika.Tests;

[Collection("ApplicationRuntimeContext")]
public class ApplicationRuntimeContextTests
{

    [Fact]
    public void Parse_Auto_IsRecognized()
    {
        var result = DatabaseSchemaSelectionParser.Parse("Auto");

        Assert.True(result.IsSuccess);
        Assert.Equal(DatabaseSchemaSelection.Auto, result.Value);
    }

    [Fact]
    public void Parse_Batik_IsRecognized()
    {
        var result = DatabaseSchemaSelectionParser.Parse("Batik");

        Assert.True(result.IsSuccess);
        Assert.Equal(DatabaseSchemaSelection.Batik, result.Value);
    }

    [Fact]
    public void Parse_Omika_IsRecognized()
    {
        var result = DatabaseSchemaSelectionParser.Parse("Omika");

        Assert.True(result.IsSuccess);
        Assert.Equal(DatabaseSchemaSelection.Omika, result.Value);
    }

    [Theory]
    [InlineData("auto")]
    [InlineData("AUTO")]
    [InlineData("batik")]
    [InlineData("Batik")]
    [InlineData("BATIK")]
    [InlineData("  Omika  ")]
    [InlineData("omika")]
    [InlineData("OMIKA")]
    public void Parse_IsCaseAndWhitespaceInsensitive(string value)
    {
        var result = DatabaseSchemaSelectionParser.Parse(value);

        Assert.True(result.IsSuccess);
    }

    [Fact]
    public void Parse_UnknownValue_ReturnsClearError()
    {
        var result = DatabaseSchemaSelectionParser.Parse("2024");

        Assert.True(result.IsFailure);
        var error = Assert.Single(result.Errors);
        Assert.Contains("2024", error, StringComparison.OrdinalIgnoreCase);
        Assert.Contains(nameof(DatabaseSchemaSelection.Auto), error, StringComparison.Ordinal);
        Assert.Contains(nameof(DatabaseSchemaSelection.Batik), error, StringComparison.Ordinal);
        Assert.Contains(nameof(DatabaseSchemaSelection.Omika), error, StringComparison.Ordinal);
    }

    [Fact]
    public void Parse_NullOrEmpty_ReturnsClearError()
    {
        var result = DatabaseSchemaSelectionParser.Parse(null);

        Assert.True(result.IsFailure);
        Assert.NotEmpty(result.Errors);
    }

    [Fact]
    public void TryParse_KnownValue_ReturnsTrue()
    {
        var ok = DatabaseSchemaSelectionParser.TryParse("Batik", out var selection);

        Assert.True(ok);
        Assert.Equal(DatabaseSchemaSelection.Batik, selection);
    }

    [Fact]
    public void TryParse_UnknownValue_ReturnsFalse()
    {
        var ok = DatabaseSchemaSelectionParser.TryParse("inconnu", out _);

        Assert.False(ok);
    }

    [Fact]
    public void Configure_UnknownValue_ThrowsClearError()
    {
        ApplicationRuntimeContext.Reset();

        var ex = Assert.Throws<InvalidOperationException>(() => ApplicationRuntimeContext.Configure("inconnu"));

        Assert.Contains("inconnu", ex.Message, StringComparison.OrdinalIgnoreCase);
        Assert.Contains(ApplicationRuntimeContext.ConfigurationKey, ex.Message, StringComparison.Ordinal);
    }

    [Fact]
    public void Configure_ForcedSelection_WithoutDetection_IsNotActive()
    {
        ApplicationRuntimeContext.Reset();

        ApplicationRuntimeContext.Configure(DatabaseSchemaSelection.Omika);

        Assert.True(ApplicationRuntimeContext.IsConfigured);
        Assert.Equal(DatabaseSchemaSelection.Omika, ApplicationRuntimeContext.Current.Selection);
        Assert.Equal(DatabaseSchemaVersion.Unknown, ApplicationRuntimeContext.Current.DetectedVersion);
        Assert.False(ApplicationRuntimeContext.Current.IsOmika);
        Assert.False(ApplicationRuntimeContext.Current.IsBatik);
    }

    [Fact]
    public void Configure_Auto_WithoutDetection_IsUnknown()
    {
        ApplicationRuntimeContext.Reset();

        ApplicationRuntimeContext.Configure(DatabaseSchemaSelection.Auto);

        Assert.True(ApplicationRuntimeContext.IsConfigured);
        Assert.Equal(DatabaseSchemaVersion.Unknown, ApplicationRuntimeContext.Current.DetectedVersion);
        Assert.False(ApplicationRuntimeContext.Current.IsBatik);
        Assert.False(ApplicationRuntimeContext.Current.IsOmika);
    }

    [Fact]
    public void Configure_Auto_WithDetectedOmika_IsOmika()
    {
        ApplicationRuntimeContext.Reset();

        ApplicationRuntimeContext.Configure(DatabaseSchemaSelection.Auto);
        var result = ApplicationRuntimeContext.SetDetectedVersion(DatabaseSchemaVersion.Omika);

        Assert.True(result.IsSuccess);
        Assert.True(ApplicationRuntimeContext.Current.IsOmika);
        Assert.False(ApplicationRuntimeContext.Current.IsBatik);
        Assert.Equal(DatabaseSchemaVersion.Omika, ApplicationRuntimeContext.Current.DetectedVersion);
    }

    [Fact]
    public void Configure_Auto_WithDetectedBatik_IsBatik()
    {
        ApplicationRuntimeContext.Reset();

        ApplicationRuntimeContext.Configure(DatabaseSchemaSelection.Auto);
        var result = ApplicationRuntimeContext.SetDetectedVersion(DatabaseSchemaVersion.Batik);

        Assert.True(result.IsSuccess);
        Assert.True(ApplicationRuntimeContext.Current.IsBatik);
        Assert.False(ApplicationRuntimeContext.Current.IsOmika);
        Assert.Equal(DatabaseSchemaVersion.Batik, ApplicationRuntimeContext.Current.DetectedVersion);
    }

    [Fact]
    public void Configure_ForcedOmika_WithDetectedOmika_IsOmika()
    {
        ApplicationRuntimeContext.Reset();

        ApplicationRuntimeContext.Configure(DatabaseSchemaSelection.Omika);
        var result = ApplicationRuntimeContext.SetDetectedVersion(DatabaseSchemaVersion.Omika);

        Assert.True(result.IsSuccess);
        Assert.True(ApplicationRuntimeContext.Current.IsOmika);
        Assert.Equal(DatabaseSchemaVersion.Omika, ApplicationRuntimeContext.Current.DetectedVersion);
    }

    [Fact]
    public void Configure_ForcedBatik_WithDetectedBatik_IsBatik()
    {
        ApplicationRuntimeContext.Reset();

        ApplicationRuntimeContext.Configure(DatabaseSchemaSelection.Batik);
        var result = ApplicationRuntimeContext.SetDetectedVersion(DatabaseSchemaVersion.Batik);

        Assert.True(result.IsSuccess);
        Assert.True(ApplicationRuntimeContext.Current.IsBatik);
        Assert.Equal(DatabaseSchemaVersion.Batik, ApplicationRuntimeContext.Current.DetectedVersion);
    }

    [Fact]
    public void Configure_ForcedOmika_WithDetectedBatik_ReturnsFailureAndKeepsUnknown()
    {
        ApplicationRuntimeContext.Reset();

        ApplicationRuntimeContext.Configure(DatabaseSchemaSelection.Omika);
        var result = ApplicationRuntimeContext.SetDetectedVersion(DatabaseSchemaVersion.Batik);

        Assert.True(result.IsFailure);
        Assert.NotEmpty(result.Errors);
        Assert.Equal(DatabaseSchemaVersion.Unknown, ApplicationRuntimeContext.Current.DetectedVersion);
        Assert.False(ApplicationRuntimeContext.Current.IsOmika);
        Assert.False(ApplicationRuntimeContext.Current.IsBatik);
    }

    [Fact]
    public void Configure_ForcedBatik_WithDetectedOmika_ReturnsFailureAndKeepsUnknown()
    {
        ApplicationRuntimeContext.Reset();

        ApplicationRuntimeContext.Configure(DatabaseSchemaSelection.Batik);
        var result = ApplicationRuntimeContext.SetDetectedVersion(DatabaseSchemaVersion.Omika);

        Assert.True(result.IsFailure);
        Assert.NotEmpty(result.Errors);
        Assert.Equal(DatabaseSchemaVersion.Unknown, ApplicationRuntimeContext.Current.DetectedVersion);
        Assert.False(ApplicationRuntimeContext.Current.IsOmika);
        Assert.False(ApplicationRuntimeContext.Current.IsBatik);
    }

    [Fact]
    public void SetDetectedVersion_UnknownVersion_ReturnsFailure()
    {
        ApplicationRuntimeContext.Reset();

        ApplicationRuntimeContext.Configure(DatabaseSchemaSelection.Auto);
        var result = ApplicationRuntimeContext.SetDetectedVersion(DatabaseSchemaVersion.Unknown);

        Assert.True(result.IsFailure);
        Assert.NotEmpty(result.Errors);
    }

    [Fact]
    public void ValidateDetectedVersion_ForcedSelection_Mismatch_ReturnsFailure()
    {
        ApplicationRuntimeContext.Reset();

        ApplicationRuntimeContext.Configure(DatabaseSchemaSelection.Omika);
        var result = ApplicationRuntimeContext.Current.ValidateDetectedVersion(DatabaseSchemaVersion.Batik);

        Assert.True(result.IsFailure);
        var error = Assert.Single(result.Errors);
        Assert.Contains(nameof(DatabaseSchemaSelection.Omika), error, StringComparison.Ordinal);
        Assert.Contains(nameof(DatabaseSchemaVersion.Batik), error, StringComparison.Ordinal);
    }

    [Fact]
    public void FromConfiguration_ReturnsContextWithParsedSelection()
    {
        var result = ApplicationRuntimeContext.FromConfiguration("Batik");

        Assert.True(result.IsSuccess);
        Assert.Equal(DatabaseSchemaSelection.Batik, result.Value.Selection);
        Assert.Equal(DatabaseSchemaVersion.Unknown, result.Value.DetectedVersion);
        Assert.False(result.Value.IsBatik);
        Assert.False(result.Value.IsOmika);
    }

    [Fact]
    public void FromConfiguration_UnknownValue_ReturnsFailure()
    {
        var result = ApplicationRuntimeContext.FromConfiguration("n'importe quoi");

        Assert.True(result.IsFailure);
        Assert.NotEmpty(result.Errors);
    }

    [Fact]
    public void Current_WithoutConfiguration_ThrowsClearError()
    {
        ApplicationRuntimeContext.Reset();

        var ex = Assert.Throws<InvalidOperationException>(() => _ = ApplicationRuntimeContext.Current);

        Assert.Contains(nameof(ApplicationRuntimeContext.Configure), ex.Message, StringComparison.Ordinal);
    }
}