using GB5Shared.DTO.Framework.Login;
using GB5Shared.EventLogPublish;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using SwBLL.ChangeRequest;
using SwBLL.ClientDatabase;
using SwBLL.DbServer;
using SwBLL.DdlScript;
using SwBLL.Provisioning;
using SwBLL.UserResourceRole;
using SwDAL.CustomCode.ChangeRequest;
using SwDAL.DTO.ChangeRequest;
using SwDAL.DTO.ClientDatabase;
using SwDAL.DTO.DbServer;
using SwDAL.DTO.DdlScript;
using SwDAL.Enums;
using Xunit;

namespace SwTests;

/// <summary>
/// Covers ChangeRequestBLL.Execute()'s new ClientProvisioning pre-step — the branch that creates
/// the physical database (via IClientDatabaseProvisioner) before falling through to the existing,
/// unmodified DDL-execution path. Every case here mocks IClientDatabaseProvisioner directly, so
/// none of these tests touch a real database or Vault — they only prove Execute() picks the right
/// provisioner method for the CR's ProvisioningMode and validates the required fields first.
/// </summary>
public class ChangeRequestBLLProvisioningTests
{
    private static (ChangeRequestBLL Svc, Mock<IChangeRequestDAL> Dal, Mock<IClientDatabaseBLL> ClientDatabaseBLL,
        Mock<IClientDatabaseProvisioner> Provisioner) BuildService()
    {
        var dal               = new Mock<IChangeRequestDAL>();
        var clientDatabaseBLL = new Mock<IClientDatabaseBLL>();
        var dbServerBLL       = new Mock<IDbServerBLL>();
        var targetDbExecutor  = new Mock<ITargetDbExecutor>();
        var ddlScriptBLL      = new Mock<IDdlScriptBLL>();
        var provisioner       = new Mock<IClientDatabaseProvisioner>();

        dal.Setup(d => d.GetLinkedApprovedDdlScripts(It.IsAny<int>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
           .ReturnsAsync(Enumerable.Empty<DdlScriptDTO>());
        dal.Setup(d => d.UpdateStatus(It.IsAny<int>(), It.IsAny<byte>(), It.IsAny<byte>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
           .Returns(Task.CompletedTask);
        dal.Setup(d => d.AppendTimeline(It.IsAny<int>(), It.IsAny<CrTimelineEventType>(), It.IsAny<string?>(), It.IsAny<int>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
           .Returns(Task.CompletedTask);

        clientDatabaseBLL.Setup(c => c.GetById(It.IsAny<int>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new ClientDatabaseDTO { ClientDbId = 5, ClientDbCode = "acme01", DatabaseName = "acme01", DbServerId = 1, DatabaseRole = 0 });
        clientDatabaseBLL.Setup(c => c.UpdateStatusAsync(It.IsAny<int>(), It.IsAny<byte>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync("updated");

        dbServerBLL.Setup(d => d.GetByIdWithCredentials(It.IsAny<int>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .ReturnsAsync(new DbServerDTO { DbServerId = 1, DbType = 0, HostName = "sql01" });

        targetDbExecutor.Setup(t => t.BuildConnectionString(It.IsAny<DbServerDTO>(), It.IsAny<string>()))
            .Returns("conn-str");

        provisioner.Setup(p => p.CreateFromSnapshotAsync(It.IsAny<ClientDatabaseDTO>(), It.IsAny<DbServerDTO>(), It.IsAny<string>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .Returns(Task.CompletedTask);
        provisioner.Setup(p => p.CreateFromScriptsAsync(It.IsAny<ClientDatabaseDTO>(), It.IsAny<DbServerDTO>(), It.IsAny<int>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
            .Returns(Task.CompletedTask);

        // EventLogPublish.PublishEventLogAsync catches and logs every exception internally
        // (never throws) — a null DaprClient is a safe test double here, it just makes the
        // publish attempt fail silently (logged as a warning), exactly like a real Dapr sidecar
        // being unreachable would in production. None of these tests assert on the publish itself.
        var eventLogPublish = new EventLogPublish(null!, NullLogger<EventLogPublish>.Instance);

        var svc = new ChangeRequestBLL(
            dal.Object, clientDatabaseBLL.Object, dbServerBLL.Object, targetDbExecutor.Object,
            ddlScriptBLL.Object, provisioner.Object, new Mock<IUserResourceRoleBLL>().Object,
            eventLogPublish, NullLogger<ChangeRequestBLL>.Instance);

        return (svc, dal, clientDatabaseBLL, provisioner);
    }

    private static ChangeRequestDTO ApprovedProvisioningCr(
        ProvisioningMode? mode = null, string? templateBackupRef = null, int? baselinePackageId = null) => new()
    {
        ChangeRequestId          = 100,
        ClientDatabaseId         = 5,
        CrStatus                 = ChangeRequestStatus.Approved,
        Category                 = ChangeRequestCategory.ClientProvisioning,
        QueryType                = ChangeRequestQueryType.Other,
        ProvisioningMode         = mode,
        TemplateBackupRef        = templateBackupRef,
        BaselineUpgradePackageId = baselinePackageId
    };

    private static LoginDTO TestLogin() => new() { ClientId = 42, UserId = -1 };

    [Fact]
    public async Task Test_Execute_ClientProvisioning_MissingProvisioningMode_Throws()
    {
        var (svc, dal, _, provisioner) = BuildService();
        var cr = ApprovedProvisioningCr(mode: null);
        dal.Setup(d => d.GetById(cr.ChangeRequestId, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>())).ReturnsAsync(cr);

        await Assert.ThrowsAsync<InvalidOperationException>(() =>
            svc.Execute(cr.ChangeRequestId, TestLogin(), CancellationToken.None));

        provisioner.Verify(p => p.CreateFromSnapshotAsync(It.IsAny<ClientDatabaseDTO>(), It.IsAny<DbServerDTO>(), It.IsAny<string>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Never);
        provisioner.Verify(p => p.CreateFromScriptsAsync(It.IsAny<ClientDatabaseDTO>(), It.IsAny<DbServerDTO>(), It.IsAny<int>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Never);
    }

    [Fact]
    public async Task Test_Execute_ClientProvisioning_FromSnapshot_MissingTemplateBackupRef_Throws()
    {
        var (svc, dal, _, provisioner) = BuildService();
        var cr = ApprovedProvisioningCr(mode: ProvisioningMode.FromSnapshot, templateBackupRef: null);
        dal.Setup(d => d.GetById(cr.ChangeRequestId, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>())).ReturnsAsync(cr);

        await Assert.ThrowsAsync<InvalidOperationException>(() =>
            svc.Execute(cr.ChangeRequestId, TestLogin(), CancellationToken.None));

        provisioner.Verify(p => p.CreateFromSnapshotAsync(It.IsAny<ClientDatabaseDTO>(), It.IsAny<DbServerDTO>(), It.IsAny<string>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Never);
    }

    [Fact]
    public async Task Test_Execute_ClientProvisioning_FromSnapshot_CallsProvisionerAndActivatesClientDb()
    {
        var (svc, dal, clientDatabaseBLL, provisioner) = BuildService();
        var cr = ApprovedProvisioningCr(mode: ProvisioningMode.FromSnapshot, templateBackupRef: "acme-template.bak");
        dal.Setup(d => d.GetById(cr.ChangeRequestId, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>())).ReturnsAsync(cr);

        await svc.Execute(cr.ChangeRequestId, TestLogin(), CancellationToken.None);

        provisioner.Verify(p => p.CreateFromSnapshotAsync(
            It.Is<ClientDatabaseDTO>(c => c.ClientDbId == 5), It.IsAny<DbServerDTO>(), "acme-template.bak",
            It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Once);
        provisioner.Verify(p => p.CreateFromScriptsAsync(It.IsAny<ClientDatabaseDTO>(), It.IsAny<DbServerDTO>(), It.IsAny<int>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Never);

        clientDatabaseBLL.Verify(c => c.UpdateStatusAsync(5, (byte)ClientDbStatus.Active, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Once);
        dal.Verify(d => d.UpdateStatus(cr.ChangeRequestId, (byte)ChangeRequestStatus.Executed, (byte)ChangeRequestStatus.Approved, It.IsAny<int>(), null, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Once);
    }

    [Fact]
    public async Task Test_Execute_ClientProvisioning_FromScripts_MissingBaselinePackageId_Throws()
    {
        var (svc, dal, _, provisioner) = BuildService();
        var cr = ApprovedProvisioningCr(mode: ProvisioningMode.FromScripts, baselinePackageId: null);
        dal.Setup(d => d.GetById(cr.ChangeRequestId, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>())).ReturnsAsync(cr);

        await Assert.ThrowsAsync<InvalidOperationException>(() =>
            svc.Execute(cr.ChangeRequestId, TestLogin(), CancellationToken.None));

        provisioner.Verify(p => p.CreateFromScriptsAsync(It.IsAny<ClientDatabaseDTO>(), It.IsAny<DbServerDTO>(), It.IsAny<int>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Never);
    }

    [Fact]
    public async Task Test_Execute_ClientProvisioning_FromScripts_CallsProvisionerWithBaselinePackage()
    {
        var (svc, dal, clientDatabaseBLL, provisioner) = BuildService();
        var cr = ApprovedProvisioningCr(mode: ProvisioningMode.FromScripts, baselinePackageId: 77);
        dal.Setup(d => d.GetById(cr.ChangeRequestId, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>())).ReturnsAsync(cr);

        await svc.Execute(cr.ChangeRequestId, TestLogin(), CancellationToken.None);

        provisioner.Verify(p => p.CreateFromScriptsAsync(
            It.Is<ClientDatabaseDTO>(c => c.ClientDbId == 5), It.IsAny<DbServerDTO>(), 77,
            It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Once);

        clientDatabaseBLL.Verify(c => c.UpdateStatusAsync(5, (byte)ClientDbStatus.Active, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Once);
    }

    [Fact]
    public async Task Test_Execute_NonProvisioningCategory_NeverCallsProvisioner()
    {
        var (svc, dal, _, provisioner) = BuildService();
        var cr = new ChangeRequestDTO
        {
            ChangeRequestId  = 200,
            ClientDatabaseId = 5,
            CrStatus         = ChangeRequestStatus.Approved,
            Category         = ChangeRequestCategory.SchemaChange,
            QueryType        = ChangeRequestQueryType.DDL
        };
        dal.Setup(d => d.GetById(cr.ChangeRequestId, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>())).ReturnsAsync(cr);
        dal.Setup(d => d.GetLinkedApprovedDdlScripts(cr.ChangeRequestId, It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()))
           .ReturnsAsync(new List<DdlScriptDTO> { new() { DdlScriptId = 1, SqlScript = "SELECT 1" } });

        await svc.Execute(cr.ChangeRequestId, TestLogin(), CancellationToken.None);

        provisioner.Verify(p => p.CreateFromSnapshotAsync(It.IsAny<ClientDatabaseDTO>(), It.IsAny<DbServerDTO>(), It.IsAny<string>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Never);
        provisioner.Verify(p => p.CreateFromScriptsAsync(It.IsAny<ClientDatabaseDTO>(), It.IsAny<DbServerDTO>(), It.IsAny<int>(), It.IsAny<LoginDTO>(), It.IsAny<CancellationToken>()), Times.Never);
    }
}