using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;
using Newtonsoft.Json;
using PartnerDAL.DTO.PartnerTerm;
using PartnerDAL.Query.PartnerTerm;

namespace PartnerDAL.CustomCode.PartnerTerm
{
    public class PartnerTermDAL : IPartnerTermDAL
    {
        private readonly IQueryExecutor _queryExecutor;
        private readonly IValidation _validation;

        public PartnerTermDAL(IQueryExecutor queryExecutor, IValidation validation)
        {
            _queryExecutor = queryExecutor;
            _validation = validation;
        }

        public async Task<string> GetTerminologyBundle(int clientId, int languageId, LoginDTO loginDTO)
        {
            try
            {
                var rows = await _queryExecutor.QueryAsync<PartnerTermDTO>(
                    loginDTO, PartnerTermQB.GET_TERMINOLOGY_BUNDLE,
                    new { ClientId = clientId, LanguageId = languageId }).ConfigureAwait(false);

                var bundle = rows.ToDictionary(r => r.TermKey, r => r.TermValue);
                return JsonConvert.SerializeObject(bundle);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetPartnerTerm(int partnerProductId, int languageId, LoginDTO loginDTO)
        {
            try
            {
                var rows = await _queryExecutor.QueryAsync<PartnerTermDTO>(
                    loginDTO, PartnerTermQB.GET_PARTNER_TERM,
                    new { PartnerProductId = partnerProductId, LanguageId = languageId }).ConfigureAwait(false);
                return JsonConvert.SerializeObject(rows);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<int> SavePartnerTerm(PartnerTermDTO dto, LoginDTO loginDTO)
        {
            try
            {
                return await _queryExecutor.ExecuteIdentityAsync(
                    loginDTO, PartnerTermQB.SAVE_PARTNER_TERM, dto).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                string error = await _validation.HandleException(ex, ErrorResponse.SaveErrorMessage).ConfigureAwait(false);
                throw new Exception(error);
            }
        }

        public async Task<int> UpdatePartnerTerm(PartnerTermDTO dto, LoginDTO loginDTO)
        {
            try
            {
                return await _queryExecutor.ExecuteAsync(
                    loginDTO, PartnerTermQB.UPDATE_PARTNER_TERM, dto).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                string error = await _validation.HandleException(ex, ErrorResponse.UpdateErrorMessage).ConfigureAwait(false);
                throw new Exception(error);
            }
        }

        public async Task<int> DeletePartnerTerm(int partnerTermId, LoginDTO loginDTO)
        {
            try
            {
                return await _queryExecutor.ExecuteAsync(
                    loginDTO, PartnerTermQB.DELETE_PARTNER_TERM,
                    new { PartnerTermId = partnerTermId }).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                string error = await _validation.HandleException(ex, ErrorResponse.DeleteErrorMessage).ConfigureAwait(false);
                throw new Exception(error);
            }
        }
    }
}