using System;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using FrameworkBLL.GOP.Worker.NodeExecutors;
using FrameworkBLL.Promotion;
using FrameworkDAL.CustomCode.Promotion;
using FrameworkDAL.DTO.Promotion;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.DTO.GOP;
using GB5Shared.DTO.Promotion;
using GB5Shared.EventLogPublish;
using GB5Shared.Promotion;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using Xunit;

namespace FrameworkTests;

/// <summary>
/// Metadata Promotion's three GOP node executors (PromotionExport/Ingest/Import) have no live
/// database or cross-deployment dependency in isolation — IPromotableEntity/IPromotionAssetLinkDAL
/// are both mockable interfaces — so this covers the actual branching logic (validation blocks a
/// promotion, a dedup match is recognized as an update, an insert-vs-update decision is made
/// correctly) without needing a real database, matching FrameworkTests' existing "mock the
/// interfaces, exercise the real logic" convention (see TypeNormalizerTests/MetaReportBLLTests).
/// </summary>
public class PromotionNodeExecutorTests
{
    private static LoginDTO Login() => new() { ClientId = -1, UserId = 7 };

    private static GopFlowSnapshotStepDTO Step(string nodeType) => new()
    {
        NodeId = 1, NodeCode = "test-step", NodeType = nodeType, SnapshotVersion = "1"
    };

    private static GopExecutionHeaderDTO Header(int executionId = 100) => new()
    {
        ExecutionId = executionId, FlowId = 1, FlowCode = "TestFlow", SnapshotVersion = "1"
    };

    private static IServiceProvider ServiceProviderWith(string entityTypeCode, IPromotableEntity entity)
    {
        var services = new ServiceCollection();
        services.AddKeyedSingleton(entityTypeCode, entity);
        return services.BuildServiceProvider();
    }

    [Fact]
    public async Task Export_ValidationBlocked_ThrowsAndNeverReturnsABundle()
    {
        var promotionBll = new Mock<IPromotionBLL>();
        promotionBll.Setup(b => b.BuildExportBundleAsync("MENU", 42, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ThrowsAsync(new InvalidOperationException("Not promotable: references a client-only addon column"));

        var executor = new PromotionExportNodeExecutor(promotionBll.Object, NullLogger<PromotionExportNodeExecutor>.Instance);

        var inputJson = JsonSerializer.Serialize(new { EntityTypeCode = "MENU", OriginEntityId = 42 });

        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
            executor.ExecuteAsync(Step("PromotionExport"), Header(), inputJson, Login(), CancellationToken.None));

        Assert.Contains("addon", ex.Message);
    }

    [Fact]
    public async Task Export_Promotable_ReturnsSerializedBundle()
    {
        var promotionBll = new Mock<IPromotionBLL>();
        promotionBll.Setup(b => b.BuildExportBundleAsync("MENU", 42, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new PromotionBundleDTO
            {
                EntityTypeCode        = "MENU",
                OriginEntityId        = 42,
                OriginEnvironmentCode = "CLIENT-ACME"
            });

        var executor = new PromotionExportNodeExecutor(promotionBll.Object, NullLogger<PromotionExportNodeExecutor>.Instance);

        var inputJson = JsonSerializer.Serialize(new { EntityTypeCode = "MENU", OriginEntityId = 42 });
        var outputJson = await executor.ExecuteAsync(
            Step("PromotionExport"), Header(), inputJson, Login(), CancellationToken.None);

        var bundle = JsonSerializer.Deserialize<PromotionBundleDTO>(outputJson!)!;
        Assert.Equal("MENU", bundle.EntityTypeCode);
        Assert.Equal(42, bundle.OriginEntityId);
        Assert.Equal("CLIENT-ACME", bundle.OriginEnvironmentCode);
    }

    [Fact]
    public async Task Ingest_NoPriorLink_IsNotFlaggedAsUpdate()
    {
        var entity = new Mock<IPromotableEntity>();
        entity.Setup(e => e.ValidateForPromotionAsync(It.IsAny<PromotionBundleDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(PromotionValidationResultDTO.Ok());

        var assetLinkDal = new Mock<IPromotionAssetLinkDAL>();
        assetLinkDal.Setup(d => d.GetByOrigin("CLIENT-ACME", "MENU", 42, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync((PromotionAssetLinkDTO?)null);

        var config = new ConfigurationBuilder()
            .AddInMemoryCollection(new System.Collections.Generic.Dictionary<string, string?>
            {
                ["Promotion:OriginEnvironmentCode"] = "IMPSYS-PARTNERX"
            }).Build();

        var sp = ServiceProviderWith("MENU", entity.Object);
        var executor = new PromotionIngestNodeExecutor(
            sp, assetLinkDal.Object, config, NullLogger<PromotionIngestNodeExecutor>.Instance);

        var bundle = new PromotionBundleDTO { EntityTypeCode = "MENU", OriginEntityId = 42, OriginEnvironmentCode = "CLIENT-ACME" };
        var outputJson = await executor.ExecuteAsync(
            Step("PromotionIngest"), Header(), JsonSerializer.Serialize(bundle), Login(), CancellationToken.None);

        var result = JsonSerializer.Deserialize<PromotionIngestResultDTO>(outputJson!)!;
        Assert.False(result.IsUpdateToExistingAsset);
        Assert.Null(result.ExistingDestinationId);
    }

    [Fact]
    public async Task Ingest_PriorLinkExists_IsFlaggedAsUpdateWithExistingDestinationId()
    {
        var entity = new Mock<IPromotableEntity>();
        entity.Setup(e => e.ValidateForPromotionAsync(It.IsAny<PromotionBundleDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(PromotionValidationResultDTO.Ok());

        var assetLinkDal = new Mock<IPromotionAssetLinkDAL>();
        assetLinkDal.Setup(d => d.GetByOrigin("CLIENT-ACME", "MENU", 42, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new PromotionAssetLinkDTO { PromotionAssetLinkId = 9, DestinationEntityId = 501 });

        var config = new ConfigurationBuilder().Build();
        var sp = ServiceProviderWith("MENU", entity.Object);
        var executor = new PromotionIngestNodeExecutor(
            sp, assetLinkDal.Object, config, NullLogger<PromotionIngestNodeExecutor>.Instance);

        var bundle = new PromotionBundleDTO { EntityTypeCode = "MENU", OriginEntityId = 42, OriginEnvironmentCode = "CLIENT-ACME" };
        var outputJson = await executor.ExecuteAsync(
            Step("PromotionIngest"), Header(), JsonSerializer.Serialize(bundle), Login(), CancellationToken.None);

        var result = JsonSerializer.Deserialize<PromotionIngestResultDTO>(outputJson!)!;
        Assert.True(result.IsUpdateToExistingAsset);
        Assert.Equal(501, result.ExistingDestinationId);
    }

    [Fact]
    public async Task Import_MissingDestinationSourceTypeConfig_ThrowsBeforeCallingImport()
    {
        var entity = new Mock<IPromotableEntity>(MockBehavior.Strict);
        var assetLinkDal = new Mock<IPromotionAssetLinkDAL>(MockBehavior.Strict);
        var config = new ConfigurationBuilder().Build(); // Promotion:DestinationSourceType unset
        var eventLog = new EventLogPublish(new Dapr.Client.DaprClientBuilder().Build(), NullLogger<EventLogPublish>.Instance);

        var sp = ServiceProviderWith("MENU", entity.Object);
        var executor = new PromotionImportNodeExecutor(
            sp, assetLinkDal.Object, config, eventLog, NullLogger<PromotionImportNodeExecutor>.Instance);

        var ingestResult = new PromotionIngestResultDTO
        {
            Bundle = new PromotionBundleDTO { EntityTypeCode = "MENU", OriginEntityId = 42 }
        };

        await Assert.ThrowsAsync<InvalidOperationException>(() =>
            executor.ExecuteAsync(
                Step("PromotionImport"), Header(), JsonSerializer.Serialize(ingestResult), Login(), CancellationToken.None));

        // Strict mocks with zero setups — reaching either would have thrown a MockException instead,
        // proving Import never touches IPromotableEntity/IPromotionAssetLinkDAL when config is missing.
    }

    [Fact]
    public async Task Import_NewAsset_InsertsAssetLink()
    {
        var entity = new Mock<IPromotableEntity>();
        entity.Setup(e => e.ImportPromotedAsync(
                It.IsAny<PromotionBundleDTO>(), 3, null, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(777);

        var assetLinkDal = new Mock<IPromotionAssetLinkDAL>();
        assetLinkDal.Setup(d => d.Insert(It.IsAny<PromotionAssetLinkDTO>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        var config = new ConfigurationBuilder()
            .AddInMemoryCollection(new System.Collections.Generic.Dictionary<string, string?>
            {
                ["Promotion:DestinationSourceType"] = "3"
            }).Build();
        var eventLog = new EventLogPublish(new Dapr.Client.DaprClientBuilder().Build(), NullLogger<EventLogPublish>.Instance);

        var sp = ServiceProviderWith("MENU", entity.Object);
        var executor = new PromotionImportNodeExecutor(
            sp, assetLinkDal.Object, config, eventLog, NullLogger<PromotionImportNodeExecutor>.Instance);

        var ingestResult = new PromotionIngestResultDTO
        {
            Bundle = new PromotionBundleDTO { EntityTypeCode = "MENU", OriginEntityId = 42, OriginEnvironmentCode = "CLIENT-ACME" },
            ExistingDestinationId = null
        };

        var outputJson = await executor.ExecuteAsync(
            Step("PromotionImport"), Header(), JsonSerializer.Serialize(ingestResult), Login(), CancellationToken.None);

        Assert.Contains("777", outputJson);
        assetLinkDal.Verify(d => d.Insert(
            It.Is<PromotionAssetLinkDTO>(l => l.DestinationEntityId == 777 && l.OriginEntityId == 42),
            It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Once);
        assetLinkDal.Verify(d => d.UpdateAfterPromotion(
            It.IsAny<PromotionAssetLinkDTO>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Never);
    }

    [Fact]
    public async Task Import_ExistingAsset_UpdatesRatherThanInserts()
    {
        var entity = new Mock<IPromotableEntity>();
        entity.Setup(e => e.ImportPromotedAsync(
                It.IsAny<PromotionBundleDTO>(), 3, 501, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(501); // update path returns the same destination id

        var assetLinkDal = new Mock<IPromotionAssetLinkDAL>();
        assetLinkDal.Setup(d => d.GetByOrigin("CLIENT-ACME", "MENU", 42, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new PromotionAssetLinkDTO { PromotionAssetLinkId = 9, DestinationEntityId = 501 });

        var config = new ConfigurationBuilder()
            .AddInMemoryCollection(new System.Collections.Generic.Dictionary<string, string?>
            {
                ["Promotion:DestinationSourceType"] = "3"
            }).Build();
        var eventLog = new EventLogPublish(new Dapr.Client.DaprClientBuilder().Build(), NullLogger<EventLogPublish>.Instance);

        var sp = ServiceProviderWith("MENU", entity.Object);
        var executor = new PromotionImportNodeExecutor(
            sp, assetLinkDal.Object, config, eventLog, NullLogger<PromotionImportNodeExecutor>.Instance);

        var ingestResult = new PromotionIngestResultDTO
        {
            Bundle = new PromotionBundleDTO { EntityTypeCode = "MENU", OriginEntityId = 42, OriginEnvironmentCode = "CLIENT-ACME" },
            ExistingDestinationId = 501
        };

        await executor.ExecuteAsync(
            Step("PromotionImport"), Header(), JsonSerializer.Serialize(ingestResult), Login(), CancellationToken.None);

        assetLinkDal.Verify(d => d.UpdateAfterPromotion(
            It.Is<PromotionAssetLinkDTO>(l => l.PromotionAssetLinkId == 9 && l.DestinationEntityId == 501),
            It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Once);
        assetLinkDal.Verify(d => d.Insert(
            It.IsAny<PromotionAssetLinkDTO>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Never);
    }
}