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

namespace FBCKBLL.Implementations;

public class RecognitionBLL : IRecognitionBLL
{
    private readonly IRecognitionDAL            _dal;
    private readonly IValidation                _validation;
    private readonly KeyInvalidate              _keyInvalidate;
    private readonly EventLogPublish            _eventLog;
    private readonly IFBCKNotificationService   _notification;
    private readonly ILogger<RecognitionBLL>    _logger;

    public RecognitionBLL(IRecognitionDAL dal, IValidation validation, KeyInvalidate keyInvalidate,
        EventLogPublish eventLog, IFBCKNotificationService notification, ILogger<RecognitionBLL> logger)
    {
        _dal          = dal;
        _validation   = validation;
        _keyInvalidate = keyInvalidate;
        _eventLog     = eventLog;
        _notification = notification;
        _logger       = logger;
    }

    public async Task<string> GetRecognitionAsync(int recognitionId, LoginDTO login, CancellationToken ct)
    {
        var dto = await _dal.GetRecognitionAsync(recognitionId, login, ct).ConfigureAwait(false);
        return JsonSerializer.Serialize(dto);
    }

    public async Task<string> GetRecognitionListAsync(int toEmployeeId, int fromEmployeeId,
        int page, int pageSize, LoginDTO login, CancellationToken ct)
    {
        var list = await _dal.GetRecognitionListAsync(toEmployeeId, fromEmployeeId, page, pageSize, login, ct).ConfigureAwait(false);
        return JsonSerializer.Serialize(list);
    }

    public async Task<string> GetRecognitionWallAsync(int ouid, int page, int pageSize, LoginDTO login, CancellationToken ct)
    {
        var list = await _dal.GetRecognitionWallAsync(ouid, page, pageSize, login, ct).ConfigureAwait(false);
        return JsonSerializer.Serialize(list);
    }

    public async Task<string> SaveRecognitionAsync(RecognitionDTO dto, LoginDTO login, CancellationToken ct)
    {
        try
        {
            GB5Trace.Step("validate-recognition", new { dto.ToEmployeeId });
            await _validation.NotEmpty(dto.Message, nameof(dto.Message)).ConfigureAwait(false);
            if (dto.ToEmployeeId == login.UserId)
                return "You cannot recognise yourself.";

            GB5Trace.Step("save-recognition", new { dto.ToEmployeeId });
            var savedId = await _dal.SaveRecognitionAsync(dto, login, ct).ConfigureAwait(false);

            GB5Trace.Step("event-publish", new { EventTypeId = EventTypeConstant.SAVERECOGNITIONEVENTTYPEID });
            await _eventLog.PublishEventLogAsync("Recognition Given", nameof(RecognitionDTO),
                EventTypeConstant.SAVERECOGNITIONEVENTTYPEID, savedId, login, ct: ct).ConfigureAwait(false);

            dto.RecognitionId = savedId;
            try { await _notification.NotifyRecognitionGivenAsync(dto, login, ct).ConfigureAwait(false); }
            catch (Exception notifyEx)
            {
                _logger.LogWarning(notifyEx, "SignalR notification failed for recognition {RecognitionId}", savedId);
            }

            return $"{SuccessResponse.SaveSuccessMessage} {savedId}";
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("recognition-save-failed", ex);
            _logger.LogError(ex, "SaveRecognition failed for ToEmployee {ToEmployeeId}", dto.ToEmployeeId);
            throw;
        }
    }

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

            GB5Trace.Step("event-publish", new { EventTypeId = EventTypeConstant.DELETERECOGNITIONEVENTTYPEID });
            await _eventLog.PublishEventLogAsync("Recognition Deleted", nameof(RecognitionDTO),
                EventTypeConstant.DELETERECOGNITIONEVENTTYPEID, recognitionId, login, ct: ct).ConfigureAwait(false);

            return SuccessResponse.DeleteSuccessMessage;
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("recognition-delete-failed", ex);
            _logger.LogError(ex, "DeleteRecognition failed for RecognitionId {RecognitionId}", recognitionId);
            throw;
        }
    }
}