using FrameworkDAL.CustomCode.DiagnosticsCenter;
using GB5Shared.DTO.Framework.Login;
using Microsoft.Extensions.Logging;
using System.Text.Json;

namespace FrameworkBLL.DiagnosticsCenter;

public class DiagnosticsCenterBLL : IDiagnosticsCenterBLL
{
    private readonly IDiagnosticsCenterDAL         _dal;
    private readonly ILogger<DiagnosticsCenterBLL> _logger;

    private static readonly JsonSerializerOptions JsonOpts = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
    };

    public DiagnosticsCenterBLL(IDiagnosticsCenterDAL dal, ILogger<DiagnosticsCenterBLL> logger)
    {
        _dal    = dal;
        _logger = logger;
    }

    public async Task<string> GetHealthDashboardAsync(LoginDTO login, CancellationToken ct)
    {
        try
        {
            var result = await _dal.GetHealthDashboardAsync(login.ClientId, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(result, JsonOpts);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetHealthDashboard failed for tenant {TenantId}", login.ClientId);
            throw;
        }
    }

    public async Task<string> GetSlowTransactionsAsync(int topN, int hoursBack, LoginDTO login, CancellationToken ct)
    {
        topN      = Math.Clamp(topN, 1, 200);
        hoursBack = Math.Clamp(hoursBack, 1, 168); // max 7 days
        try
        {
            var result = await _dal.GetSlowTransactionsAsync(login.ClientId, topN, hoursBack, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(result, JsonOpts);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetSlowTransactions failed for tenant {TenantId}", login.ClientId);
            throw;
        }
    }

    public async Task<string> GetRecentErrorsAsync(int topN, int hoursBack, LoginDTO login, CancellationToken ct)
    {
        topN      = Math.Clamp(topN, 1, 200);
        hoursBack = Math.Clamp(hoursBack, 1, 168);
        try
        {
            var result = await _dal.GetRecentErrorsAsync(login.ClientId, topN, hoursBack, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(result, JsonOpts);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetRecentErrors failed for tenant {TenantId}", login.ClientId);
            throw;
        }
    }

    public async Task<string> GetWorkflowDiagnosticsAsync(int topN, int hoursBack, LoginDTO login, CancellationToken ct)
    {
        topN      = Math.Clamp(topN, 1, 200);
        hoursBack = Math.Clamp(hoursBack, 1, 168);
        try
        {
            var result = await _dal.GetWorkflowDiagnosticsAsync(topN, hoursBack, login, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(result, JsonOpts);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetWorkflowDiagnostics failed for tenant {TenantId}", login.ClientId);
            throw;
        }
    }

    public async Task<string> GetIntegrationDiagnosticsAsync(int topN, int hoursBack, LoginDTO login, CancellationToken ct)
    {
        topN      = Math.Clamp(topN, 1, 200);
        hoursBack = Math.Clamp(hoursBack, 1, 168);
        try
        {
            var result = await _dal.GetIntegrationDiagnosticsAsync(topN, hoursBack, login, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(result, JsonOpts);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetIntegrationDiagnostics failed for tenant {TenantId}", login.ClientId);
            throw;
        }
    }

    public async Task<string> GetSessionDiagnosticsAsync(LoginDTO login, CancellationToken ct)
    {
        try
        {
            var result = await _dal.GetSessionDiagnosticsAsync(login.ClientId, login, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(result, JsonOpts);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetSessionDiagnostics failed for tenant {TenantId}", login.ClientId);
            throw;
        }
    }

    public async Task<string> GetModuleHealthAsync(int hoursBack, LoginDTO login, CancellationToken ct)
    {
        hoursBack = Math.Clamp(hoursBack, 1, 168);
        try
        {
            var result = await _dal.GetModuleHealthAsync(login.ClientId, hoursBack, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(result, JsonOpts);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetModuleHealth failed for tenant {TenantId}", login.ClientId);
            throw;
        }
    }
}