using System.Text.Json;
using CMGMBLL.Interfaces;
using CMGMDAL.DTOs;
using CMGMDAL.Interfaces;
using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EventLogPublish;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using static GB5Shared.GB5Constant.Constant;
using Microsoft.Extensions.Logging;

namespace CMGMBLL.Implementations;

public class CompetencyKRAMapBLL : ICompetencyKRAMapBLL
{
    private readonly ICompetencyKRAMapDAL  _dal;
    private readonly KeyInvalidate         _keyInvalidate;
    private readonly EventLogPublish       _eventLog;
    private readonly ILogger<CompetencyKRAMapBLL> _logger;

    public CompetencyKRAMapBLL(ICompetencyKRAMapDAL dal, KeyInvalidate keyInvalidate,
        EventLogPublish eventLog, ILogger<CompetencyKRAMapBLL> logger)
    {
        _dal           = dal;
        _keyInvalidate = keyInvalidate;
        _eventLog      = eventLog;
        _logger        = logger;
    }

    public async Task<string> GetByFrameworkAsync(int frameworkId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            var list = await _dal.GetByFrameworkAsync(frameworkId, login, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(list);
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("get-kramap-failed", ex);
            _logger.LogError(ex, "GetKRAMap failed for FrameworkId {FrameworkId}", frameworkId);
            throw;
        }
    }

    public async Task<string> BulkSaveAsync(int frameworkId, IEnumerable<CompetencyKRAMapDTO> maps, LoginDTO login, CancellationToken ct)
    {
        try
        {
            GB5Trace.Step("validate-kramap", new { frameworkId });
            if (frameworkId <= 0) return "Framework Id is required.";

            GB5Trace.Step("bulk-save-kramap", new { frameworkId });
            await _dal.BulkSaveAsync(frameworkId, maps, login, ct).ConfigureAwait(false);

            GB5Trace.Step("event-publish", new { EventTypeId = EventTypeConstant.SAVECMGMKRAMAPEVENTTYPEID });
            await _eventLog.PublishEventLogAsync("Competency KRA Map Saved",
                new { FrameworkId = frameworkId }, EventTypeConstant.SAVECMGMKRAMAPEVENTTYPEID,
                frameworkId, login, ct: ct).ConfigureAwait(false);

            var cacheKey = new CacheKeyGeneration().KeyGeneration(frameworkId, EntityConstant.OBJECTCMGMKRAMAP, CacheKeyLevel.CLIENT_LEVEL, login);
            await _keyInvalidate.AllInvalidateCache(cacheKey).ConfigureAwait(false);

            return SuccessResponse.SaveSuccess;
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("bulk-save-kramap-failed", ex);
            _logger.LogError(ex, "BulkSaveKRAMap failed for FrameworkId {FrameworkId}", frameworkId);
            throw;
        }
    }

    public async Task<string> DeleteOneAsync(int competencyKRAMapId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            GB5Trace.Step("delete-kramap", new { competencyKRAMapId });
            await _dal.DeleteOneAsync(competencyKRAMapId, login, ct).ConfigureAwait(false);

            GB5Trace.Step("event-publish", new { EventTypeId = EventTypeConstant.SAVECMGMKRAMAPEVENTTYPEID });
            await _eventLog.PublishEventLogAsync("Competency KRA Map Entry Deleted",
                new { CompetencyKRAMapId = competencyKRAMapId }, EventTypeConstant.SAVECMGMKRAMAPEVENTTYPEID,
                competencyKRAMapId, login, ct: ct).ConfigureAwait(false);

            var cacheKey = new CacheKeyGeneration().KeyGeneration(competencyKRAMapId, EntityConstant.OBJECTCMGMKRAMAP, CacheKeyLevel.CLIENT_LEVEL, login);
            await _keyInvalidate.AllInvalidateCache(cacheKey).ConfigureAwait(false);

            return SuccessResponse.DeleteSuccessMessage;
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("delete-kramap-failed", ex);
            _logger.LogError(ex, "DeleteKRAMap failed for Id {Id}", competencyKRAMapId);
            throw;
        }
    }
}