using CustomerOnlineV2.Api.API.TPApi;
using CustomerOnlineV2.Common.Helper;
using CustomerOnlineV2.Common.Models;
using CustomerOnlineV2.Common.Models.AccountModel;
using CustomerOnlineV2.Common.Models.HomeModel;
using CustomerOnlineV2.Common.Models.TransactionModel;
using CustomerOnlineV2.Repository.Repository.TransactionRepository;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace CustomerOnlineV2.Business.Business.TransactionBusiness
{
    public class TransactionBusiness : ITransactionBusiness
    {
        private readonly ILogger<TransactionBusiness> _logger;
        private readonly ITransactionRepository _transactionRepo;
        private readonly ITPApiService _tpApi;

        public TransactionBusiness(ILogger<TransactionBusiness> logger, ITransactionRepository transactionRepo, ITPApiService tpApi)
        {
            _logger = logger;
            _transactionRepo = transactionRepo;
            _tpApi = tpApi;
        }

        public async Task<ExrateResponse> DoCalculation(SendTransactionModel calcRequest, LoginResponse loginDetails)
        {
            ExrateResponse _response = new ExrateResponse();
            _logger.LogDebug("TRANSACTIONBUSINESS | DOCALCULATION | REQUEST | " + JsonConvert.SerializeObject(calcRequest));
            _response = ValidateExrateRequest(calcRequest);

            if (_response.ResponseCode == ResponseHelper.SUCCESS)
            {
                ExratePayoutDetailsModel _partnerDetails = await _transactionRepo.GetPayoutDetails(calcRequest, loginDetails);

                ExrateCalculateRequestModel _request = GenerateExrateParams(calcRequest, loginDetails, _partnerDetails);

                _response = await _tpApi.GetExRate(_request);
                _response.ProcessId = calcRequest.ProcessId;
                _response.tpExRate = _partnerDetails.TpExRate;
            }
            return _response;
        }

        public async Task<SendMoneyResponse> SendMoney(SendTransactionModel sendMoneyRequest, LoginResponse loginDetails)
        {
            SendMoneyResponse _response = new SendMoneyResponse();
            _logger.LogDebug("TRANSACTIONBUSINESS | SENDMONEY | REQUEST | " + JsonConvert.SerializeObject(sendMoneyRequest));
            _response = ValidateSendMoneyRequest(sendMoneyRequest);

            if (_response.ResponseCode == ResponseHelper.SUCCESS)
            {
                SendMoneyRequestModel _request = GenerateSendMoneyParams(sendMoneyRequest, loginDetails);

                _response = await _tpApi.SendMoney(_request);
            }
            return _response;
        }

        public async Task<SendMoneySuccessModel> GetTransactionDetails(string id, LoginResponse loginDetails)
        {
            return await _transactionRepo.GetTransactionDetails(id, loginDetails);
        }

        public async Task<TransactionDetailModel> GetReceiptData(string id, LoginResponse loginDetails)
        {
            return await _transactionRepo.GetReceiptData(id, loginDetails);
        }


        public async Task<SendMoneySuccessModel> SaveTranData(TrustPaymentRequest tranData, LoginResponse loginDetails)
        {
            return await _transactionRepo.SaveTranData(tranData, loginDetails);
        }

        public async Task<SendMoneySuccessModel> UpdateTranData(TrustPaymentRequest tranData, LoginResponse loginDetails)
        {
            return await _transactionRepo.UpdateTranData(tranData, loginDetails);
        }
        private SendMoneyRequestModel GenerateSendMoneyParams(SendTransactionModel sendMoneyRequest, LoginResponse loginDetails)
        {
            return new SendMoneyRequestModel
            {
                SenderId = loginDetails.UserId,
                SIpAddress = sendMoneyRequest.IpAddress,
                IsRealtime = "false",
                RequestBy = "mobile",
                Receiver = new Common.Models.TransactionModel.ReceiverModel { ReceiverId = sendMoneyRequest.Receiver },
                CDDI = new CDDIModel
                {
                    PurposeOfRemittance = sendMoneyRequest.PurposeOfRemit,
                    RelWithSender = "11331",
                    SourceOfFund = "11415"
                },
                SCountryId = Utilities.ReadFromAppSettings("OnlineAgent:SendingCountry"),
                PCountryId = sendMoneyRequest.ReceivingCountry,
                DeliveryMethodId = sendMoneyRequest.DeliveryMethod,
                CollCurr = Utilities.ReadFromAppSettings("OnlineAgent:CollCurrency"),
                PayoutCurr = sendMoneyRequest.PayoutCurrency,
                CollAmt = sendMoneyRequest.CollectAmount,
                PayoutAmt = sendMoneyRequest.PayoutAmount,
                TransferAmt = sendMoneyRequest.TransferAmount,
                ServiceCharge = sendMoneyRequest.ServiceCharge,
                ExRate = sendMoneyRequest.ExRate,
                CalBy = sendMoneyRequest.CalcBy,
                TpPCurr = sendMoneyRequest.PayoutCurrency,
                PayOutPartnerId = sendMoneyRequest.PayoutPartner,
                ForexSessionId = sendMoneyRequest.ForexSessionId,
                PaymentType = "wallet",
                //SchemeId = sendMoneyRequest.SchemeId,
                //TpExRate = sendMoneyRequest.TpExRate,
                ProcessId = sendMoneyRequest.ProcessId,
                UserName = loginDetails.UserName
            };
        }

        private ExrateCalculateRequestModel GenerateExrateParams(SendTransactionModel calcRequest, LoginResponse loginDetails, ExratePayoutDetailsModel partnerDetails)
        {
            return new ExrateCalculateRequestModel()
            {
                RequestedBy = "mobile",
                SCountry = Utilities.ReadFromAppSettings("OnlineAgent:SendingCountry"),
                SSuperAgent = Utilities.ReadFromAppSettings("OnlineAgent:SuperAgentId"),
                SBranch = Utilities.ReadFromAppSettings("OnlineAgent:BranchId"),
                CollCurrency = Utilities.ReadFromAppSettings("OnlineAgent:CollCurrency"),
                PayoutPartner = partnerDetails.PayoutPartner,
                PCountry = calcRequest.ReceivingCountry,
                PCountryName = partnerDetails.PayoutCountryName,
                pCountryCode = partnerDetails.PayoutCountryCode,
                PCurrency = partnerDetails.PayoutCurrency,
                SCurrency = Utilities.ReadFromAppSettings("OnlineAgent:CollCurrency"),
                CAmount = calcRequest.CollectAmount,
                PAmount = calcRequest.PayoutAmount,
                ServiceType = calcRequest.DeliveryMethod,
                CalcBy = calcRequest.CalcBy,
                PaymentType = "wallet",
                IsManualSc = "false",
                ManualSc = "0",
                IsExRateCalcByPartner = "false",
                ProcessFor = Utilities.ReadFromAppSettings("OnlineAgent:ProcessFor"),
                ProcessId = calcRequest.ProcessId,
                UserName = loginDetails.UserName,
                SessionId = calcRequest.ProcessId,
                SchemeId = calcRequest.SchemeId,
                TpExRate = partnerDetails.TpExRate
            };
        }

        private SendMoneyResponse ValidateSendMoneyRequest(SendTransactionModel sendMoneyRequest)
        {
            SendMoneyResponse _response = new SendMoneyResponse();
            _response.ResponseCode = ResponseHelper.SUCCESS;
            _response.ResponseMessage = ResponseMessageHelper.SUCCESS;

            if (string.IsNullOrEmpty(sendMoneyRequest.CalcBy))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param calcBy can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (sendMoneyRequest.CalcBy != "c")
            {
                if (sendMoneyRequest.CalcBy != "p")
                {
                    _response.ResponseCode = ResponseHelper.FAILED;
                    _response.ResponseMessage = "Param calcBy have invalid value!";

                    _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
                }
            }
            else if (string.IsNullOrEmpty(sendMoneyRequest.ReceivingCountry))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param ReceivingCountry can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (string.IsNullOrEmpty(sendMoneyRequest.DeliveryMethod))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param DeliveryMethod can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (string.IsNullOrEmpty(sendMoneyRequest.CollectAmount))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Params CollectAmount can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (string.IsNullOrEmpty(sendMoneyRequest.PayoutAmount))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Params PayoutAmount can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (string.IsNullOrEmpty(sendMoneyRequest.SchemeId))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param SchemeId can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (Utilities.TryParseDecimal(sendMoneyRequest.CollectAmount) <= 0)
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param CollectAmount has invalid value!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (Utilities.TryParseDecimal(sendMoneyRequest.PayoutAmount) <= 0)
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param PayoutAmount has invalid value!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (sendMoneyRequest.CalcBy == "c" && Utilities.TryParseDecimal(sendMoneyRequest.CollectAmount) <= 0)
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param CollectAmount has invalid value!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (sendMoneyRequest.CalcBy == "p" && Utilities.TryParseDecimal(sendMoneyRequest.PayoutAmount) <= 0)
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param PayoutAmount has invalid value!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (string.IsNullOrEmpty(sendMoneyRequest.Receiver))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Params Receiver can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (string.IsNullOrEmpty(sendMoneyRequest.PurposeOfRemit))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Params PurposeOfRemit can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (Convert.ToBoolean(sendMoneyRequest.TermsAndConditions) != true)
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param TermsAndConditions has invalid value!";

                _logger.LogError("TRANSACTIONBUSINESS | SENDMONEY.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }

            return _response;
        }

        private ExrateResponse ValidateExrateRequest(SendTransactionModel calcRequest)
        {
            ExrateResponse _response = new ExrateResponse();
            _response.ResponseCode = ResponseHelper.SUCCESS;
            _response.ResponseMessage = ResponseMessageHelper.SUCCESS;

            if (string.IsNullOrEmpty(calcRequest.CalcBy))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param calcBy can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | DOCALCULATION.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (calcRequest.CalcBy != "c")
            {
                if (calcRequest.CalcBy != "p")
                {
                    _response.ResponseCode = ResponseHelper.FAILED;
                    _response.ResponseMessage = "Param calcBy have invalid value!";

                    _logger.LogError("TRANSACTIONBUSINESS | DOCALCULATION.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
                }
            }
            else if (string.IsNullOrEmpty(calcRequest.ReceivingCountry))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param ReceivingCountry can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | DOCALCULATION.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (string.IsNullOrEmpty(calcRequest.DeliveryMethod))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param DeliveryMethod can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | DOCALCULATION.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (string.IsNullOrEmpty(calcRequest.CollectAmount))
            {
                if (string.IsNullOrEmpty(calcRequest.PayoutAmount))
                {
                    _response.ResponseCode = ResponseHelper.FAILED;
                    _response.ResponseMessage = "Params CollectAmount and PayoutAmount can not be emoty!";

                    _logger.LogError("TRANSACTIONBUSINESS | DOCALCULATION.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
                }
            }
            else if (string.IsNullOrEmpty(calcRequest.SchemeId))
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param SchemeId can not be emoty!";

                _logger.LogError("TRANSACTIONBUSINESS | DOCALCULATION.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (Utilities.TryParseDecimal(calcRequest.CollectAmount) <= 0)
            {
                if (Utilities.TryParseDecimal(calcRequest.PayoutAmount) <= 0)
                {
                    _response.ResponseCode = ResponseHelper.FAILED;
                    _response.ResponseMessage = "Param CollectAmount or PayoutAmount has invalid value!";

                    _logger.LogError("TRANSACTIONBUSINESS | DOCALCULATION.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
                }
            }
            else if (calcRequest.CalcBy == "c" && Utilities.TryParseDecimal(calcRequest.CollectAmount) <= 0)
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param CollectAmount has invalid value!";

                _logger.LogError("TRANSACTIONBUSINESS | DOCALCULATION.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            else if (calcRequest.CalcBy == "p" && Utilities.TryParseDecimal(calcRequest.PayoutAmount) <= 0)
            {
                _response.ResponseCode = ResponseHelper.FAILED;
                _response.ResponseMessage = "Param PayoutAmount has invalid value!";

                _logger.LogError("TRANSACTIONBUSINESS | DOCALCULATION.VALIDATEEXRATEREQUEST | REQUEST | " + JsonConvert.SerializeObject(_response));
            }
            return _response;
        }
        public async Task<CustomerTransactionList> GetTranData(LoginResponse loginDetails)
        {
            return await _transactionRepo.GetTranData(loginDetails);
        }
        public async Task<CustomerTransactionList> GetTransactionReportList(LoginResponse loginDetails , CustomerTransaction model)
        {
            return await _transactionRepo.GetTransactionReportList(loginDetails, model);
        }
    }
}