using System.Data.Common;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.ResponseStandard;
using IDMSDAL.DTOs;
using IDMSDAL.Interfaces;
using IDMSDAL.QueryBuilders;

namespace IDMSDAL.Implementations;

public class EngagementDAL : IEngagementDAL
{
    private readonly IQueryExecutor _QueryExecutor;

    public EngagementDAL(IQueryExecutor queryExecutor)
    {
        _QueryExecutor = queryExecutor;
    }

    // ── Reads ─────────────────────────────────────────────────────────────────

    public async Task<EngagementDTO?> GetEngagementAsync(
        int engagementId, LoginDTO login, CancellationToken ct)
    {
        return await _QueryExecutor.QuerySingleAsync<EngagementDTO>(
            login, EngagementQB.GET_BY_ID,
            new { EngagementId = engagementId }).ConfigureAwait(false);
    }

    public async Task<IEnumerable<EngagementModuleDTO>> GetEngagementModulesAsync(
        int engagementId, LoginDTO login, CancellationToken ct)
    {
        return await _QueryExecutor.QueryAsync<EngagementModuleDTO>(
            login, EngagementQB.GET_MODULES,
            new { EngagementId = engagementId },
            cancellationToken: ct).ConfigureAwait(false)
            ?? Enumerable.Empty<EngagementModuleDTO>();
    }

    public async Task<EngagementDashboardDTO?> GetEngagementDashboardAsync(
        int engagementId, LoginDTO login, CancellationToken ct)
    {
        return await _QueryExecutor.QuerySingleAsync<EngagementDashboardDTO>(
            login, EngagementQB.GET_DASHBOARD,
            new { EngagementId = engagementId }).ConfigureAwait(false);
    }

    // ── Writes ────────────────────────────────────────────────────────────────

    public async Task<Result<string>> SaveEngagementAsync(
        EngagementDTO dto, LoginDTO login, DbTransaction tx, CancellationToken ct)
    {
        try
        {
            dto.EngagementCreatedById  = login.UserId;
            dto.EngagementCreatedOn    = DateTime.UtcNow;
            dto.EngagementModifiedById = login.UserId;
            dto.EngagementModifiedOn   = DateTime.UtcNow;

            int rows = await _QueryExecutor.ExecuteAsync(
                login, EngagementQB.INSERT, dto, tx,
                cancellationToken: ct).ConfigureAwait(false);

            return rows > 0
                ? Result<string>.Success("Engagement saved.")
                : Result<string>.Failure("Failed to save engagement.");
        }
        catch (Exception)
        {
            throw;
        }
    }

    public async Task<Result<string>> UpdateEngagementAsync(
        EngagementDTO dto, LoginDTO login, DbTransaction tx, CancellationToken ct)
    {
        try
        {
            dto.EngagementModifiedById = login.UserId;
            dto.EngagementModifiedOn   = DateTime.UtcNow;

            int rows = await _QueryExecutor.ExecuteAsync(
                login, EngagementQB.UPDATE, dto, tx,
                cancellationToken: ct).ConfigureAwait(false);

            return rows > 0
                ? Result<string>.Success("Engagement updated.")
                : Result<string>.Failure("Engagement not found or not updated.");
        }
        catch (Exception)
        {
            throw;
        }
    }

    public async Task<Result<string>> ActivateEngagementAsync(
        int engagementId, string activeDomainsJson, LoginDTO login, DbTransaction tx, CancellationToken ct)
    {
        try
        {
            var param = new
            {
                EngagementId           = engagementId,
                ActiveDomains          = activeDomainsJson,
                EngagementModifiedById = login.UserId,
                EngagementModifiedOn   = DateTime.UtcNow
            };

            int rows = await _QueryExecutor.ExecuteAsync(
                login, EngagementQB.ACTIVATE, param, tx,
                cancellationToken: ct).ConfigureAwait(false);

            return rows > 0
                ? Result<string>.Success("Engagement activated.")
                : Result<string>.Failure("Engagement not found or already active.");
        }
        catch (Exception)
        {
            throw;
        }
    }

    public async Task<Result<string>> DeclareGoLiveAsync(
        int engagementId, DateTime goLiveOn, LoginDTO login, DbTransaction tx, CancellationToken ct)
    {
        try
        {
            var param = new
            {
                EngagementId           = engagementId,
                GoLiveOn               = goLiveOn,
                EngagementModifiedById = login.UserId,
                EngagementModifiedOn   = DateTime.UtcNow
            };

            int rows = await _QueryExecutor.ExecuteAsync(
                login, EngagementQB.DECLARE_GOLIVE, param, tx,
                cancellationToken: ct).ConfigureAwait(false);

            return rows > 0
                ? Result<string>.Success("Go-live declared.")
                : Result<string>.Failure("Engagement not found.");
        }
        catch (Exception)
        {
            throw;
        }
    }

    public async Task<Result<string>> UpdateHealthStatusAsync(
        int engagementId, string healthStatus, int signalScore, LoginDTO login, DbTransaction tx, CancellationToken ct)
    {
        try
        {
            var param = new
            {
                EngagementId           = engagementId,
                HealthStatus           = healthStatus,
                UpgradeSignalScore     = signalScore,
                EngagementModifiedById = login.UserId,
                EngagementModifiedOn   = DateTime.UtcNow
            };

            int rows = await _QueryExecutor.ExecuteAsync(
                login, EngagementQB.UPDATE_HEALTH, param, tx,
                cancellationToken: ct).ConfigureAwait(false);

            return rows > 0
                ? Result<string>.Success("Health updated.")
                : Result<string>.Failure("Engagement not found.");
        }
        catch (Exception)
        {
            throw;
        }
    }

    // ── Module management ─────────────────────────────────────────────────────

    public async Task<Result<string>> SaveEngagementModuleAsync(
        EngagementModuleDTO dto, LoginDTO login, DbTransaction tx, CancellationToken ct)
    {
        try
        {
            int rows = await _QueryExecutor.ExecuteAsync(
                login, EngagementQB.INSERT_MODULE, dto, tx,
                cancellationToken: ct).ConfigureAwait(false);

            return rows > 0
                ? Result<string>.Success("Module saved.")
                : Result<string>.Failure("Failed to save module.");
        }
        catch (Exception)
        {
            throw;
        }
    }

    public async Task<Result<string>> DeleteEngagementModulesAsync(
        int engagementId, LoginDTO login, DbTransaction tx, CancellationToken ct)
    {
        try
        {
            int rows = await _QueryExecutor.ExecuteAsync(
                login, EngagementQB.DELETE_MODULES,
                new { EngagementId = engagementId }, tx,
                cancellationToken: ct).ConfigureAwait(false);

            return rows > 0
                ? Result<string>.Success("Modules deleted.")
                : Result<string>.Failure("No modules found.");
        }
        catch (Exception)
        {
            throw;
        }
    }

    public async Task<Result<string>> UpdateModuleSeedingStatusAsync(
        int engagementModuleId, byte status, DateTime? seededOn, LoginDTO login, CancellationToken ct)
    {
        try
        {
            var param = new
            {
                EngagementModuleId = engagementModuleId,
                SeedingStatus      = status,
                SeededOn           = seededOn
            };

            int rows = await _QueryExecutor.ExecuteAsync(
                login, EngagementQB.UPDATE_MODULE_SEEDING, param,
                cancellationToken: ct).ConfigureAwait(false);

            return rows > 0
                ? Result<string>.Success("Seeding status updated.")
                : Result<string>.Failure("Module not found.");
        }
        catch (Exception)
        {
            throw;
        }
    }
}