using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using LCU.Library.Internal.ApiSecurity.Enums;
using LCU.Library.Internal.ApiSecurity.Models;
using LCU.Library.Internal.CoreApiWrapperLib.Configuration;
using LCU.Library.Internal.CoreApiWrapperLib.CoreApiUtilities;
using LCU.Library.Internal.CoreApiWrapperLib.CoreDbUtilities;
using LCU.Library.Internal.CoreApiWrapperLib.Exceptions;
using LCU.Library.Internal.CoreApiWrapperLib.Utilities;
using LCU.Library.Internal.CoreApiWrapperModel.Constants;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Accounts;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Collaterals;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreResponses;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreSoapRequests;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreSoapResponses;
using LCU.Library.Internal.LcuHttpClient.HttpRequest;
using AccountMaintenanceRequest = LCU.Library.Internal.CoreApiWrapperModel.CoreModels.CoreRequests.AccountMaintenanceRequest;

namespace LCU.Library.Internal.CoreApiWrapperLib.DataAccess
{
	public class AccountDao : BaseCoreDao, IAccountDao
    {
        private readonly ICoreDbExecution _coreDbExecution;
        private readonly CoreConfiguration _coreConfiguration;
        private readonly CoreApiConfiguration _coreApiConfiguration;
        private readonly CoreSoapApiConfiguration _coreSoapApiConfiguration;
        private readonly ApiSecurityConfiguration _apiSecurityConfiguration;
        private readonly IPostRequest _postRequest;
        private readonly IPutRequest _putRequest;

        private const string SoapClientKeyValue = "CoreSoapApiWrapper";

        private const string GetAccountAdminBranchUpdateQuery = "AccountBranch/GetAccountAdminBranchUpdateQuery";
        private const string GetVipSavingsToFundQuery = "Account/GetVipSavingsToFundQuery";
        private const string GetAccountOwnersByAccountNumber = "Account/GetAccountOwnersByAccountNumber";
        private const string GetAccountOwnersByOrganizationName = "Account/GetAccountOwnersByOrganizationName";
        private const string GetAccountOwnersByPersonName = "Account/GetAccountOwnersByPersonName";
        private const string GetAccountsToUpdateGroupAnalysisQuery = "Account/GetAccountsToUpdateGroupAnalysis";
        private const string GetAccountsByMajorMinorBranchAndStatusQuery = "Account/GetAccountsByMajorMinorBranchCodeAndStatus";
        private const string GetAccountsByRecentTransactionsQuery = "Account/GetAccountsByRecentTransactions";
        private const string DnaTimeFormat = "yyyy-MM-dd HH:mm:ss";


        public AccountDao(ICoreRequest coreRequest,
                          CoreConfiguration coreConfiguration,
                          ApiSecurityConfiguration apiSecurityConfiguration,
                          ICoreDbExecution coreDbExecution,
                          IPostRequest postRequest,
                          IPutRequest putRequest) : base(coreRequest)
        {
            _coreConfiguration = coreConfiguration;
            _apiSecurityConfiguration = apiSecurityConfiguration;
            _coreApiConfiguration = _coreConfiguration.CoreApiConfiguration;
            _coreSoapApiConfiguration = _coreConfiguration.CoreSoapApiConfiguration;
            _coreDbExecution = coreDbExecution;
            _postRequest = postRequest;
            _putRequest = putRequest;
        }

        /// <summary>
        /// Calls Core API to search based the memberagreenbr in the MemberAgreeNbrRequest model.
        /// Default Included: Graph
        /// </summary>
        /// <param name="coreRequestParameters"></param>
        /// <param name="request"></param>
        /// <returns>IEnumerable<Account></returns>
        public async Task<IEnumerable<Account>> FindByMemberAgreeNbr(CoreRequestParameters coreRequestParameters, MemberAgreeNbrRequest request)
        {
            var endpointParameters = HttpUtilities.BuildDictionaryOfNonNullValues(coreRequestParameters);
            var jsonBody = HttpUtilities.BuildJsonOfNonNullProperties(request);
            var result = await _coreRequest.PostRequestObject<CoreApiMessage<IEnumerable<Account>>>(
                                                    _coreApiConfiguration.CoreEndPointConfiguration.AccountsQueryMemberAgreement,
                                                    endpointParameters,
                                                    jsonBody);
            return result?.MessageBody;
        }

        /// <summary>
        /// Calls Core API to search based the AcctNbr in the AcctNbrRequest model.
        /// Default Included:  Standard, Graph
        /// </summary>
        /// <param name="coreRequestParameters"></param>
        /// <param name="request"></param>
        /// <returns>Account</returns>
        public async Task<Account> FindByAcctNbr(CoreRequestParameters coreRequestParameters, AcctNbrRequest request)
        {
            var endpointParameters = HttpUtilities.BuildDictionaryOfNonNullValues(coreRequestParameters);
            var jsonBody = HttpUtilities.BuildJsonOfNonNullProperties(request);
            var result = await _coreRequest.PostRequestObject<CoreApiMessage<Account>>(
                                                        _coreApiConfiguration.CoreEndPointConfiguration.AccountsQueryAccountDetail,
                                                        endpointParameters,
                                                        jsonBody);
            return result?.MessageBody;
        }       

        /// <summary>
        /// Calls Core API to search based the filled out AccountId.
        /// Default Included: Graph
        /// </summary>
        /// <param name="coreRequestParameters"></param>
        /// <param name="accountId"></param>
        /// <returns>IEnumerable<Collateral></returns>
        public async Task<IEnumerable<Collateral>> FindCollateralById(CoreRequestParameters coreRequestParameters, string accountId)
        {
            var endpointParameters = HttpUtilities.BuildDictionaryOfNonNullValues(coreRequestParameters);
            var endpoint = HttpUtilities.ReplaceRootParameter(_coreApiConfiguration.CoreEndPointConfiguration.AccountsCollateral,
                                                              RequestRootParameters.AccountId,
                                                              accountId);
            var result = await _coreRequest.GetRequestObject<CoreApiMessage<IEnumerable<Collateral>>>(endpoint, endpointParameters);
            return result?.MessageBody;
        }

        /// <summary>
        /// Calls Core Soap API and provides an AccountMaintenanceRequest to update an account.
        /// </summary>
        /// <param name="accountMaintenanceRequest"></param>
        public async Task PutAccountMaintenanceRequest(IEnumerable<AccountMaintenanceRequest> accountMaintenanceRequests)
        {
            var endpoint = HttpUtilities.BuildHttpsUri(_coreSoapApiConfiguration.CoreSoapApiWrapperHost, _coreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountMaintenanceRequest);
            var headers = LcuHttpClient.Utilities.HttpUtilities.GetApiKeyHeaders(SoapClientKeyValue, _apiSecurityConfiguration.ExtractApiKey(SoapClientKeyValue, ApiKeySetName.InternalKeySet));

            var accounts = accountMaintenanceRequests.Select(account => new MaintenanceAccount { AccountNumber = account.AccountNumber, DeliveryMethodCode = account.DeliveryMethod, IsAccountMaintenance = true }).ToArray();
            var accountMaintenanceSoapRequest = new CoreApiWrapperModel.CoreModels.CoreSoapRequests.AccountMaintenanceRequest
            {
                Accounts = accounts
            };

            var response = await _putRequest.Async<CoreApiWrapperModel.CoreModels.CoreSoapRequests.AccountMaintenanceRequest, HttpResponseMessage> (endpoint, accountMaintenanceSoapRequest, headers, 0);
            if (!response.IsSuccessStatusCode)
            {
                throw new AccountMaintenanceRequestException($"Request to update accounts with AccountMaintenanceRequest: {accountMaintenanceSoapRequest} failed with the following bad status code: {response.StatusCode}");
            }
        }

        public async Task<IEnumerable<string>> FindAdminBranchCodeChangeAccountNumbers()
        {
            var query = QueryUtilities.GetQuery(GetAccountAdminBranchUpdateQuery);
            return await _coreDbExecution.ExecuteQuery<string>(query);
        }

        public async Task<IEnumerable<string>> FindVipSavingsToFund()
        {
            var query = QueryUtilities.GetQuery(GetVipSavingsToFundQuery);
            return await _coreDbExecution.ExecuteQuery<string>(query);
        }

        public async Task<IEnumerable<string>> FindAccountsToUpdateAccountAnalysis()
        {
            var query = QueryUtilities.GetQuery(GetAccountsToUpdateGroupAnalysisQuery);
            return await _coreDbExecution.ExecuteQuery<string>(query);
        }

        public async Task<BasicResponse> UpdateAccountAnalysis(AccountAnalysisGroupMaintenanceRequest accountAnalysisGroupMaintenanceRequest)
        {
            var endpoint = HttpUtilities.BuildHttpsUri(_coreSoapApiConfiguration.CoreSoapApiWrapperHost, _coreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountAnalysisGroupMaintenanceRequest);
            var headers = LcuHttpClient.Utilities.HttpUtilities.GetApiKeyHeaders(SoapClientKeyValue, _apiSecurityConfiguration.ExtractApiKey(SoapClientKeyValue, ApiKeySetName.InternalKeySet));

            return await _putRequest.Async<AccountAnalysisGroupMaintenanceRequest, BasicResponse>(endpoint, accountAnalysisGroupMaintenanceRequest, headers, 0);
        }

        public async Task<BasicResponse> UpdateAccountBranch(AccountBranchUpdateRequest accountBranchUpdateRequest)
        {
            var endpoint = HttpUtilities.BuildHttpsUri(_coreSoapApiConfiguration.CoreSoapApiWrapperHost, _coreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountBranchUpdateRequest);
            var headers = LcuHttpClient.Utilities.HttpUtilities.GetApiKeyHeaders(SoapClientKeyValue, _apiSecurityConfiguration.ExtractApiKey(SoapClientKeyValue, ApiKeySetName.InternalKeySet));

            return await _putRequest.Async<AccountBranchUpdateRequest, BasicResponse>(endpoint, accountBranchUpdateRequest, headers, 0);
        }

        public async Task<BasicResponse> UpdateAccountLoanToValue(AccountLtvUpdateRequest accountLtvUpdateRequest)
        {
            var endpoint = HttpUtilities.BuildHttpsUri(_coreSoapApiConfiguration.CoreSoapApiWrapperHost, _coreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountLtvUpdateRequest);
            var headers = LcuHttpClient.Utilities.HttpUtilities.GetApiKeyHeaders(SoapClientKeyValue, _apiSecurityConfiguration.ExtractApiKey(SoapClientKeyValue, ApiKeySetName.InternalKeySet));

            return await _putRequest.Async<AccountLtvUpdateRequest, BasicResponse>(endpoint, accountLtvUpdateRequest, headers, 0);
        }

        public async Task<BasicResponse> UpdateAccountNickName(AccountNickNameUpdateRequest accountNickNameUpdateRequest)
        {
            var endpoint = HttpUtilities.BuildHttpsUri(_coreSoapApiConfiguration.CoreSoapApiWrapperHost, _coreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountNickNameUpdateRequest);
            var headers = LcuHttpClient.Utilities.HttpUtilities.GetApiKeyHeaders(SoapClientKeyValue, _apiSecurityConfiguration.ExtractApiKey(SoapClientKeyValue, ApiKeySetName.InternalKeySet));

            return await _putRequest.Async<AccountNickNameUpdateRequest, BasicResponse>(endpoint, accountNickNameUpdateRequest, headers, 0);
		}

		public async Task<BasicResponse> UpdateAccountContractDate(AccountContractDateUpdateRequest accountContractDateUpdateRequest)
		{
            var endpoint = HttpUtilities.BuildHttpsUri(_coreSoapApiConfiguration.CoreSoapApiWrapperHost, _coreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountContractDateUpdateRequest);
            var headers = LcuHttpClient.Utilities.HttpUtilities.GetApiKeyHeaders(SoapClientKeyValue, _apiSecurityConfiguration.ExtractApiKey(SoapClientKeyValue, ApiKeySetName.InternalKeySet));

			return await _putRequest.Async<AccountContractDateUpdateRequest, BasicResponse>(endpoint, accountContractDateUpdateRequest, headers, 0);
		}

		public async Task<List<ActivityAccountDetails>> GetActivityAccountDetailsByAccountNumbers(List<string> accountNumbers)
        {
            var query = QueryUtilities.GetQuery("ActivityAccountDetailsByAccountNbr");
            var accountActivityParams = new
            {
                accountNumbers = accountNumbers.ToArray()
            };
            var results =
                await _coreDbExecution.ExecuteQuery<ActivityAccountDetails, object>(query, accountActivityParams);
            return results.ToList();
        }

        public async Task<IEnumerable<AccountOwnership>> FindOwnersByAccountNumber(long accountNumber, DateTime creationDate)
        {
            var query = QueryUtilities.GetQuery(GetAccountOwnersByAccountNumber);
            var accountNumberParams = new
            {
                accountNumber = accountNumber.ToString(),
                createdDate = creationDate.Date.ToString(DnaTimeFormat)
            };
            return await _coreDbExecution.ExecuteQuery<AccountOwnership, object>(query, accountNumberParams);
        }

        public async Task<IEnumerable<AccountOwnership>> FindPrimaryOwnersByOrganizationName(string organizationName)
        {
            var query = QueryUtilities.GetQuery(GetAccountOwnersByOrganizationName);
            var organizationNameParams = new
            {
                organizationName = organizationName
            };
            return await _coreDbExecution.ExecuteQuery<AccountOwnership, object>(query, organizationNameParams);
        }

        public async Task<IEnumerable<AccountOwnership>> FindPrimaryOwnersByPersonName(string personName)
        {
            var query = QueryUtilities.GetQuery(GetAccountOwnersByPersonName);
            var personNameParams = new
            {
                personName = personName
            };
            return await _coreDbExecution.ExecuteQuery<AccountOwnership, object>(query, personNameParams);
        }

        /// <summary>
        /// Calls Core Soap API post to create a new person account.
        /// </summary>
        /// <param name="CreateAccountRequest"></param>
        public async Task<CreatedAccountResponse> AddPersonAccount(CreatePersonAccountRequest createPersonAccountRequest)
        {
            var endpoint = HttpUtilities.BuildHttpsUri(_coreSoapApiConfiguration.CoreSoapApiWrapperHost, _coreSoapApiConfiguration.CoreSoapEndpointConfiguration.PostPersonAccount);
            var headers = LcuHttpClient.Utilities.HttpUtilities.GetApiKeyHeaders(SoapClientKeyValue, _apiSecurityConfiguration.ExtractApiKey(SoapClientKeyValue, ApiKeySetName.InternalKeySet));

            return await _postRequest.Async<CreatePersonAccountRequest, CreatedAccountResponse>(endpoint, createPersonAccountRequest, headers, 0);
        }

        /// <summary>
        /// Calls Core Soap API post to create a new organization account.
        /// </summary>
        /// <param name="CreateAccountRequest"></param>
        public async Task<CreatedAccountResponse> AddOrganizationAccount(CreateOrganizationAccountRequest createOrganizationAccountRequest)
        {
            var endpoint = HttpUtilities.BuildHttpsUri(_coreSoapApiConfiguration.CoreSoapApiWrapperHost, _coreSoapApiConfiguration.CoreSoapEndpointConfiguration.PostOrganizationAccount);
            var headers = LcuHttpClient.Utilities.HttpUtilities.GetApiKeyHeaders(SoapClientKeyValue, _apiSecurityConfiguration.ExtractApiKey(SoapClientKeyValue, ApiKeySetName.InternalKeySet));

            return await _postRequest.Async<CreateOrganizationAccountRequest, CreatedAccountResponse>(endpoint, createOrganizationAccountRequest, headers, 0);
        }

        /// <summary>
        /// Calls Core Soap API and provides an OrganizationMaintenanceRequest to update an account.
        /// </summary>
        /// <param name="organizationMaintenanceRequest"></param>
        public async Task<BasicResponse> PutOrganizationMaintenanceRequest(OrganizationMaintenanceRequest organizationMaintenanceRequest)
        {
            var endpoint = HttpUtilities.BuildHttpsUri(_coreSoapApiConfiguration.CoreSoapApiWrapperHost, _coreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutOrganizationMaintenanceRequest);
            var headers = LcuHttpClient.Utilities.HttpUtilities.GetApiKeyHeaders(SoapClientKeyValue, _apiSecurityConfiguration.ExtractApiKey(SoapClientKeyValue, ApiKeySetName.InternalKeySet));

            return await _putRequest.Async<OrganizationMaintenanceRequest, BasicResponse>(endpoint, organizationMaintenanceRequest, headers, 0);
        }

        /// <summary>
        /// Calls Core Soap API and provides an AccountCreditReportTypeUpdateRequest to update an account.
        /// </summary>
        /// <param name="accountCreditReportTypeUpdateRequest"></param>
        public async Task<BasicResponse> UpdateAccountCreditReportType(AccountCreditReportTypeUpdateRequest accountCreditReportTypeUpdateRequest)
        {
            var endpoint = HttpUtilities.BuildHttpsUri(_coreSoapApiConfiguration.CoreSoapApiWrapperHost, _coreSoapApiConfiguration.CoreSoapEndpointConfiguration.PutAccountCreditReportTypeUpdateRequest);
            var headers = LcuHttpClient.Utilities.HttpUtilities.GetApiKeyHeaders(SoapClientKeyValue, _apiSecurityConfiguration.ExtractApiKey(SoapClientKeyValue, ApiKeySetName.InternalKeySet));

            return await _putRequest.Async<AccountCreditReportTypeUpdateRequest, BasicResponse>(endpoint, accountCreditReportTypeUpdateRequest, headers, 0);
        }

        public async Task<IEnumerable<AccountsByMajorMinorBranchAndStatusResponse>> GetAccountsByMajorMinorBranchAndStatus(AccountsByMajorMinorBranchAndStatusRequest request)
        {
            var query = QueryUtilities.GetQuery(GetAccountsByMajorMinorBranchAndStatusQuery);
            var queryParams = new
            {
                majorAccountTypes = request.MajorTypes.ToArray(),
                minorAccountTypes = request.MinorTypes.ToArray(),
                accountStatusCodes = request.AccountStatuses.ToArray(),
                branchOrgCodes = request.BranchCodes.ToArray()
            };
            return await _coreDbExecution.ExecuteQuery<AccountsByMajorMinorBranchAndStatusResponse, object>(query, queryParams);
        }

        public async Task<IEnumerable<AccountsByRecentTransactionsResponse>> GetAccountsByRecentTransactions(AccountsByRecentTransactionsRequest request)
        {
            var query = QueryUtilities.GetQuery(GetAccountsByRecentTransactionsQuery);
            var queryParams = new
            {
                startDate = request.StartDate,
                endDate = request.EndDate
            };
            return await _coreDbExecution.ExecuteQuery<AccountsByRecentTransactionsResponse, object>(query, queryParams);
        }
	}
}