using AccountsDAL.DTO.WarehousePostingRule;
using AccountsDAL.Query.WarehousePostingRule;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.Response;
using GB5Shared.Validation;
using Newtonsoft.Json;

namespace AccountsDAL.CustomCode.WarehousePostingRule
{
    public class WarehousePostingRuleDAL : IWarehousePostingRuleDAL
    {
        private readonly IQueryExecutor _QueryExecutor;
        private readonly IValidation _Validation;

        public WarehousePostingRuleDAL(IQueryExecutor QueryExecutor, IValidation Validation)
        {
            _QueryExecutor = QueryExecutor;
            _Validation = Validation;
        }

        public async Task<string> GetWarehousePostingRule(int PostingRuleId, LoginDTO LoginDTO)
        {
            try
            {
                string sql = WarehousePostingRuleQB.GET_WAREHOUSEPOSTINGRULE;
                var parameters = new { postingruleid = PostingRuleId };
                var result = await _QueryExecutor.QuerySingleAsync<WarehousePostingRuleDTO>(LoginDTO, sql, parameters);
                return JsonConvert.SerializeObject(result);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetWarehousePostingRuleList(int? FactId, LoginDTO LoginDTO)
        {
            try
            {
                string sql = WarehousePostingRuleQB.GET_WAREHOUSEPOSTINGRULE_LIST;
                var parameters = new { FactId };
                var list = (await _QueryExecutor.QueryAsync<WarehousePostingRuleDTO>(LoginDTO, sql, parameters)
                                                 .ConfigureAwait(false)).ToList();
                return JsonConvert.SerializeObject(list);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<int?> GetExistingRuleIdForMeasure(int MeasureId, LoginDTO LoginDTO)
        {
            try
            {
                string sql = WarehousePostingRuleQB.GET_EXISTING_RULE_FOR_MEASURE;
                var parameters = new { MeasureId };
                var results = (await _QueryExecutor.QueryAsync<int>(LoginDTO, sql, parameters)
                                                    .ConfigureAwait(false)).ToList();
                return results.Count > 0 ? results[0] : (int?)null;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<List<string>> GetMeasureCodesForSameFact(int MeasureId, LoginDTO LoginDTO)
        {
            try
            {
                string sql = WarehousePostingRuleQB.GET_MEASURECODES_FOR_SAME_FACT;
                var parameters = new { MeasureId };
                var results = await _QueryExecutor.QueryAsync<string>(LoginDTO, sql, parameters).ConfigureAwait(false);
                return results.ToList();
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<int> SaveWarehousePostingRule(WarehousePostingRuleDTO WarehousePostingRuleDTO, LoginDTO LoginDTO)
        {
            try
            {
                const string sql = WarehousePostingRuleQB.SAVE_WAREHOUSEPOSTINGRULE;
                return await _QueryExecutor.ExecuteAsync(LoginDTO, sql, WarehousePostingRuleDTO);
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, $"{ErrorResponse.SaveErrorMessage}");
                throw new Exception(error);
            }
        }

        public async Task<int> UpdateWarehousePostingRule(WarehousePostingRuleDTO WarehousePostingRuleDTO, LoginDTO LoginDTO)
        {
            try
            {
                const string sql = WarehousePostingRuleQB.UPDATE_WAREHOUSEPOSTINGRULE;
                return await _QueryExecutor.ExecuteAsync(LoginDTO, sql, WarehousePostingRuleDTO);
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, $"{ErrorResponse.UpdateErrorMessage}");
                throw new Exception(error);
            }
        }

        public async Task<string> DeleteWarehousePostingRule(int PostingRuleId, LoginDTO LoginDTO)
        {
            try
            {
                string sql = WarehousePostingRuleQB.DELETE_WAREHOUSEPOSTINGRULE;
                var parameters = new { postingruleid = PostingRuleId };
                var result = await _QueryExecutor.ExecuteAsync(LoginDTO, sql, parameters);

                return result > 0
                    ? $"{SuccessResponse.DeleteSuccessMessage}"
                    : $"{ErrorResponse.DeleteNotFoundMessage}";
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, $"{ErrorResponse.DeleteErrorMessage}");
                throw new Exception(error);
            }
        }
    }
}