<?php

namespace App\Http\Controllers;

use App\Models\AgentPlus;
use App\Models\CodeGenerer;
use App\Models\ConfigWallet;
use App\Models\Identification;
use App\Models\NetworksAgent;
use App\Models\UsersDemandesCredit;
use App\Models\UsersGroup;
use App\Models\Wallet;
use App\Models\WalletAgent;
use App\Models\WalletsUser;
use App\Traits\ApiResponser;
use App\Traits\Helper;
use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Support\Facades\DB;

class NanoCreditController extends Controller
{
    use ApiResponser;
    use Helper;

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

    // Gestion du nano credit

    public function askNanoCredit(Request $request)
    {
        $this->validate($request, [
            'type_caution' => 'required|in:groupe,individuel',
            'duree_mois' => 'required|integer|min:0|not_in:0',
            'id_user' => 'required|integer|min:0|not_in:0',
            'password' => 'required',
            'montant' => 'required|numeric|min:0|not_in:0',
        ]);

        $user = User::findOrFail($request->id_user);
        if (!$this->checkPassword($request->password, $user->encrypted_password, $user->salt))
            return $this->errorResponse(trans('messages.incorrect_user_password'));

        $identfication = $this->checkMyIdentification($request->id_user);
        if (!($identfication instanceof Identification))
            return $identfication;

        $init_country = $user->network->country->id;
        $result = ConfigWallet::join('networks', 'networks.id', '=', 'configWallet.id_network')
            ->where('networks.country_id', $init_country)->where('configWallet.type', 'ilink')
            ->select('configWallet.id')->first();
        if ($result) {
            $config = ConfigWallet::findOrFail($result->id);
        } else {
            return $this->errorResponse(trans('errors.no_ilink_network'));
        }

        $taxes = array_values(array_filter($config->taxes->all(), function ($tax) {
            return $tax->categorie == 'nano_credit';
        }));

        $paliers = array_values($config->paliers_config_nano_credits->all());

        $demande_credit = new UsersDemandesCredit();
        $demande_credit->fill($request->all());

        // Derniere demande de nano credit
        $last_demand = UsersDemandesCredit::where('id_user', $request->id_user)->where('etat', 'VALIDE')->first();
        if ($last_demand)
            return $this->errorResponse(trans('errors.last_nano_credit_not_refunded'));

        if ($request->type_caution == 'groupe') {

            $group = UsersGroup::find($user->group_id);
            if (!$group)
                return $this->errorResponse(trans('errors.not_belongs_to_any_group'));

            if (!$group->actif)
                return $this->errorResponse(trans('errors.your_group_not_active'));

            if ($group->nombre_utilisateurs < 10)
                return $this->errorResponse(trans('errors.your_group_not_valid'));

            if ($request->montant < $group->limite_credit)
                return $this->errorResponse(trans('errors.nano_credit_amount_must_be_less_than_group_limit'));


            $walletUser = WalletsUser::where('idUser', $request->id_user)->firstOrFail();

            $demande_credit->frais = $this->calculateFees($paliers, $request->montant, $request->duree_mois);
            $demande_credit->taxe = $this->calculateTax($taxes, $demande_credit->frais);
            $demande_credit->date_demande = new \DateTime();
            $demande_credit->date_remboursement_prevu = $demande_credit->date_demande->modify('+' . $request->duree_mois . ' month');
            $demande_credit->etat = 'VALIDE';
            $demande_credit->id_demande = $this->getNanoCreditDemandID();

            $montant_total = $demande_credit->montant + $demande_credit->frais + $demande_credit->taxe;

            $user->balance_credit += $montant_total;
            $walletUser->balance += $demande_credit->montant;
            $user->save();
            $walletUser->save();
            $demande_credit->save();

            $message = trans('messages.successful_user_group_nano_credit_demand',
                ['id_demand' => $demande_credit->id_demande, 'amount' => $this->toMoney($montant_total, $init_country),
                    'net' => $this->toMoney($demande_credit->montant, $init_country), 'fees' => $this->toMoney($demande_credit->frais + $demande_credit->taxe, $init_country),
                    'date' => $demande_credit->date_remboursement_prevu]);
            $this->sendMail($user->email, trans('messages.successful_nano_credit_demand'), $message);
            return $this->successResponse($message . trans('messages.sent_by_mail'));

        }

        if ($request->type_caution == 'individuel') {

            $demande_credit->frais = $this->calculateFees($paliers, $request->montant, $request->duree_mois);
            $demande_credit->taxe = $this->calculateTax($taxes, $demande_credit->frais);
            $demande_credit->etat = 'EN_ATTENTE_DE_VALIDATION';

            $montant_total = $demande_credit->montant + $demande_credit->frais + $demande_credit->taxe;

            $demande_credit->id_demande = $this->getNanoCreditDemandID();
            $demande_credit->save();

            $message = trans('messages.successful_user_individual_nano_credit_demand',
                ['id_demand' => $demande_credit->id_demande, 'amount' => $this->toMoney($montant_total, $init_country),
                    'net' => $this->toMoney($demande_credit->montant, $init_country),
                    'fees' => $this->toMoney($demande_credit->frais + $demande_credit->taxe, $init_country),]);
            $this->sendMail($user->email, trans('messages.successful_nano_credit_demand'), $message);
            return $this->successResponse($message . trans('messages.sent_by_mail'));
        }

    }

    public function cautionnerCredit(Request $request)
    {
        $this->validate($request, [
            'id_demande' => 'required',
            'id_wallet_agent' => 'required|integer|min:0|not_in:0',
            'password' => 'required',
        ]);

        $walletAgent = Wallet::findOrFail($request->get('id_wallet_agent'));
        $network_agent = NetworksAgent::findOrFail($walletAgent->id_networkAgent);
        $agent_country = $network_agent->network->country->id;

        // 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_hyp = WalletAgent::where('agent_id', $hyperviseur->id)->firstOrFail();
        $walletHyperviseur = Wallet::findOrFail($wallet_agent_hyp->wallet_id);


        $agent = AgentPlus::findOrFail($network_agent->agent_id);
        if (!$this->checkPassword($request->password, $agent->encrypted_password, $agent->salt))
            return $this->errorResponse(trans('messages.incorrect_user_password'));

        $demande_credit = UsersDemandesCredit::where('id_demande', $request->id_demande)->first();
        if (!$demande_credit)
            return $this->errorResponse(trans('errors.nano_credit_not_found'));

        if ($demande_credit->type_caution != 'individuel')
            return $this->errorResponse(trans('errors.nano_credit_not_individual'));


        if ($demande_credit->etat == 'VALIDE')
            return $this->errorResponse(trans('messages.treated_demand'));

        $user = User::findOrFail($demande_credit->id_user);
        $user_country = $user->network->country->id;

        if ($user_country != $agent_country)
            return $this->errorResponse('errors.operation_cannot_performed_in_country');

        $montant_total = $demande_credit->montant + $demande_credit->frais + $demande_credit->taxe;

        if ($montant_total > $walletAgent->balance_princ)
            return $this->errorResponse(trans('errors.insufficient_balance'));


        $demande_credit->date_demande = new \DateTime();
        $demande_credit->date_remboursement_prevu = $demande_credit->date_demande->modify('+' . $demande_credit->duree_mois . ' month');
        $demande_credit->etat = 'VALIDE';
        $demande_credit->id_wallet_agent = $walletAgent->id;
        $user->balance_credit += $montant_total;

        $walletHyperviseur->balance_princ += $demande_credit->montant;
        $walletAgent->balance_princ -= $montant_total;
        $walletAgent->save();
        $walletHyperviseur->save();
        $user->save();

        $demande_credit->save();

        $user_message = trans('messages.successful_guarantee_user_individual_nano_credit_demand',
            ['id_demand' => $demande_credit->id_demande, 'amount' => $this->toMoney($montant_total, $agent_country),
                'net' => $this->toMoney($demande_credit->montant, $agent_country), 'fees' => $this->toMoney($demande_credit->frais + $demande_credit->taxe, $agent_country),
                'date' => $demande_credit->date_remboursement_prevu, 'agent_name' => $agent->lastname . ' ' . $agent->firstname, 'code_agent' => $agent->code_membre]);

        $agent_message = trans('messages.successful_guarantee_agent_individual_nano_credit_demand',
            ['id_demand' => $demande_credit->id_demande, 'amount' => $this->toMoney($montant_total, $agent_country),
                'net' => $this->toMoney($demande_credit->montant, $agent_country), 'fees' => $this->toMoney($demande_credit->frais + $demande_credit->taxe, $agent_country),
                'date' => $demande_credit->date_remboursement_prevu, 'user_name' => $user->lastname . ' ' . $user->firstname, 'code_user' => $user->user_code]);

        $this->sendMail($user->email, trans('messages.successful_guarantee_nano_credit_demand'), $user_message);
        $this->sendMail($agent->email, trans('messages.successful_guarantee_nano_credit_demand'), $agent_message);
        return $this->successResponse($agent_message . trans('messages.sent_by_mail'));
    }

    public function rembourserCredit(Request $request)
    {
        $this->validate($request, [
            'id_demande' => 'required',
            'id_user' => 'required|integer|min:0|not_in:0',
            'password' => 'required',
        ]);

        $user = User::findOrFail($request->id_user);
        if (!$this->checkPassword($request->password, $user->encrypted_password, $user->salt))
            return $this->errorResponse(trans('messages.incorrect_user_password'));

        $walletUser = WalletsUser::where('idUser', $request->id_user)->firstOrFail();
        $demande_credit = UsersDemandesCredit::where('id_demande', $request->id_demande)->first();
        if (!$demande_credit)
            return $this->errorResponse(trans('errors.nano_credit_not_found'));

        if ($demande_credit->etat == 'REMBOURSE')
            return $this->errorResponse(trans('errors.nano_credit_already_refunded'));

        $init_country = $user->network->country->id;
        $montant_total = $demande_credit->montant + $demande_credit->frais + $demande_credit->taxe;

        if ($montant_total > $walletUser->balance)
            return $this->errorResponse(trans('errors.insufficient_balance'));

        $user->balance_credit -= $montant_total;
        $walletUser->balance -= $montant_total;
        $demande_credit->etat = 'REMBOURSE';

        if ($demande_credit->type_caution == 'individuel') {
            $walletAgent = Wallet::findOrFail($demande_credit->id_wallet_agent);
            $network_agent = NetworksAgent::findOrFail($walletAgent->id_networkAgent);

            // 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_hyp = WalletAgent::where('agent_id', $hyperviseur->id)->firstOrFail();
            $walletHyperviseur = Wallet::findOrFail($wallet_agent_hyp->wallet_id);

            $walletAgent->balance_princ += $demande_credit->montant;
            $walletHyperviseur->balance_princ -= $demande_credit->montant;
            $walletAgent->save();
            $walletHyperviseur->save();
        }

        $demande_credit->date_remboursement = new \DateTime();

        $walletUser->save();
        $user->save();
        $demande_credit->save();

        $message = trans('messages.successful_nano_credit_demand_refunded',
            ['id_demand' => $demande_credit->id_demande, 'amount' => $this->toMoney($montant_total, $init_country),
                'net' => $this->toMoney($demande_credit->montant, $init_country), 'fees' => $this->toMoney($demande_credit->frais + $demande_credit->taxe, $init_country),
                'caution' => $demande_credit->type_caution == 'groupe' ? 'Groupe' : 'Individuel']);
        $this->sendMail($user->email, trans('messages.successful_nano_credit_refunded'), $message);
        return $this->successResponse($message . trans('messages.sent_by_mail'));
    }

    // Calculer les frais
    private function calculateFees(array $paliers, $montant, $duree)
    {
        $size = sizeof($paliers);
        if ($size > 0) {
//           $mois = array_map(function ($palier) {
//               return $palier->duree_mois;
//           },$paliers);

            $palier = null;
            foreach ($paliers as $p) {
                if ($p->duree_mois == $duree) {
                    $palier = $p;
                    break;
                }
            }

            if ($palier) {
                return $palier->taux * $montant / 100;
            }
        }
        return 0;
    }

    private function getNanoCreditDemandID()
    {
        do {
            $code = $this->generateGroupCode();
            $result = collect(DB::select('SELECT * FROM users_demandes_credits WHERE id_demande = :code', ['code' => $code]));
            $codeCorrect = sizeof($result) < 0;
        } while ($codeCorrect);
        return $code;
    }

}