using System.ComponentModel.DataAnnotations;
using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.AutoNumber;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.EntityHandler;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using GB5Shared.Validation;
using MarketingDAL.CustomCode.BusinessAspirationGoal;
using MarketingDAL.DTO.BusinessAspirationGoal;
using Microsoft.Extensions.Logging;
using static GB5Shared.GB5Constant.Constant;

namespace MarketingBLL.BusinessAspirationGoal;

public class BusinessAspirationGoalBLL : IBusinessAspirationGoalBLL
{
    private readonly IBusinessAspirationGoalDAL _BusinessAspirationGoalDAL;
    private readonly AutoNumber _AutoNumber;
    private readonly IValidation _Validation;
    private readonly KeyInvalidate _KeyInvalidate;
    private readonly BaseEntityAppService<BusinessAspirationGoalDTO> _BaseEntityAppService;
    private readonly ILogger<BusinessAspirationGoalBLL> _Logger;

    public BusinessAspirationGoalBLL(
        IBusinessAspirationGoalDAL businessAspirationGoalDAL,
        AutoNumber autoNumber,
        IValidation validation,
        KeyInvalidate keyInvalidate,
        BaseEntityAppService<BusinessAspirationGoalDTO> baseEntityAppService,
        ILogger<BusinessAspirationGoalBLL> logger)
    {
        _BusinessAspirationGoalDAL = businessAspirationGoalDAL;
        _AutoNumber = autoNumber;
        _Validation = validation;
        _KeyInvalidate = keyInvalidate;
        _BaseEntityAppService = baseEntityAppService;
        _Logger = logger;
    }

    public async Task<string> GetBusinessAspirationGoal(int businessAspirationGoalId, LoginDTO loginDTO, CancellationToken ct)
    {
        try
        {
            return await _BusinessAspirationGoalDAL.GetBusinessAspirationGoal(businessAspirationGoalId, loginDTO, ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("get-businessaspirationgoal-failed", ex);
            _Logger.LogError(ex, "GetBusinessAspirationGoal failed for BusinessAspirationGoalId {BusinessAspirationGoalId}", businessAspirationGoalId);
            throw;
        }
    }

    public async Task<BusinessAspirationGoalDTO?> GetLatestBusinessAspirationGoal(LoginDTO loginDTO, CancellationToken ct)
    {
        try
        {
            return await _BusinessAspirationGoalDAL.GetLatestBusinessAspirationGoal(loginDTO, ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("get-latest-businessaspirationgoal-failed", ex);
            _Logger.LogError(ex, "GetLatestBusinessAspirationGoal failed");
            throw;
        }
    }

    public async Task<string> SaveBusinessAspirationGoal(BusinessAspirationGoalDTO businessAspirationGoalDTO, LoginDTO loginDTO, CancellationToken ct)
    {
        if (businessAspirationGoalDTO == null)
            throw new ArgumentNullException(nameof(businessAspirationGoalDTO));

        AutoNumberDTO? autoNumberDTO = null;

        try
        {
            GB5Trace.Step("validate-businessaspirationgoal", new { businessAspirationGoalDTO.BusinessAspirationGoalId });

            await _Validation.NotEmpty(businessAspirationGoalDTO.BusinessAspirationGoalCode, nameof(businessAspirationGoalDTO.BusinessAspirationGoalCode));
            await _Validation.NotEmpty(businessAspirationGoalDTO.BusinessAspirationGoalName, nameof(businessAspirationGoalDTO.BusinessAspirationGoalName));
            await _Validation.Range(1900, 2200, businessAspirationGoalDTO.EffectiveYear, nameof(businessAspirationGoalDTO.EffectiveYear));

            businessAspirationGoalDTO.ModifiedById = loginDTO.UserId;
            businessAspirationGoalDTO.ModifiedOn = DateTime.UtcNow;

            bool isNew = businessAspirationGoalDTO.BusinessAspirationGoalId == 0;

            if (isNew)
            {
                autoNumberDTO = await _AutoNumber.GetNumberAsync(1, "BIZASPIRATIONGOAL", loginDTO).ConfigureAwait(false);
                businessAspirationGoalDTO.BusinessAspirationGoalId = autoNumberDTO.StartNumber;
                businessAspirationGoalDTO.CreatedById = loginDTO.UserId;
                businessAspirationGoalDTO.CreatedOn = DateTime.UtcNow;
            }

            GB5Trace.Step("save-businessaspirationgoal", new { businessAspirationGoalDTO.BusinessAspirationGoalId, isNew });

            await _BaseEntityAppService.ExecuteSaveAsync(
                EntityConstant.OBJECTMARKETINGBUSINESSASPIRATIONGOAL,
                isNew ? EventTypeConstant.SAVEMARKETINGBUSINESSASPIRATIONGOALEVENTTYPEID : EventTypeConstant.UPDATEMARKETINGBUSINESSASPIRATIONGOALEVENTTYPEID,
                businessAspirationGoalDTO,
                loginDTO,
                async tx =>
                {
                    _ = isNew
                        ? await _BusinessAspirationGoalDAL.SaveBusinessAspirationGoal(businessAspirationGoalDTO, loginDTO, tx, ct).ConfigureAwait(false)
                        : await _BusinessAspirationGoalDAL.UpdateBusinessAspirationGoal(businessAspirationGoalDTO, loginDTO, tx, ct).ConfigureAwait(false);
                    return businessAspirationGoalDTO.BusinessAspirationGoalId;
                },
                null, -1, -1, null, isNew).ConfigureAwait(false);

            GB5Trace.Step("event-publish", new
            {
                EventTypeId = isNew ? EventTypeConstant.SAVEMARKETINGBUSINESSASPIRATIONGOALEVENTTYPEID : EventTypeConstant.UPDATEMARKETINGBUSINESSASPIRATIONGOALEVENTTYPEID
            });

            var cacheKey = new CacheKeyGeneration().KeyGeneration(
                businessAspirationGoalDTO.BusinessAspirationGoalId, EntityConstant.OBJECTMARKETINGBUSINESSASPIRATIONGOAL, CacheKeyLevel.CLIENT_LEVEL, loginDTO);
            await _KeyInvalidate.AllInvalidateCache(cacheKey).ConfigureAwait(false);

            _Logger.LogInformation("BusinessAspirationGoal {BusinessAspirationGoalId} {Action} by user {UserId}",
                businessAspirationGoalDTO.BusinessAspirationGoalId, isNew ? "saved" : "updated", loginDTO.UserId);

            return isNew
                ? $"{SuccessResponse.SaveSuccessMessage} {businessAspirationGoalDTO.BusinessAspirationGoalId}"
                : $"{SuccessResponse.UpdateSuccessMessage} {businessAspirationGoalDTO.BusinessAspirationGoalId}";
        }
        catch (ValidationException vex)
        {
            GB5Trace.MarkFailed("save-businessaspirationgoal-failed", vex);
            if (autoNumberDTO != null && businessAspirationGoalDTO.BusinessAspirationGoalId > 0)
                await _AutoNumber.RollbackAutoNumber("BIZASPIRATIONGOAL", businessAspirationGoalDTO.BusinessAspirationGoalId, loginDTO).ConfigureAwait(false);
            throw new Exception(vex.Message);
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("save-businessaspirationgoal-failed", ex);
            _Logger.LogError(ex, "SaveBusinessAspirationGoal failed for BusinessAspirationGoalId {BusinessAspirationGoalId}", businessAspirationGoalDTO.BusinessAspirationGoalId);
            if (autoNumberDTO != null && businessAspirationGoalDTO.BusinessAspirationGoalId > 0)
                await _AutoNumber.RollbackAutoNumber("BIZASPIRATIONGOAL", businessAspirationGoalDTO.BusinessAspirationGoalId, loginDTO).ConfigureAwait(false);
            throw;
        }
    }

    public async Task<string> GetSelectListBusinessAspirationGoal(CriteriaDTO criteriaDTO, LoginDTO loginDTO, CancellationToken ct)
    {
        try
        {
            return await _BusinessAspirationGoalDAL.GetSelectListBusinessAspirationGoal(criteriaDTO, loginDTO, ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("get-selectlist-businessaspirationgoal-failed", ex);
            _Logger.LogError(ex, "GetSelectListBusinessAspirationGoal failed");
            throw;
        }
    }

    public async Task<string> DeleteBusinessAspirationGoal(int businessAspirationGoalId, LoginDTO loginDTO, CancellationToken ct)
    {
        try
        {
            GB5Trace.Step("delete-businessaspirationgoal", new { businessAspirationGoalId });

            var result = await _BusinessAspirationGoalDAL.DeleteBusinessAspirationGoal(businessAspirationGoalId, loginDTO, ct).ConfigureAwait(false);

            var cacheKey = new CacheKeyGeneration().KeyGeneration(
                businessAspirationGoalId, EntityConstant.OBJECTMARKETINGBUSINESSASPIRATIONGOAL, CacheKeyLevel.CLIENT_LEVEL, loginDTO);
            await _KeyInvalidate.AllInvalidateCache(cacheKey).ConfigureAwait(false);

            _Logger.LogInformation("BusinessAspirationGoal {BusinessAspirationGoalId} deleted by user {UserId}", businessAspirationGoalId, loginDTO.UserId);

            return result;
        }
        catch (Exception ex)
        {
            GB5Trace.MarkFailed("delete-businessaspirationgoal-failed", ex);
            _Logger.LogError(ex, "DeleteBusinessAspirationGoal failed for BusinessAspirationGoalId {BusinessAspirationGoalId}", businessAspirationGoalId);
            throw;
        }
    }
}