<?php

namespace App\Http\Controllers;

use App\Models\AgentPlus;
use App\Models\CodeGenerer;
use App\Models\ConfigWallet;
use App\Models\NetworksAgent;
use App\Models\PayingNetwork;
use App\Models\TypeIlinkTransaction;
use App\Models\PaliersConfigWallet;
use App\Models\User;
use App\Models\Wallet;
use App\Models\WalletAgent;
use App\Models\WalletIlinkTransaction;
use App\Models\WalletsUser;
use App\Models\WalletTransaction;
use App\Traits\ApiResponser;
use App\Traits\Helper;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\DB;
use function GuzzleHttp\Promise\all;

class iLinkTransactionController extends Controller
{
    use ApiResponser;
    use Helper;

    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }

    public function add(Request $request)
    {
        $transaction = new WalletIlinkTransaction();
        $this->validate($request, [
            'type' => 'required|integer|min:0|not_in:0',
            'id_wallet_agent' => 'required_without:id_wallet_user|integer|min:0|not_in:0',
            'id_wallet_user' => 'required_without:id_wallet_agent|integer|min:0|not_in:0',
            'id_network' => 'required_with:id_wallet_user|integer|min:0|not_in:0',
            'password' => 'required',
            'montant' => 'required|numeric|min:0|not_in:0',
        ]);
        $type = TypeIlinkTransaction::findOrFail($request->type);

        if (isset($request->id_wallet_agent)) {
            $walletAgent = Wallet::findOrFail($request->get('id_wallet_agent'));
            $network_agent = NetworksAgent::findOrFail($walletAgent->id_networkAgent);
            // Configuratrion du wallet
            $config = ConfigWallet::where('id_network', $network_agent->network_id)->firstOrFail();

            // Recuperation des wallets hyperviseur et superviseur
            $codeGenerer = CodeGenerer::findOrFail($network_agent->codeGenerer_id);
            $superviseur = AgentPlus::where('code_membre', $codeGenerer->code_parrain)->firstOrFail();
            $hyperviseur = AgentPlus::where('code_membre', $superviseur->code_parrain)->firstOrFail();

            $wallet_agent_sup = WalletAgent::where('agent_id', $superviseur->id)->firstOrFail();
            $wallet_agent_hyp = WalletAgent::where('agent_id', $hyperviseur->id)->firstOrFail();
            $walletSuperviseur = Wallet::findOrFail($wallet_agent_sup->wallet_id);
            $walletHyperviseur = Wallet::findOrFail($wallet_agent_hyp->wallet_id);
        } elseif (isset($request->id_wallet_user)) {
            $config = ConfigWallet::where('id_network', $request->id_network)->firstOrFail();

            $hyperviseur = AgentPlus::where('category', 'hyper')->where('network_id', $request->id_network)->firstOrFail();
            $wallet_agent_hyp = WalletAgent::where('agent_id', $hyperviseur->id)->firstOrFail();
            $walletHyperviseur = Wallet::findOrFail($wallet_agent_hyp->wallet_id);
        }


        $taxesNationales = array_values(array_filter($config->taxes->all(), function ($tax) {
            return $tax->destination == 'national';
        }));

        $taxesInternationales = array_values(array_filter($config->taxes->all(), function ($tax) {
            return $tax->destination == 'international';
        }));


        $plr_user_wallet_wallet = $this->getPaliers($config->paliers_config_wallets->all(), "user_wallet_wallet_international");
        $plr_user_wallet_cash = $this->getPaliers($config->paliers_config_wallets->all(), "user_wallet_cash_international");
        $plr_agent_depot_wallet_ilink = $this->getPaliers($config->paliers_config_wallets->all(), "agent_depot_wallet_ilink_international");
        $plr_agent_depot_autre_wallet = $this->getPaliers($config->paliers_config_wallets->all(), "agent_depot_autre_wallet_international");
        $plr_agent_cash_cash = $this->getPaliers($config->paliers_config_wallets->all(), "agent_cash_cash_international");

        $plr_user_wallet_wallet_national = $this->getPaliers($config->paliers_config_wallets->all(), "user_wallet_wallet_national");
        $plr_user_wallet_cash_national = $this->getPaliers($config->paliers_config_wallets->all(), "user_wallet_cash_national");
        $plr_agent_depot_wallet_ilink_national = $this->getPaliers($config->paliers_config_wallets->all(), "agent_depot_wallet_ilink_national");
        $plr_agent_depot_autre_wallet_national = $this->getPaliers($config->paliers_config_wallets->all(), "agent_depot_autre_wallet_national");
        $plr_agent_cash_cash_national = $this->getPaliers($config->paliers_config_wallets->all(), "agent_cash_cash_national");


        $data = $request->all();
        if (isset($request->cvv) && !is_numeric($request->cvv))
            return $this->errorResponse('errors.invalid_cvv');

        $transaction->fill($data);
        // Client API
        $client = new \GuzzleHttp\Client([
            'base_uri' => env('VISA_API_URL'),
            'auth' => [env('VISA_API_USERNAME'), env('VISA_API_PASSWORD')]
        ]);

        switch ($type->id) {
            case 1: //User - Envoi wallet à wallet
                $this->validate($request, $transaction->send_wallet_wallet_rules());
                $walletUser = WalletsUser::findOrFail($request->id_wallet_user);
                $user = User::findOrFail($walletUser->idUser);
                if ($this->checkPassword($request->password, $user->encrypted_password, $user->salt)) {
                    $transaction->frais = $frais = ($request->init_country != $request->final_country) ? $this->calculateFees($plr_user_wallet_wallet, $request->montant) : $this->calculateFees($plr_user_wallet_wallet_national, $request->montant);
                    $transaction->taxe = $taxe = ($request->init_country != $request->final_country) ? $this->calculateTax($taxesInternationales, $frais) : $this->calculateTax($taxesNationales, $frais);
                    $transaction->montant_depot = $montantDepot = $transaction->montant - $frais - $taxe;
                    $configPayeur = ConfigWallet::where('id_network', $request->network_destinataire)->firstOrFail();
                    $reseauPayeur = PayingNetwork::where('id_network', $request->network_destinataire)->where('id_configWallet', $config->id)->firstOrFail();
                    if($request->init_country != $request->final_country){
                        $transaction->part_reseau_payeur = $frais * $reseauPayeur->taux_partage / 100;
                        $transaction->part_reseau_emetteur = $frais - $transaction->part_reseau_payeur;
                    }else{
                        $transaction->part_reseau_payeur = 0;
                        $transaction->part_reseau_emetteur = $frais;
                    }
                    $transaction->commission_hyp = $transaction->part_reseau_emetteur;
                    $reseauPayeur->balance_com += $transaction->part_reseau_payeur;
                    if ($configPayeur->type == 'ilink') {
                        $walletHyperviseur->balance_com += $transaction->part_reseau_emetteur;
                        $destinataire = User::where('user_code', $request->id_destinataire)->first();
                        if($destinataire) { // Si c'est un wallet ilink
                            $walletDestinataire = WalletsUser::where('idUser', $destinataire->id)->firstOrFail();
                            $walletDestinataire->balance += $montantDepot;
                            $walletDestinataire->save();
                        } else {
                            return $this->errorResponse(trans('errors.wallet_not_defined'));
                        }
                        $walletUser->balance -= $transaction->montant;
                        //Hyperviseur payeur
                        $hyperviseurPayeur = AgentPlus::where('category', 'hyper')->where('network_id',  $request->network_destinataire)->firstOrFail();
                        if($hyperviseurPayeur->id == $hyperviseur->id){ //Si c'est le reseau payeur est aussi emetteur
                            $walletHyperviseur->balance_com += $transaction->part_reseau_payeur;
                            $reseauPayeur->balance_com += $transaction->part_reseau_emetteur;
                        }else{
                            $wallet_agent_hypPayeur = WalletAgent::where('agent_id', $hyperviseurPayeur->id)->firstOrFail();
                            $walletHyperviseurPayeur = Wallet::findOrFail($wallet_agent_hypPayeur->wallet_id);
                            $walletHyperviseurPayeur->balance_com += $transaction->part_reseau_payeur;
                            $walletHyperviseurPayeur->save();
                        }
                        $walletHyperviseur->save();
                        $walletUser->save();
                    } else {
                        //Emettre requete SSL vers wallet extene correspondant pour recharger le compte dont l'id est :
//                        $transaction->id_destinataire ;
                        // et le montant est:
//                        $montantDepot;
                    }
                    $reseauPayeur->save();
                    $transaction->save();
                    $this->sendMail($user->email, trans('messages.successful_transaction'), trans('messages.successful_user_send_to_wallet',
                        ['id_transaction' => $transaction->id, 'amount' => $this->toMoney($transaction->montant, $request->init_country), 'net_init' => $this->toMoney($montantDepot, $request->init_country),
                            'net_final' => $this->convertMoney($montantDepot, $request->init_country, $request->final_country), 'fees' => $this->toMoney($frais + $taxe, $request->init_country),
                            'init_country'=>$this->getCountryName($request->init_country) , 'final_country'=>$this->getCountryName($request->final_country),
                            'sender_code' => $user->user_code, 'receiver_code' => $transaction->id_destinataire]));
                    return $this->successResponse(trans('messages.successful_transaction'));
                } else {
                    return $this->errorResponse(trans('messages.incorrect_user_password'));
                }
                break;
            case 2: //User - Envoi de wallet à carte

                break;
            case 3: //User - Envoi de wallet à cash

                break;
            case 4: //User - Envoi de wallet à banque
                // Non disponible
                //Pas de taxes
                break;
//		case 5: //User - Envoi de carte à wallet
//			$frais =$montant * $config->taux_com_user_carte_wallet / 100;
////			$taxe = ($init_country != $final_country) ? $this->calculateTax($taxesInternationales , $frais) : $this->calculateTax($taxesNationales ,$frais);
//			break;
//		case 6: //User - Envoi de carte à cash
//			$frais =$montant * $config->taux_com_user_carte_cash / 100;
////			$taxe = ($init_country != $final_country) ? $this->calculateTax($taxesInternationales , $frais) : $this->calculateTax($taxesNationales ,$frais);
//			break;
            case 9: // User - Retrait de wallet en cash

                break;
            case 10: //User - Retrait de carte vers wallet

                break;
            case 11: // User - Retrait de carte vers cash

                break;
            case 12: // Agent  - Retrait en cash
                $this->validate($request, $transaction->remove_cash_rules());
                $agent = AgentPlus::findOrFail($network_agent->agent_id);
                if ($this->checkPassword($request->password, $agent->encrypted_password, $agent->salt)) {
                    $transaction = WalletIlinkTransaction::find($request->id_transaction);
                    if ($transaction) {
                        if ($transaction->status_retrait == 0) {
                            if ($this->checkPassword($request->code_retrait, $transaction->encrypted_code_retrait, $transaction->code_retrait_salt)) {
                                if ($transaction->montant_retrait == $request->montant) {
                                    $part_ag = floatval($transaction->frais * $config->taux_com_ag_retrait_cash / 100);
                                    $part_sup = floatval($transaction->frais * $config->taux_com_sup_retrait_cash / 100);
                                    $walletAgent->balance_princ += $transaction->montant_retrait;
                                    $walletAgent->balance_com += $part_ag;
                                    $walletSuperviseur->balance_com += $part_sup;
                                    $walletHyperviseur->balance_com -= ($part_ag + $part_sup);
                                    $transaction->status_retrait = 1;
                                    $transaction->date_retrait = new \DateTime();
                                    $walletAgent->save();
                                    $walletSuperviseur->save();
                                    $walletHyperviseur->save();
                                    $transaction->save();
                                    return $this->successResponse(trans('messages.successful_transaction'));
                                } else {
                                    return $this->errorResponse('Montant de retrait incorrect');
                                }
                            } else {
                                return $this->errorResponse('Code de retrait invalide');
                            }
                        } else {
                            return $this->errorResponse('Retrait déjà éffectuée');
                        }
                    } else {
                        return $this->errorResponse('Cette transaction n\'existe pas', Response::HTTP_NOT_FOUND);
                    }
                } else {
                    return $this->errorResponse(trans('messages.incorrect_user_password'));
                }
                break;
            case 13: // Agent - Retrait de la carte vers cash
                $this->validate($request, $transaction->card_rules());
                $agent = AgentPlus::findOrFail($network_agent->agent_id);
                if ($this->checkPassword($request->password, $agent->encrypted_password, $agent->salt)) {
                    $expiration_date = \DateTime::createFromFormat('m/y', $request->expiration_date);
                    if (!$expiration_date)
                        $expiration_date = new \DateTime();
                    $transaction->expiration_date = $expiration_date;

                    $frais = floatval($request->montant * $config->taux_com_wallet_ag_carte_cash / 100);
                    $montantRetrait = $transaction->montant + $frais;
                    $transaction->montant_retrait = $montantRetrait;
                    $body['amount'] = $montantRetrait;
                    $body['card_number'] = $request->numero_carte;
                    $body['cvv'] = $request->cvv;
                    $body['expiry_date'] = $expiration_date->format('Y-m');

//                    $response = $client->post('fund-transfer-api/v1/transaction/pull', ['json' => $body]);
                    $code = 200; // $response->getStatusCode();

                    if ($code == 200) {
                        $banqueCommission = floatval($frais * $config->taux_com_banque_retrait_carte_cash / 100);
                        $transaction->commission_banque = $banqueCommission;
                        // 2---> Emmètre via API sécurisé SSL une requête de débit de notre
                        //compte marchand du (Part de la banque partenaire en %
                        //pour le dépôtqui s’applique sur les frais minimum) et créditer
                        //le compte des opérations défini avec notre banque
                        //partenaire

                        $walletAgent->balance_princ += $transaction->montant;

                        $agentCommission = floatval($frais * $config->taux_com_ag_retrait_carte_cash / 100);
                        $superviseurCommission = floatval($frais * $config->taux_com_sup_retrait_carte_cash / 100);
                        $hyperviseurCommission = floatval($frais * $$config->taux_com_hyp_retrait_carte_cash / 100);

                        $walletAgent->balance_com += $agentCommission;
                        $transaction->commission_ag = $agentCommission;
                        $walletSuperviseur->balance_com += $superviseurCommission;
                        $transaction->commission_sup = $superviseurCommission;
                        $walletHyperviseur->balance_com += $hyperviseurCommission;
                        $transaction->commission_hyp = $hyperviseurCommission;
                        $transaction->id_wallet_ag = $walletAgent->id;
                        $transaction->id_wallet_sup = $walletSuperviseur->id;
                        $transaction->id_wallet_hyp = $walletHyperviseur->id;
                        $transaction->frais = $frais;
                        $transaction->date = new \DateTime();
                        $walletAgent->save();
                        $walletSuperviseur->save();
                        $walletHyperviseur->save();
                        $transaction->save();
                        return $this->successResponse(trans('messages.successful_transaction'));

                    } else {
                        return $this->errorResponse(trans('errors.visa_api_failed'), Response::HTTP_INTERNAL_SERVER_ERROR);
                    }
                } else {
                    return $this->errorResponse(trans('messages.incorrect_user_password'));
                }
                break;
            case 14: // Agent - Envoi de cash vers wallet iLink
                $this->validate($request, $transaction->cash_wallet_rules());
                $agent = AgentPlus::findOrFail($network_agent->agent_id);
                if ($this->checkPassword($request->password, $agent->encrypted_password, $agent->salt)) {
                    $user = User::where('user_code', $request->user_code)->firstOrFail();
                    $walletUser = WalletsUser::where('idUser', $user->id)->firstOrFail();

                    $frais = ($request->init_country != $request->final_country) ? $this->calculateFees($plr_agent_depot_wallet_ilink, $request->montant) : $this->calculateFees($plr_agent_depot_wallet_ilink_national, $request->montant);
                    $taxe = ($request->init_country != $request->final_country) ? $this->calculateTax($taxesInternationales, $frais) : $this->calculateTax($taxesNationales, $frais);
                    $montantDepot = $request->montant - $frais - $taxe;
                    $transaction->montant_depot = $montantDepot;
                    $walletUser->balance += $montantDepot;
                    $commisionAgent = floatval($frais * $config->taux_com_ag_envoi_cash / 100);
                    $commisionSuper = floatval($frais * $config->taux_com_sup_envoi_cash / 100);
                    $commisionHyper = floatval($frais * $config->taux_com_hyp_envoi_cash / 100);
                    $walletAgent->balance_princ -= $transaction->montant;
                    $walletAgent->balance_com += $commisionAgent;
                    $transaction->commission_ag = $commisionAgent;
                    $walletSuperviseur->balance_com += $commisionSuper;
                    $transaction->commission_sup = $commisionSuper;
                    $walletHyperviseur->balance_com += $commisionHyper;
                    $transaction->commission_hyp = $commisionHyper;
                    $transaction->taxe = $taxe;
                    $transaction->frais = $frais;
                    $transaction->date = new \DateTime();
                    $walletUser->save();
                    $walletAgent->save();
                    $walletSuperviseur->save();
                    $walletHyperviseur->save();
                    $transaction->id_wallet_user = $walletUser->id;
                    $transaction->id_wallet_ag = $walletAgent->id;
                    $transaction->id_wallet_sup = $walletSuperviseur->id;
                    $transaction->id_wallet_hyp = $walletHyperviseur->id;
                    $transaction->save();
                    $this->sendMail($user->email, trans('messages.successful_transaction'), trans('messages.successful_deposit_ilink',
                        ['id_transaction' => $transaction->id, 'amount' => $this->toMoney($transaction->montant, $request->init_country), 'net_init' => $this->toMoney($montantDepot, $request->init_country),
                            'net_final' => $this->convertMoney($montantDepot, $request->init_country, $request->final_country), 'fees' => $this->toMoney($frais, $request->init_country), 'tax' => $this->toMoney($taxe, $request->init_country),
                            'user_code' => $request->user_code]));
                    return $this->successResponse(trans('messages.successful_transaction'));
                } else {
                    return $this->errorResponse(trans('messages.incorrect_user_password'));
                }
                break;
            case 15: // Agent - Envoi de cash vers autre wallet
                $this->validate($request, $transaction->cash_cash_rules());
                $agent = AgentPlus::findOrFail($network_agent->agent_id);
                if ($this->checkPassword($request->password, $agent->encrypted_password, $agent->salt)) {
                    $frais = ($request->init_country != $request->final_country) ? $this->calculateFees($plr_agent_depot_autre_wallet, $request->montant) : $this->calculateFees($plr_agent_depot_autre_wallet_national, $request->montant);
                    $taxe = ($request->init_country != $request->final_country) ? $this->calculateTax($taxesInternationales, $frais) : $this->calculateTax($taxesNationales, $frais);
                    $montantDepot = $request->montant - $frais - $taxe;
                    $transaction->montant_depot = $montantDepot;
                    //Emettre une trame securise pour crediter le wallet utilisateur
//                    $walletUser->balance += $montantDepot;
//                    $transaction->id_destinataire = r
                    $commisionAgent = floatval($frais * $config->taux_com_ag_envoi_cash / 100);
                    $commisionSuper = floatval($frais * $config->taux_com_sup_envoi_cash / 100);
                    $commisionHyper = floatval($frais * $config->taux_com_hyp_envoi_cash / 100);
                    $walletAgent->balance_princ -= $transaction->montant;
                    $walletAgent->balance_com += $commisionAgent;
                    $transaction->commission_ag = $commisionAgent;
                    $walletSuperviseur->balance_com += $commisionSuper;
                    $transaction->commission_sup = $commisionSuper;
                    $walletHyperviseur->balance_com += $commisionHyper;
                    $transaction->commission_hyp = $commisionHyper;
                    $transaction->taxe = $taxe;
                    $transaction->frais = $frais;
                    $transaction->date = new \DateTime();

                    $walletAgent->save();
                    $walletSuperviseur->save();
                    $walletHyperviseur->save();
                    $transaction->id_wallet_ag = $walletAgent->id;
                    $transaction->id_wallet_sup = $walletSuperviseur->id;
                    $transaction->id_wallet_hyp = $walletHyperviseur->id;
                    $transaction->save();
                } else {
                    return $this->errorResponse(trans('messages.incorrect_user_password'));
                }
                break;
            case 16: // Agent - Envoi de cash vers une carte visa
                $this->validate($request, $transaction->card_rules());
                $agent = AgentPlus::findOrFail($network_agent->agent_id);
                if ($this->checkPassword($request->password, $agent->encrypted_password, $agent->salt)) {
                    $expiration_date = \DateTime::createFromFormat('m/y', $request->expiration_date);
                    if (!$expiration_date)
                        $expiration_date = new \DateTime();
                    $transaction->expiration_date = $expiration_date;

                    $frais = $request->montant * $config->taux_com_wallet_ag_envoi_cash_carte / 100;
                    $montantDepot = $transaction->montant - $frais;
                    $transaction->montant_depot = $montantDepot;
                    $body['amount'] = $montantDepot;
                    $body['card_number'] = $request->numero_carte;
                    $body['cvv'] = $request->cvv;
                    $body['expiry_date'] = $expiration_date->format('Y-m');

                    $response = $client->post('fund-transfer-api/v1/transaction/push', ['json' => $body]);
                    $code = $response->getStatusCode();

                    if ($code == 200) {
                        $banqueCommission = floatval($frais * $config->taux_com_banque_depot_cash_carte / 100);
                        $transaction->commission_banque = $banqueCommission;
                        // 2---> Emmètre via API sécurisé SSL une requête de débit de notre
                        //compte marchand du (Part de la banque partenaire en %
                        //pour le dépôtqui s’applique sur les frais minimum) et créditer
                        //le compte des opérations défini avec notre banque
                        //partenaire

                        $walletAgent->balance_princ -= $transaction->montant;

                        $agentCommission = floatval($frais * $config->taux_com_ag_depot_cash_carte / 100);
                        $superviseurCommission = floatval($frais * $config->taux_com_sup_depot_cash_carte / 100);
                        $hyperviseurCommission = floatval($frais * $config->taux_com_hyp_depot_cash_carte / 100);

                        $walletAgent->balance_com += $agentCommission;
                        $transaction->commission_ag = $agentCommission;
                        $walletSuperviseur->balance_com += $superviseurCommission;
                        $transaction->commission_sup = $superviseurCommission;
                        $walletHyperviseur->balance_com += $hyperviseurCommission;
                        $transaction->commission_hyp = $hyperviseurCommission;
                        $transaction->id_wallet_ag = $walletAgent->id;
                        $transaction->id_wallet_sup = $walletSuperviseur->id;
                        $transaction->id_wallet_hyp = $walletHyperviseur->id;
                        $transaction->frais = $frais;
                        $transaction->date = new \DateTime();
                        $walletAgent->save();
                        $walletSuperviseur->save();
                        $walletHyperviseur->save();
                        $transaction->save();
                        return $this->successResponse(trans('messages.successful_transaction'));

                    } else {
                        return $this->errorResponse(trans('errors.visa_api_failed'), Response::HTTP_INTERNAL_SERVER_ERROR);
                    }
                } else {
                    return $this->errorResponse(trans('messages.incorrect_user_password'));
                }
                break;
            case 17: // Agent - Envoi de cash vers cash
                $this->validate($request, array_merge($transaction->cash_cash_rules(), [
                    'email_emetteur' => 'required',
                ]));
                $agent = AgentPlus::findOrFail($network_agent->agent_id);
                if ($this->checkPassword($request->password, $agent->encrypted_password, $agent->salt)) {
                    $frais = ($request->init_country != $request->final_country) ? $this->calculateFees($plr_agent_cash_cash, $request->montant) : $this->calculateFees($plr_agent_cash_cash_national, $request->montant);
                    $taxe = ($request->init_country != $request->final_country) ? $this->calculateTax($taxesInternationales, $frais) : $this->calculateTax($taxesNationales, $frais);
                    $montantRetrait = $request->montant - $frais - $taxe;
                    $commisionAgent = floatval($frais * $config->taux_com_ag_envoi_cash / 100);
                    $commisionSuper = floatval($frais * $config->taux_com_sup_envoi_cash / 100);
                    $commisionHyper = floatval($frais * $config->taux_com_hyp_envoi_cash / 100);

                    $transaction->montant_retrait = $montantRetrait;
                    $walletAgent->balance_com += $commisionAgent;
                    $transaction->commission_ag = $commisionAgent;
                    $walletSuperviseur->balance_com += $commisionSuper;
                    $transaction->commission_sup = $commisionSuper;
                    $walletHyperviseur->balance_com += $commisionHyper;
                    $transaction->commission_hyp = $commisionHyper;
                    $transaction->id_wallet_ag = $walletAgent->id;
                    $transaction->id_wallet_sup = $walletSuperviseur->id;
                    $transaction->id_wallet_hyp = $walletHyperviseur->id;

                    $code_retrait = $this->random_string();
                    $hash = $this->hashSSHA($code_retrait);
                    $transaction->encrypted_code_retrait = $hash['encrypted'];
                    $transaction->code_retrait_salt = $hash['salt'];

                    $walletAgent->balance_princ -= $transaction->montant;
                    $transaction->frais = $frais;
                    $transaction->taxe = $taxe;
                    $transaction->date = new \DateTime();
                    $transaction->status_retrait = 0;
                    $walletAgent->save();
                    $walletSuperviseur->save();
                    $walletHyperviseur->save();
                    $transaction->save();
                    $this->sendMail($request->email_emetteur, trans('messages.successful_transaction'), trans('messages.successful_send_cash',
                        ['sender_name' => $request->prenom_emetteur . ' ' . $request->nom_emetteur, 'receiver_name' => $request->prenom_destinataire . ' ' . $request->prenom_destinataire,
                            'id_transaction' => $transaction->id, 'amount' => $this->toMoney($transaction->montant, $request->init_country), 'net_init' => $this->toMoney($montantRetrait, $request->init_country),
                            'net_final' => $this->convertMoney($montantRetrait, $request->init_country, $request->final_country), 'fees' => $this->toMoney($frais, $request->init_country), 'tax' => $this->toMoney($taxe, $request->init_country),
                            'code' => wordwrap($code_retrait, 4, ' ', true)]));
                    return $this->successResponse(trans('messages.successful_transaction'));
                } else {
                    return $this->errorResponse(trans('messages.incorrect_user_password'));
                }
                break;
            case 18: // Agent - Envoi de cash vers banque
                // Indisponible
                break;
        }

    }

    public function lastTransactions($id_wallet)
    {
        $transactions = WalletTransaction::where('id_wallet', $id_wallet)->orderBy('date', 'desc')->limit(10)
            ->get(['type', DB::raw('\'wallet\' as source'), 'montant', 'numCarte AS destinataire', 'date', 'id']);
        return $this->successResponse($transactions);
    }

    public function calculateCommission(Request $request)
    {
        $rules = [
            'id_wallet' => 'required|integer|min:1',
            'montant' => 'required|numeric|min:0|not_in:0',
            'type' => 'required|in:credit,debit',
        ];

        $this->validate($request, $rules);

        $walletAgent = Wallet::findOrFail($request->get('id_wallet'));
        $network_agent = NetworksAgent::findOrFail($walletAgent->id_networkAgent);
        // Configuratrion du wallet
        $config = ConfigWallet::where('id_network', $network_agent->network_id)->firstOrFail();
        $commission = null;
        if ($request->type == 'credit') {
            //Depot
            $commission = ($request->montant * $config->taux_com_client_depot / 100) + $config->frais_min_banque_depot;
            $data['montant_calcule'] = $request->montant - $commission;
        } elseif ($request->type == 'debit') {
            // Retrait
            $commission = $request->montant * $config->taux_com_client_retrait / 100;
            $data['montant_calcule'] = $request->montant + $commission;
        }

        $data['commission'] = $commission;
        return $this->successResponse($data);
    }


    private function getPaliers(array $paliers, $type)
    {
        return array_values(array_filter($paliers, function ($palier) use ($type) {
            return $palier->type == $type;
        }));
    }

    //Calcul des frais internationaux
    private function calculateFees(array $paliers, $montant)
    {
        $size = sizeof($paliers);

        $min = $paliers[0]->min;
        $max = $size > 0 ? $paliers[$size - 1]->max : 0;
        $palier = null;
        foreach ($paliers as $p) {
            if ($montant >= $p->min && $montant <= $p->max) {
                $palier = $p;
                break;
            }
        }

        if ($palier) {
            return (($palier->min + $palier->max) / 2 * $palier->taux / 100);
        } else {
            if ($montant < $min)
                return $min * $paliers[0]->taux / 100;
            else if ($montant > $max)
                return $max * $paliers[$size - 1]->taux / 100;
        }
    }


//Calcul des taxes
    private function calculateTax(array $taxes, $frais)
    {
        $sommeTaux = 0;
        $sommeFixe = 0;
        foreach ($taxes as $tax) {
            if ($tax->type == '%')
                $sommeTaux += $tax->valeur;

            if ($tax->type == 'fixe')
                $sommeFixe += $tax->valeur;
        }
        return ($frais * $sommeTaux / 100) + $sommeFixe;
    }

    private function random_string()
    {
        $character_set_array = array();
        $character_set_array[] = array('count' => 12, 'characters' => 'ABCDEFGHJKMNPQRSTUVWXYZ');
        $character_set_array[] = array('count' => 4, 'characters' => '23456789');
        $temp_array = array();
        foreach ($character_set_array as $character_set) {
            for ($i = 0; $i < $character_set['count']; $i++) {
                $temp_array[] = $character_set['characters'][rand(0, strlen($character_set['characters']) - 1)];
            }
        }
        shuffle($temp_array);
        return implode('', $temp_array);
    }
}