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

namespace AccountsDAL.CustomCode.WarehouseFact
{
    public class WarehouseFactDAL : IWarehouseFactDAL
    {
        private readonly IQueryExecutor _QueryExecutor;
        private readonly IValidation _Validation;

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

        public async Task<string> GetWarehouseFact(int FactId, LoginDTO LoginDTO)
        {
            try
            {
                string sql = WarehouseFactQB.GET_WAREHOUSEFACT;
                var parameters = new { factid = FactId };
                var result = await _QueryExecutor.QuerySingleAsync<WarehouseFactDTO>(LoginDTO, sql, parameters);
                return JsonConvert.SerializeObject(result);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetWarehouseFactList(LoginDTO LoginDTO)
        {
            try
            {
                string sql = WarehouseFactQB.GET_WAREHOUSEFACT_LIST;
                var list = (await _QueryExecutor.QueryAsync<WarehouseFactDTO>(LoginDTO, sql)
                                                 .ConfigureAwait(false)).ToList();
                return JsonConvert.SerializeObject(list);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<int?> GetExistingFactIdForCode(string FactCode, int TenantId, LoginDTO LoginDTO)
        {
            try
            {
                string sql = WarehouseFactQB.GET_EXISTING_FACT_FOR_CODE;
                var parameters = new { FactCode, TenantId };
                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<bool> CheckTableExists(string TableName, LoginDTO LoginDTO)
        {
            try
            {
                string sql = WarehouseFactQB.CHECK_TABLE_EXISTS;
                var parameters = new { TableName };
                int count = await _QueryExecutor.ExecuteScalarAsync<int>(LoginDTO, sql, parameters).ConfigureAwait(false);
                return count > 0;
            }
            catch (Exception)
            {
                throw;
            }
        }

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

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

        public async Task<string> DeleteWarehouseFact(int FactId, LoginDTO LoginDTO)
        {
            try
            {
                string sql = WarehouseFactQB.DELETE_WAREHOUSEFACT;
                var parameters = new { factid = FactId };
                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);
            }
        }
    }
}