<?php

namespace App\Http\Controllers;

use App\Http\Requests\CustomerRegisterRequest;
use App\Mail\PasswordResetMail;
use App\Mail\RegisterConfirmMail;
use App\Models\Customers;
use App\Models\PasswordReset;
use App\Models\Products;
use App\Models\Recipes;
use Carbon\Carbon;
use Exception;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\Session;
use Illuminate\Support\Str;

class CustomerController extends Controller
{
    /**
     * Affiche la page d'inscription
     */
    public function registerForm()
    {
        if (Auth::guard('customer')->check()) {
            return redirect()->route('club.index');
        }
        return view('front.auth.register');
    }

    /**
     * Enregistre le customer dans la base de données
     */
    public function register(CustomerRegisterRequest $request)
    {
        /** @var \App\Lib\LDCCRM\ApiV1 */
        $crm = app('crmApi');
        $crmCustomer = $crm->createCustomer(
            $request->email,
            $request->password,
            $request->firstname,
            $request->lastname,
            $request->optin !== null ? 1 : 0,
            $birthDate = Carbon::createFromDate(
                $request->year,
                $request->month,
                $request->day
            )->format('Y-m-d'),
            isset($phone) ? $phone : null,
            isset($address) ? $address : null,
            null,
            $request->city,
            $request->postcode,
            null
        );

        if ($crmCustomer->status === "OK") {
            $customer = new Customers($request->all());
            $customer->crm_id = $crmCustomer->user->crm_id;
            $customer->hashcode = $crmCustomer->user->hashcode;
            $customer->save();

            Mail::to($request->email)->send(new RegisterConfirmMail($customer, $request->firstname));

            return view('front.auth.confirm-register');
        } else {
            switch ($crmCustomer->code) {
                case 102:
                    return back()->withInput()->withErrors(
                        "Les champs obligatoires n'ont pas été correctement remplis."
                    );
                case 103:
                    return back()->withInput()->withErrors(
                        "Un compte est déjà associé à cette adresse email."
                    );
                default:
                    return back()->withInput()->withErrors(
                        "Une erreur est survenue lors de l'inscription, merci de réessayer plus tard."
                    );
            }
        }
    }

    /**
     * Retourne la page de connexion
     */
    public function authenticateForm(Request $request)
    {
        if (Auth::guard('customer')->check()) {
            return redirect()->route('club.index');
        }
        if ($request->get('url')) {
            Session::put('url.intended', $request->get('url'));
            Session::save();
        }
        return view('front.auth.login');
    }

    /**
     * Gère l'authentification des customers
     */
    public function authenticate(Request $request)
    {
        $request->validate([
            'email' => 'required|email:rfc',
            'password' => 'required',
        ]);

        $email = filter_var($request->email, FILTER_SANITIZE_EMAIL);
        $password = $request->password;
        $remember = $request->remember !== null ? true : false;

        /** @var \App\Lib\LDCCRM\ApiV1 */
        $crm = app('crmApi');
        $result = $crm->loginCustomer($email, $password);

        /** @var Customers */
        $customer = Customers::where('email', $email)->first();
        if ($customer) {
            if ($result->status === "OK" || (config('app.debug') && env('NOCRM'))) {
                return $this->processLogin($customer, $remember);
            } else {
                return $this->processLoginError($result, $email, $customer);
            }
        } else {
            // Si pas de compte local mais existe en CRM ou pas de compte local existe en CRM mais pas activé
            if ($result->status === "OK" || $result->code === 116) {
                $customer = $this->createCustomer($result);

                if ($customer === false) {
                    return back()->withErrors("Une erreur est survenue, merci de réessayer ultérieurement.");
                }

                if ($result->status !== "OK" && $result->code === 116) {
                    return $this->processLoginError($result, $email, $customer);
                }
                return $this->processLogin($customer, $remember);
            } else {
                return $this->processLoginError($result, $email, $customer);
            }
        }
    }

    private function createCustomer($result)
    {
        $pseudo = $this->getUniquePseudo($result->user->firstname, $result->user->lastname, 0);
        if ($pseudo === false) {
            return false;
        }

        $customer = new Customers((array)$result->user);
        $customer->crm_id = $result->user->crm_id;
        $customer->hashcode = $result->user->hashcode;
        $customer->username = $pseudo;
        $customer->save();

        return $customer;
    }

    private function getUniquePseudo($firstname, $lastname, $i)
    {
        if ($i === 20) {
            return false;
        }

        $pseudo = $firstname . '.' . substr($lastname, 0, 1);
        if ($i > 0) {
            $pseudo .= "-" . Str::random(8);
        }

        $customer = Customers::where('username', $pseudo)->first();
        if ($customer) {
            return $this->getUniquePseudo($firstname, $lastname, $i + 1);
        }

        return $pseudo;
    }

    private function processLogin($customer, $remember)
    {
        /** @var \Illuminate\Auth\SessionGuard */
        $guard = Auth::guard('customer');
        $guard->login($customer, $remember);
        $url = Session::pull('url.intended');
        Session::forget('url.intended');
        Session::save();
        return $url ? redirect()->to($url) : redirect()->to(Session::pull('previousurl'));
    }

    private function processLoginError($result, $email, $customer)
    {
        switch ($result->code) {
            case 115:
                return back()
                    ->withErrors(
                        __('Veuillez vérifier que vous avez correctement rempli les champs obligatoires.')
                    );
            case 116:
                Mail::to($email)->send(new RegisterConfirmMail($customer, null));
                return back()
                    ->withErrors(
                        __('Votre compte n\'est pas activé, vérifiez dans vos emails pour y trouver
                                le mail de confirmation. Un lien d\'activation vous a été renvoyé.')
                    );
            case 117 || 118 || 119:
                return back()->withErrors("Email ou mot de passe incorrect.");
            default:
                return back()->withErrors("Une erreur est survenue, merci de réessayer ultérieurement.");
        }
    }

    /**
     * Active le compte d'un customer
     */
    public function activate($hashcode)
    {
        $hashcode = filter_var($hashcode, FILTER_SANITIZE_STRING);
        $customer = Customers::select('crm_id')->where('hashcode', $hashcode)->first();
        if ($customer) {
            /** @var \App\Lib\LDCCRM\ApiV1 */
            $crm = app('crmApi');
            $result = $crm->activateCustomer($customer->crm_id);
            if ($result->status === "OK") {
                return view('front.auth.activate')
                    ->with('message', 'Votre compte a bien été activé, vous pouvez désormais vous connecter.');
            } else {
                return view('front.auth.activate')->with('message', "Ce lien d'activation n'est pas valide.");
            }
        } else {
            return view('front.auth.activate')->with('message', "Ce lien d'activation n'est pas valide.");
        }
    }

    public function logout()
    {
        /** @var \Illuminate\Auth\SessionGuard */
        $guard = Auth::guard('customer');
        if ($guard->check()) {
            $guard->logout();
            return redirect()->route('home');
        }
    }

    public function passwordReset(Request $request)
    {
        $request->validate([
            'email' => 'required|email:rfc|max:255',
        ]);

        $email = filter_var($request->email, FILTER_SANITIZE_EMAIL);

        $customerExist = Customers::where('email', $email)->count() === 0 ? false : true;

        if ($customerExist) {
            return $this->sendResetPasswordLink($email);
        } else {
            /** @var \App\Lib\LDCCRM\ApiV1 */
            $crm = app('crmApi');
            $result = $crm->getCustomerByEmail($email);

            if ($result->status === 'OK') {
                $customer = $this->createCustomer($result);
                if ($customer === false) {
                    return back()->withErrors("Une erreur est survenue, merci de réessayer ultérieurement.");
                }

                return $this->sendResetPasswordLink($email);
            } else {
                if ($result->code !== 500) {
                    return back()->withErrors(__("Cette adresse email n'est pas enregistrée dans nos services."));
                } else {
                    return back()->withErrors("Une erreur est survenue, merci de réessayer ultérieurement.");
                }
            }
        }
    }

    private function sendResetPasswordLink($email)
    {
        // Suppression des anciens tokens
        PasswordReset::where('email', $email)->delete();

        $token = Str::random(80);

        $passwordReset = new PasswordReset();
        $passwordReset->email = $email;
        $passwordReset->token = $token;
        $passwordReset->created_at = now();
        $passwordReset->save();

        Mail::to($email)->send(new PasswordResetMail($token));
        return back()->with(
            'success',
            __("La procédure pour changer votre mot de passe a été envoyé sur votre email.")
        );
    }

    /**
     * Print the view used to change the password of a user when he required it
     * @param $token Token used to identificate the user to change the password of
     * @return View The view to print
     */
    public function viewChangePassword($token)
    {
        $pwdReset = PasswordReset::where('token', $token)->first();
        if (!$pwdReset) {
            abort(419);
        }
        $customer = Customers::where('email', $pwdReset->email)->first();
        if (!$customer) {
            abort(404);
        }

        return view('front.auth.password-reset', compact('customer'))->with('token', $token);
    }

    public function changePassword(Request $request, $token)
    {
        $request->validate([
            'password' => 'required|confirmed|min:8|max:255'
        ]);

        $password = $request->password;

        try {
            $passwordReset = PasswordReset::where('token', $token)->first();
            $customer = Customers::where('email', $passwordReset->email)->first();
            $crmId = $customer->crm_id;
        } catch (Exception $e) {
            return back()->withErrors("Changement du mot de passe impossible, les données envoyés sont incorrectes.");
        }
        /** @var \App\Lib\LDCCRM\ApiV1 */
        $crm = app('crmApi');
        $result = $crm->changePwdCustomer($crmId, $password);
        if ($result->status === "OK") {
            $passwordReset->delete();
            return view('front.auth.password-reset-ok', compact('customer'));
        } else {
            switch ($result->code) {
                case 107:
                    return back()
                        ->withErrors("Veuillez vérifier que vous avez correctement rempli les champs obligatoires.");
                case 108 || 109:
                    return back()
                        ->withErrors("Changement impossible, compte inexistant.");
                default:
                    return back()
                        ->withErrors("Une erreur est survenue, merci de réessayer ultérieurement.");
            }
        }
    }

    public function changePasswordWhenAuthenticated(Request $request)
    {
        $request->validate([
            'password' => 'required|min:8|confirmed|max:255'
        ]);

        $crm = app('crmApi');
        $customer = $crm->changePwdCustomer(Auth::guard('customer')->user()->crm_id, $request->password);

        if ($customer->status === "OK") {
            return back()->with('success', __("Modifications enregistrés !"));
        } else {
            return back()->withErrors(__("Une erreur est survenue, merci de réessayer ultérieurement."));
        }
    }

    public function changeOptin($token)
    {
        // TODO : Route et test de la méthode avec nouveau client CRM pour l'opt in
        dd("Attente");
        $crmId = Customers::where('hashcode', $token)->first()->crm_id;

        /** @var \App\Lib\LDCCRM\ApiV1 */
        $crm = app('crmApi');
        $result = $crm->toggleOptInCustomer($crmId);
        if ($result->status === "OK") {
            dd("OK");
            return back()->with('success', 'Modification enregistrée !');
        } else {
            switch ($result->code) {
                case 113 || 114:
                    dd("KO 113 ou 114");
                    return back()->withErrors("Mise à jour impossible, compte inexistant.");
                default:
                    dd("KO default");
                    return back()->withErrors("Une erreur est survenue, merci de réessayer ultérieurement.");
            }
        }
    }

    public function setFavoriteRecipe(Recipes $recipe, bool $status)
    {
        /** @var Customer */
        $customer = Auth::guard('customer')->user();
        if ($status) {
            $customer->recipes()->attach($recipe);
        } else {
            $customer->recipes()->detach($recipe);
        }
        return response()->json();
    }

    public function setItemInCart(Products $product, bool $status)
    {
        /** @var \App\Models\Customer */
        $customer = Auth::guard('customer')->user();
        if ($status) {
            $customer->products()->attach($product);
        } else {
            $customer->products()->detach($product);
        }
    }

    public function delete($id)
    {
        // TODO : Implémenter la suppression lorsque la CRM sera prête pour le faire aussi
        dd('Not implemented yet');
        // Suppression d'un compte client
        $customer = Customers::findOrFail($id);
        $customer->recipes()->delete();
        $customer->products()->delete();
        $customer->answers()->delete();

        // TODO : Suppression via la CRM

        /** @var \Illuminate\Auth\SessionGuard */
        $guard = Auth::guard('customer');
        if ($guard->user()->id === $customer->id) {
            $guard->logout();
        }
        $customer->delete();

        return redirect()->route('home');
    }
}