using GB5Shared.Signatory.DTO;
using GB5Shared.DTO.Framework.AutoNumber;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EventLogPublish;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using GB5Shared.Validation;
using Microsoft.Extensions.Logging;
using static GB5Shared.GB5Constant.Constant;

namespace GB5Shared.Signatory
{
    public class SignatoryBLL : ISignatoryBLL
    {
        private readonly ISignatoryDAL _SignatoryDAL;
        private readonly AutoNumber _AutoNumber;
        private readonly IValidation _Validation;
        private readonly GB5Shared.EventLogPublish.EventLogPublish _EventLog;
        private readonly ILogger<SignatoryBLL> _Logger;

        public SignatoryBLL(ISignatoryDAL SignatoryDAL, AutoNumber AutoNumber, IValidation Validation,
            GB5Shared.EventLogPublish.EventLogPublish EventLog, ILogger<SignatoryBLL> Logger)
        {
            _SignatoryDAL = SignatoryDAL;
            _AutoNumber = AutoNumber;
            _Validation = Validation;
            _EventLog = EventLog;
            _Logger = Logger;
        }

        public async Task<string> GetSignatory(int signatoryId, LoginDTO loginDTO, CancellationToken ct)
            => await _SignatoryDAL.GetSignatory(signatoryId, loginDTO, ct).ConfigureAwait(false);

        public async Task<string> GetActiveSignatoryByModule(int moduleId, LoginDTO loginDTO, CancellationToken ct)
            => await _SignatoryDAL.GetActiveSignatoryByModule(moduleId, loginDTO, ct).ConfigureAwait(false);

        public async Task<string> GetSelectListSignatory(CriteriaDTO criteriaDTO, LoginDTO loginDTO, CancellationToken ct)
            => await _SignatoryDAL.GetSelectListSignatory(criteriaDTO, loginDTO, ct).ConfigureAwait(false);

        public async Task<string> SaveSignatory(SignatoryDTO signatoryDTO, LoginDTO loginDTO, CancellationToken ct)
        {
            if (signatoryDTO == null) throw new ArgumentNullException(nameof(signatoryDTO));
            AutoNumberDTO? autoNumberDTO = null;

            try
            {
                GB5Trace.Step("validate-signatory", new { signatoryDTO.SignatoryId, signatoryDTO.ModuleId });
                await _Validation.NotEmpty(signatoryDTO.SignatoryName, nameof(signatoryDTO.SignatoryName));

                bool isNew = signatoryDTO.SignatoryId == 0;
                signatoryDTO.ModifiedById = loginDTO.UserId;
                signatoryDTO.ModifiedOn = DateTime.UtcNow;
                signatoryDTO.TenantId = loginDTO.ClientId;

                GB5Trace.Step("save-signatory", new { signatoryDTO.SignatoryId, isNew });

                if (isNew)
                {
                    autoNumberDTO = await _AutoNumber.GetAutoNumber(1, "SIGNATORY", loginDTO).ConfigureAwait(false);
                    signatoryDTO.SignatoryId = autoNumberDTO.StartNumber;
                    signatoryDTO.CreatedById = loginDTO.UserId;
                    signatoryDTO.CreatedOn = DateTime.UtcNow;

                    await _SignatoryDAL.SaveSignatory(signatoryDTO, loginDTO, ct).ConfigureAwait(false);
                }
                else
                {
                    await _SignatoryDAL.UpdateSignatory(signatoryDTO, loginDTO, ct).ConfigureAwait(false);
                }

                GB5Trace.Step("event-publish", new { EventTypeId = EventTypeConstant.SAVESIGNATORYEVENTTYPEID });
                await _EventLog.PublishEventLogAsync(
                    "Signatory Saved",
                    new { signatoryDTO.SignatoryId, signatoryDTO.ModuleId, signatoryDTO.SignatoryName },
                    EventTypeConstant.SAVESIGNATORYEVENTTYPEID,
                    signatoryDTO.SignatoryId,
                    loginDTO,
                    ct: ct).ConfigureAwait(false);

                return isNew
                    ? $"{SuccessResponse.SaveSuccessMessage} {signatoryDTO.SignatoryId}"
                    : $"{SuccessResponse.UpdateSuccessMessage} {signatoryDTO.SignatoryId}";
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-signatory-failed", ex);
                if (autoNumberDTO != null && signatoryDTO.SignatoryId > 0)
                    await _AutoNumber.RollbackAutoNumber("SIGNATORY", signatoryDTO.SignatoryId, loginDTO).ConfigureAwait(false);

                _Logger.LogError(ex, "SaveSignatory failed for ModuleId {ModuleId}", signatoryDTO.ModuleId);
                throw;
            }
        }

        public async Task<string> DeleteSignatory(int signatoryId, LoginDTO loginDTO, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("delete-signatory", new { signatoryId });
                var result = await _SignatoryDAL.DeleteSignatory(signatoryId, loginDTO, ct).ConfigureAwait(false);

                GB5Trace.Step("event-publish", new { EventTypeId = EventTypeConstant.DELETESIGNATORYEVENTTYPEID });
                await _EventLog.PublishEventLogAsync(
                    "Signatory Deleted",
                    new { signatoryId },
                    EventTypeConstant.DELETESIGNATORYEVENTTYPEID,
                    signatoryId,
                    loginDTO,
                    ct: ct).ConfigureAwait(false);

                return result;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("delete-signatory-failed", ex);
                _Logger.LogError(ex, "DeleteSignatory failed for SignatoryId {SignatoryId}", signatoryId);
                throw;
            }
        }
    }
}