using AccountsDAL.CustomCode.CostCategory;
using AccountsDAL.DTO.CostCategory;
using GB5Shared.DaprCache;
using GB5Shared.DTO.Framework.AutoNumber;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.HybridCache;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;
using static GB5Shared.GB5Constant.Constant;

namespace AccountsBLL.CostCategory
{
    public class CostCategoryBLL : ICostCategoryBLL
    {
        private readonly ICostCategoryDAL _CostCategoryDAL;
        private readonly AutoNumber _AutoNumber;
        private readonly IValidation _Validation;
        private readonly KeyInvalidate _KeyInvalidate;

        public CostCategoryBLL(ICostCategoryDAL CostCategoryDAL, AutoNumber AutoNumber, IValidation Validation, KeyInvalidate keyInvalidate)
        {
            _CostCategoryDAL = CostCategoryDAL;
            _AutoNumber = AutoNumber;
            _Validation = Validation;
            _KeyInvalidate = keyInvalidate;
        }

        public async Task<string> GetCostCategory(int CostCategoryId, LoginDTO LoginDTO)
        {
            try
            {
                return await _CostCategoryDAL.GetCostCategory(CostCategoryId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetSelectListCostCategory(CriteriaDTO criteriaDTO, LoginDTO loginDTO)
        {

            try
            {
                return await _CostCategoryDAL.GetSelectListCostCategory(criteriaDTO, loginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetCostCategoryList(CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                return await _CostCategoryDAL.GetCostCategoryList(CriteriaDTO, LoginDTO)
                                              .ConfigureAwait(false);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> SaveCostCategory(
       CostCategoryDTO CostCategoryDTO,
       LoginDTO LoginDTO)
        {
            if (CostCategoryDTO == null)
                throw new ArgumentNullException(nameof(CostCategoryDTO));

            AutoNumberDTO? autoNumberDTO = null;

            try
            {
                await _Validation.NotEmpty(
                    CostCategoryDTO.CostCategoryCode,
                    nameof(CostCategoryDTO.CostCategoryCode));

                await _Validation.NotEmpty(
                    CostCategoryDTO.CostCategoryName,
                    nameof(CostCategoryDTO.CostCategoryName));

                CostCategoryDTO.CostCategoryModifiedById = LoginDTO.UserId;
                CostCategoryDTO.CostCategoryModifiedOn = DateTime.UtcNow;

                bool isNew = CostCategoryDTO.CostCategoryId == 0;

                if (isNew)
                {
                    int conditionCount =
                        CostCategoryDTO.CostCategoryConditionArray?.Count ?? 0;

                    int totalRequired = 1 + conditionCount;

                    autoNumberDTO = await _AutoNumber.GetNumberAsync(
                        totalRequired,
                        "COSTCATEGORY",
                        LoginDTO);

                    int nextId = autoNumberDTO.StartNumber;

                    CostCategoryDTO.CostCategoryId = nextId++;

                    CostCategoryDTO.CostCategoryCreatedById = LoginDTO.UserId;
                    CostCategoryDTO.CostCategoryCreatedOn = DateTime.UtcNow;

                    if (CostCategoryDTO.CostCategoryConditionArray?.Any() == true)
                    {
                        foreach (var condition in CostCategoryDTO.CostCategoryConditionArray)
                        {
                            condition.CostCategoryConditionId = nextId++;
                            condition.CostCategoryId = CostCategoryDTO.CostCategoryId;
                        }
                    }

                    await _CostCategoryDAL.SaveCostCategory(
                        CostCategoryDTO,
                        LoginDTO);
                }
                else
                {
                    var newConditions = CostCategoryDTO.CostCategoryConditionArray?
                        .Where(x => x.CostCategoryConditionId == 0)
                        .ToList();

                    if (newConditions?.Any() == true)
                    {
                        var conditionAutoNumber =
                            await _AutoNumber.GetNumberAsync(
                                newConditions.Count,
                                "COSTCATEGORY",
                                LoginDTO);

                        int nextId = conditionAutoNumber.StartNumber;

                        foreach (var condition in newConditions)
                        {
                            condition.CostCategoryConditionId = nextId++;
                            condition.CostCategoryId =
                                CostCategoryDTO.CostCategoryId;
                        }
                    }

                    await _CostCategoryDAL.UpdateCostCategory(
                        CostCategoryDTO,
                        LoginDTO);
                }

                return isNew
                    ? $"{SuccessResponse.SaveSuccessMessage} {CostCategoryDTO.CostCategoryId}"
                    : $"{SuccessResponse.UpdateSuccessMessage} {CostCategoryDTO.CostCategoryId}";
            }
            catch
            {
                if (autoNumberDTO != null)
                {
                    await _AutoNumber.RollbackAutoNumber(
                        "COSTCATEGORY",
                        autoNumberDTO.StartNumber,
                        LoginDTO);
                }

                throw;
            }
        }




        public async Task<string> DeleteCostCategory(int CostCategoryId, LoginDTO LoginDTO)
        {
            try
            {
                var conditionsResult = await _CostCategoryDAL.DeleteCostCategoryCondition(CostCategoryId, LoginDTO);

                if (conditionsResult <= 0)
                    return $"{ErrorResponse.DeleteNotFoundMessage}";

                var parentResult = await _CostCategoryDAL.DeleteCostCategory(CostCategoryId, LoginDTO);

                if (parentResult <= 0)
                    return $"{ErrorResponse.DeleteNotFoundMessage}";

                return $"{SuccessResponse.DeleteSuccessMessage}";
            }
            catch (Exception ex)
            {
                throw new Exception($"Error Deleting CostCategory ID {CostCategoryId}", ex);
            }
        }
    }
}