using System.ComponentModel.DataAnnotations;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using GB5Shared.Validation;
using Microsoft.Extensions.Logging;
using PartnerBLL.PartnerBrand;
using PartnerDAL.CustomCode.PartnerBrand;
using PartnerDAL.DTO.PartnerBrand;

namespace PartnerBLL.Implementations
{
    public class PartnerBrandBLL : IPartnerBrandBLL
    {
        private readonly IPartnerBrandDAL _partnerBrandDAL;
        private readonly IValidation _validation;
        private readonly ILogger<PartnerBrandBLL> _logger;

        public PartnerBrandBLL(IPartnerBrandDAL partnerBrandDAL, IValidation validation, ILogger<PartnerBrandBLL> logger)
        {
            _partnerBrandDAL = partnerBrandDAL;
            _validation = validation;
            _logger = logger;
        }

        public async Task<string> GetPartnerBrand(int PartnerBrandId, LoginDTO loginDTO)
        {
            try
            {
                return await _partnerBrandDAL.GetPartnerBrand(PartnerBrandId, loginDTO).ConfigureAwait(false);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetSelectListPartnerBrand(CriteriaDTO criteriaDTO, LoginDTO loginDTO, CancellationToken ct)
        {
            try
            {
                return await _partnerBrandDAL.GetSelectListPartnerBrand(criteriaDTO, loginDTO, ct).ConfigureAwait(false);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> SavePartnerBrand(PartnerBrandDTO partnerBrandDTO, LoginDTO loginDTO)
        {
            if (partnerBrandDTO == null) throw new ArgumentNullException(nameof(partnerBrandDTO));

            try
            {
                GB5Trace.Step("validate-partner-brand", new { partnerBrandDTO.PartnerId });
                if (partnerBrandDTO.PartnerId == 0)
                    throw new ValidationException("PartnerId is required.");

                bool isNew = partnerBrandDTO.PartnerBrandId == 0;
                partnerBrandDTO.PartnerBrandModifiedById = loginDTO.UserId;
                partnerBrandDTO.PartnerBrandModifiedOn = DateTime.UtcNow;

                GB5Trace.Step("save-partner-brand", new { partnerBrandDTO.PartnerBrandId, isNew });

                if (isNew)
                {
                    partnerBrandDTO.PartnerBrandCreatedById = loginDTO.UserId;
                    partnerBrandDTO.PartnerBrandCreatedOn = DateTime.UtcNow;
                    int newId = await _partnerBrandDAL.SavePartnerBrand(partnerBrandDTO, loginDTO).ConfigureAwait(false);
                    return $"{SuccessResponse.SaveSuccessMessage} {newId}";
                }
                else
                {
                    int rowsAffected = await _partnerBrandDAL.UpdatePartnerBrand(partnerBrandDTO, loginDTO).ConfigureAwait(false);
                    if (rowsAffected == 0)
                        throw new ValidationException(
                            $"No brand found with PartnerBrandId {partnerBrandDTO.PartnerBrandId} for PartnerId {partnerBrandDTO.PartnerId}.");
                    return $"{SuccessResponse.UpdateSuccessMessage} {partnerBrandDTO.PartnerBrandId}";
                }
            }
            catch (ValidationException vex)
            {
                throw new Exception(vex.Message);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-partner-brand-failed", ex);
                _logger.LogError(ex, "SavePartnerBrand failed for PartnerId {PartnerId}", partnerBrandDTO.PartnerId);
                throw;
            }
        }

        public async Task<string> DeletePartnerBrand(int partnerBrandId, LoginDTO loginDTO)
        {
            try
            {
                int rows = await _partnerBrandDAL.DeletePartnerBrand(partnerBrandId, loginDTO).ConfigureAwait(false);
                return rows > 0 ? SuccessResponse.DeleteSuccessMessage : ErrorResponse.DeleteNotFoundMessage;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("delete-partner-brand-failed", ex);
                _logger.LogError(ex, "DeletePartnerBrand failed for PartnerBrandId {PartnerBrandId}", partnerBrandId);
                throw;
            }
        }

        public async Task<string> GetPartnerBrandListByPartner(int partnerId, LoginDTO loginDTO)
        {
            try
            {
                return await _partnerBrandDAL.GetPartnerBrandListByPartner(partnerId, loginDTO).ConfigureAwait(false);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetPartnerProductBrand(int partnerProductId, LoginDTO loginDTO)
        {
            try
            {
                return await _partnerBrandDAL.GetPartnerProductBrand(partnerProductId, loginDTO).ConfigureAwait(false);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> SavePartnerProductBrand(PartnerProductBrandDTO partnerProductBrandDTO, LoginDTO loginDTO)
        {
            if (partnerProductBrandDTO == null) throw new ArgumentNullException(nameof(partnerProductBrandDTO));

            try
            {
                GB5Trace.Step("validate-partner-product-brand", new { partnerProductBrandDTO.PartnerProductId });
                if (partnerProductBrandDTO.PartnerProductId == 0)
                    throw new ValidationException("PartnerProductId is required.");

                bool isNew = partnerProductBrandDTO.PartnerProductBrandId == 0;
                partnerProductBrandDTO.PartnerProductBrandModifiedById = loginDTO.UserId;
                partnerProductBrandDTO.PartnerProductBrandModifiedOn = DateTime.UtcNow;

                GB5Trace.Step("save-partner-product-brand", new { partnerProductBrandDTO.PartnerProductBrandId, isNew });

                if (isNew)
                {
                    partnerProductBrandDTO.PartnerProductBrandCreatedById = loginDTO.UserId;
                    partnerProductBrandDTO.PartnerProductBrandCreatedOn = DateTime.UtcNow;
                    int newId = await _partnerBrandDAL.SavePartnerProductBrand(partnerProductBrandDTO, loginDTO).ConfigureAwait(false);
                    return $"{SuccessResponse.SaveSuccessMessage} {newId}";
                }
                else
                {
                    int rowsAffected = await _partnerBrandDAL.UpdatePartnerProductBrand(partnerProductBrandDTO, loginDTO).ConfigureAwait(false);
                    if (rowsAffected == 0)
                        throw new ValidationException(
                            $"No product brand found with PartnerProductBrandId {partnerProductBrandDTO.PartnerProductBrandId} for PartnerProductId {partnerProductBrandDTO.PartnerProductId}.");
                    return $"{SuccessResponse.UpdateSuccessMessage} {partnerProductBrandDTO.PartnerProductBrandId}";
                }
            }
            catch (ValidationException vex)
            {
                throw new Exception(vex.Message);
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-partner-product-brand-failed", ex);
                _logger.LogError(ex, "SavePartnerProductBrand failed for PartnerProductId {PartnerProductId}", partnerProductBrandDTO.PartnerProductId);
                throw;
            }
        }

        public async Task<string> GetResolvedBrandForClient(LoginDTO loginDTO)
        {
            try
            {
                return await _partnerBrandDAL.GetResolvedBrandForClient(
                    loginDTO.ClientId, loginDTO.BaseUri ?? "", loginDTO).ConfigureAwait(false);
            }
            catch (Exception)
            {
                throw;
            }
        }

    }
}