using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using FrameworkBLL.GOP;
using FrameworkBLL.Promotion;
using FrameworkSL.Controllers.Promotion;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.DTO.GOP;
using GB5Shared.DTO.Promotion;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using Quartz;
using Xunit;

namespace FrameworkTests;

/// <summary>
/// PromotionExchangeIngestQuartzJob is the Tier 2 (Exchange) destination-side poller — these
/// tests cover its per-item isolation (one bad package/bundle never stops the rest of the batch)
/// and that it replicates the exact same OpenPackageAsync -> SubmitExecution("PromotionIngest")
/// sequence ImportPromotionPackageService already runs for a manually uploaded Tier 1 file.
/// </summary>
public class PromotionExchangeIngestQuartzJobTests
{
    private static Mock<IJobExecutionContext> FakeContext()
    {
        var ctx = new Mock<IJobExecutionContext>();
        ctx.Setup(c => c.CancellationToken).Returns(CancellationToken.None);
        return ctx;
    }

    private static PromotionExchangeIngestQuartzJob NewJob(
        Mock<IPromotionExchangeClient> exchange, Mock<IPromotionBLL> promotion, Mock<IGopQueueBLL> gop,
        LoginDTO? systemLogin = null)
    {
        var systemContext = new Mock<IPromotionSystemContext>();
        systemContext.Setup(c => c.GetSystemLogin()).Returns(systemLogin ?? new LoginDTO { ClientId = -1, DatabaseName = "GB5DEMO" });

        return new PromotionExchangeIngestQuartzJob(
            exchange.Object, promotion.Object, gop.Object, systemContext.Object,
            NullLogger<PromotionExchangeIngestQuartzJob>.Instance);
    }

    [Fact]
    public async Task Execute_NoPendingPackages_NeverCallsDownloadOrSubmit()
    {
        var exchange = new Mock<IPromotionExchangeClient>();
        exchange.Setup(e => e.ListPendingAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(Array.Empty<PromotionExchangePendingPackageDTO>());
        var promotion = new Mock<IPromotionBLL>();
        var gop = new Mock<IGopQueueBLL>();

        await NewJob(exchange, promotion, gop).Execute(FakeContext().Object);

        exchange.Verify(e => e.DownloadAsync(It.IsAny<int>(), It.IsAny<CancellationToken>()), Times.Never);
        gop.Verify(g => g.SubmitExecution(It.IsAny<GopSubmitRequestDTO>(), It.IsAny<LoginDTO>()), Times.Never);
    }

    [Fact]
    public async Task Execute_OnePendingPackage_DownloadsOpensAndSubmitsOnePerBundle()
    {
        var exchange = new Mock<IPromotionExchangeClient>();
        exchange.Setup(e => e.ListPendingAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<PromotionExchangePendingPackageDTO> { new() { PackageId = 5, OriginEnvironmentCode = "ORIGIN1" } });
        exchange.Setup(e => e.DownloadAsync(5, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new byte[] { 1, 2, 3 });

        var promotion = new Mock<IPromotionBLL>();
        promotion.Setup(p => p.OpenPackageAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new PromotionPackageManifestDTO
            {
                Items = new List<PromotionBundleDTO>
                {
                    new() { EntityTypeCode = "MENU", OriginEntityId = 1 },
                    new() { EntityTypeCode = "REPORTVIEW", OriginEntityId = 2 }
                }
            });

        var gop = new Mock<IGopQueueBLL>();
        gop.Setup(g => g.SubmitExecution(It.IsAny<GopSubmitRequestDTO>(), It.IsAny<LoginDTO>()))
            .ReturnsAsync(new GopSubmitResponseDTO { ExecutionId = 1 });

        var systemLogin = new LoginDTO { ClientId = -1, DatabaseName = "GB5DEMO" };
        await NewJob(exchange, promotion, gop, systemLogin).Execute(FakeContext().Object);

        gop.Verify(g => g.SubmitExecution(
            It.Is<GopSubmitRequestDTO>(r => r.SourceCode == "PromotionIngest"), systemLogin), Times.Exactly(2));
    }

    [Fact]
    public async Task Execute_DownloadReturnsNull_SkipsThatPackageWithoutThrowing()
    {
        var exchange = new Mock<IPromotionExchangeClient>();
        exchange.Setup(e => e.ListPendingAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<PromotionExchangePendingPackageDTO> { new() { PackageId = 5 } });
        exchange.Setup(e => e.DownloadAsync(5, It.IsAny<CancellationToken>()))
            .ReturnsAsync((byte[]?)null);

        var promotion = new Mock<IPromotionBLL>();
        var gop = new Mock<IGopQueueBLL>();

        await NewJob(exchange, promotion, gop).Execute(FakeContext().Object);

        promotion.Verify(p => p.OpenPackageAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()), Times.Never);
        gop.Verify(g => g.SubmitExecution(It.IsAny<GopSubmitRequestDTO>(), It.IsAny<LoginDTO>()), Times.Never);
    }

    [Fact]
    public async Task Execute_OnePackageThrowsWhileOpening_OtherPackageStillProcessed()
    {
        var exchange = new Mock<IPromotionExchangeClient>();
        exchange.Setup(e => e.ListPendingAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<PromotionExchangePendingPackageDTO>
            {
                new() { PackageId = 1 },
                new() { PackageId = 2 }
            });
        exchange.Setup(e => e.DownloadAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(new byte[] { 9 });
        exchange.Setup(e => e.DownloadAsync(2, It.IsAny<CancellationToken>())).ReturnsAsync(new byte[] { 8 });

        var promotion = new Mock<IPromotionBLL>();
        promotion.Setup(p => p.OpenPackageAsync(It.Is<byte[]>(b => b[0] == 9), It.IsAny<CancellationToken>()))
            .ThrowsAsync(new InvalidOperationException("corrupt package"));
        promotion.Setup(p => p.OpenPackageAsync(It.Is<byte[]>(b => b[0] == 8), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new PromotionPackageManifestDTO
            {
                Items = new List<PromotionBundleDTO> { new() { EntityTypeCode = "MENU", OriginEntityId = 3 } }
            });

        var gop = new Mock<IGopQueueBLL>();
        gop.Setup(g => g.SubmitExecution(It.IsAny<GopSubmitRequestDTO>(), It.IsAny<LoginDTO>()))
            .ReturnsAsync(new GopSubmitResponseDTO { ExecutionId = 1 });

        // Must not throw out of Execute even though package 1 fails mid-processing.
        await NewJob(exchange, promotion, gop).Execute(FakeContext().Object);

        gop.Verify(g => g.SubmitExecution(It.IsAny<GopSubmitRequestDTO>(), It.IsAny<LoginDTO>()), Times.Once);
    }

    [Fact]
    public async Task Execute_OneBundleSubmitFails_OtherBundleInSamePackageStillSubmitted()
    {
        var exchange = new Mock<IPromotionExchangeClient>();
        exchange.Setup(e => e.ListPendingAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(new List<PromotionExchangePendingPackageDTO> { new() { PackageId = 1 } });
        exchange.Setup(e => e.DownloadAsync(1, It.IsAny<CancellationToken>())).ReturnsAsync(new byte[] { 1 });

        var promotion = new Mock<IPromotionBLL>();
        promotion.Setup(p => p.OpenPackageAsync(It.IsAny<byte[]>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new PromotionPackageManifestDTO
            {
                Items = new List<PromotionBundleDTO>
                {
                    new() { EntityTypeCode = "MENU", OriginEntityId = 1 },
                    new() { EntityTypeCode = "REPORTVIEW", OriginEntityId = 2 }
                }
            });

        var gop = new Mock<IGopQueueBLL>();
        gop.Setup(g => g.SubmitExecution(It.Is<GopSubmitRequestDTO>(r => r.PayloadJson.Contains("\"MENU\"")), It.IsAny<LoginDTO>()))
            .ThrowsAsync(new InvalidOperationException("GOP unavailable"));
        gop.Setup(g => g.SubmitExecution(It.Is<GopSubmitRequestDTO>(r => r.PayloadJson.Contains("REPORTVIEW")), It.IsAny<LoginDTO>()))
            .ReturnsAsync(new GopSubmitResponseDTO { ExecutionId = 2 });

        await NewJob(exchange, promotion, gop).Execute(FakeContext().Object);

        gop.Verify(g => g.SubmitExecution(It.IsAny<GopSubmitRequestDTO>(), It.IsAny<LoginDTO>()), Times.Exactly(2));
    }
}