using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.QueryExecutor;
using GB5Shared.Resource.GB5Solution;
using GB5Shared.Resource.Response;
using GB5Shared.ResponseStandard;
using GB5Shared.Validation;
using MMDAL.DTO.Charge;
using MMDAL.Query.Charge;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace MMDAL.CustomCode.Charge
{
    public class ChargeDAL : IChargeDAL
    {
        private readonly IQueryExecutor _QueryExecutor;
        private readonly IValidation _Validation;

        public ChargeDAL(IQueryExecutor QueryExecutor, IValidation validation)
        {
            _QueryExecutor = QueryExecutor;
            _Validation = validation;
        }

        public async Task<string> GetCharge(int chargeId, LoginDTO loginDTO)
        {
            try
            {
                var sql = ChargeQB.GET_CHARGE;
                var parameters = new { ChargeId = chargeId };

                var chargeDict = new Dictionary<int, ChargeDTO>();

                var result = await _QueryExecutor.QueryMultiMapAsync<ChargeDTO, ChargeDetailDTO, ChargeDTO>(
                    loginDTO,
                    sql,
                    (parent, child) =>
                    {
                        if (!chargeDict.TryGetValue(parent.ChargeId, out var existingParent))
                        {
                            existingParent = parent;
                            existingParent.ChargeDetailArray = new List<ChargeDetailDTO>();
                            chargeDict[parent.ChargeId] = existingParent;
                        }

                        if (child != null && child.ChargeDetailId != 0)
                        {
                            existingParent.ChargeDetailArray.Add(child);
                        }

                        return existingParent;
                    },
                    parameters,
                    splitOn: "ChargeDetailId");
                var finalResult = chargeDict.Values.FirstOrDefault();
                return JsonConvert.SerializeObject(finalResult);
            }
            catch (Exception ex)
            {
                throw new Exception($"Failed to retrieve Charge data: {ex.Message}", ex);
            }
        }
        public async Task<string> GetSelectListCharge(CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                string sql = ChargeQB.GET_SELECTLIST_CHARGE;
                var parameters = new { };

                IEnumerable<ChargePicklistDTO> result = await _QueryExecutor.QueryAsync<ChargePicklistDTO>(LoginDTO, sql, parameters);
                string json = JsonConvert.SerializeObject(result);

                return json;
            }
            catch (Exception ex)
            {
                throw new Exception(MMResource.SelectListFailed, ex);
            }
        }

        public async Task<int> SaveCharge(ChargeDTO chargeDTO, LoginDTO loginDTO)
        {
            try
            {
                string sql = ChargeQB.SAVE_CHARGE;
                return await _QueryExecutor.ExecuteAsync(loginDTO, sql, chargeDTO);
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, $"{ErrorResponse.SaveErrorMessage}");
                throw new Exception(error);
            }
        }

        public async Task<int> UpdateCharge(ChargeDTO chargeDTO, LoginDTO loginDTO)
        {
            try
            {
                string sql = ChargeQB.UPDATE_CHARGE;
                return await _QueryExecutor.ExecuteAsync(loginDTO, sql, chargeDTO);
            }
            catch (Exception ex)
            {
                string error = await _Validation.HandleException(ex, $"{ErrorResponse.UpdateErrorMessage}");
                throw new Exception(error);
            }
        }


        public async Task<string> DeleteCharge(int ChargeId, LoginDTO LoginDTO)
        {
            try
            {
                string Sql = ChargeQB.DELETE_CHARGE;
                var parameters = new { ChargeId = ChargeId };
                int result = await _QueryExecutor.ExecuteAsync(LoginDTO, Sql, parameters);

                if (result > 0)
                {
                    return MMResource.DeletedSuccessfully;
                }
                else
                {
                    return MMResource.NotFoundToDelete;
                }
            }
            catch (Exception ex)
            {
                throw new Exception(MMResource.DeleteFailed, ex);
            }
        }
    }
}