<?php

namespace App\Auth;

use App\Models\Customer;
use Illuminate\Auth\EloquentUserProvider;
use Illuminate\Contracts\Auth\Authenticatable as UserContract;
use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Contracts\Auth\UserProvider as UserProviderContract;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Session;
use Illuminate\Support\Str;
use LDC\LDCCRM\Enums\ApiError;
use LDC\LDCCRM\Exceptions\ApiErrorException;
use LDC\LDCCRM\Exceptions\CrmException;
use LDC\LDCCRM\Models\Customer as CrmCustomer;

/**
 * Crm user provider to integrate nicely with Laravel
 */
class CrmUserProvider extends EloquentUserProvider implements UserProviderContract
{
    /**
     * The model to use, specified in auth config guard.
     *
     * @var string
     */
    private $usedModel = Customer::class;

    /**
     * Retrieve a user by the given credentials.
     *
     * @param  array $credentials
     * @return \Illuminate\Contracts\Auth\Authenticatable|null
     */
    public function retrieveByCredentials(array $credentials)
    {
        // * Let laravel find a model
        $model = parent::retrieveByCredentials($credentials) ??
            static::retrieveTrashed($credentials);

        try {
            /** @var \LDC\LDCCRM\CrmApiV2 */
            $crm = app('crmAPI');

            // Si pas de compte local.
            if (!$model) {
                $crmCustomer = $crm->getCustomer($credentials['email']);

                if (!$crmCustomer) {
                    // * Customer is not found on CRM.
                    return null;
                }
                $model = $this->createLocalCustomer($crmCustomer);
            }

            return $model;
        } catch (ApiErrorException $e) {
            // * Customer is not found.
            if ($e->getApiError()->equals(ApiError::modelNotFound())) {
                return null;
            }
            report($e);
            Log::error('Unhandled response ' . $e->getApiError()->label);
        } catch (CrmException | \Exception $e) {
            report($e);
            // Une erreur critique est survenue avec la CRM.
            return null;
        } //end try
        Log::error(__CLASS__ . '::retrieveByCredentials reached end of possibilities.');
        return null;
    }

    /**
     * Validate a user against the given credentials.
     *
     * @param UserContract $model
     * @param array        $credentials
     * @return boolean
     * @throws \RuntimeException If model provided is not a Customer or connection to server fails.
     * @throws \LDC\LDCCRM\Exceptions\CrmException On CRM call error.
     * @throws \Exception On CRM call error.
     */
    public function validateCredentials(UserContract $model, array $credentials)
    {
        /** @var \Illuminate\Database\Eloquent\Model $model */
        if (\get_class($model) !== $this->usedModel) {
            throw new \RuntimeException('Cannot authenticate any thing else than ' . $this->usedModel);
        }

        try {
            /** @var \LDC\LDCCRM\CrmApiV2 */
            $crm = app('crmAPI');

            // * If has trait soft delete and customer trashed, then restore customer.
            if (
                \in_array(\Illuminate\Database\Eloquent\SoftDeletes::class, \class_uses_recursive($model)) and
                $model->trashed()
            ) {
                $model->restore();
            }

            // * Ne devrait pas survenir, $crm->login throws ApiError::authFailed()
            return $crm->login($credentials['email'], $credentials['password']);
        } catch (ApiErrorException $e) {
            if (!$model->hashcode or !CrmCustomer::find($model->hashcode)) {
                $model->forceDelete();
                return false;
            }
            if ($e->getApiError()->equals(ApiError::authFailed())) {
                return false;
            }
            // ! Assert Authenticable model must be valided (MustValidate trait).
            if ($e->getApiError()->equals(ApiError::customerNotActivated())) {
                Session::flash('warning', \trans('Vous devez activer votre compte'));
                return true;
            }
        } catch (CrmException | \Exception $e) {
            report($e);
            if (config('app.debug')) {
                throw $e;
            }
            return false;
        } //end try

        Log::error(__CLASS__ . '::validateCredentials reached end of possibilities.');
        return null;
    }

    /**
     * Create a local customer
     *
     * @param \LDC\LDCCRM\Models\Customer $crmCustomer
     * @return \Illuminate\Database\Eloquent\Model
     * @throws \Throwable If saving to DB failed.
     */
    private function createLocalCustomer(\LDC\LDCCRM\Models\Customer $crmCustomer): Model
    {
        /** @var \Illuminate\Database\Eloquent\Model $model */
        $model                    = $this->usedModel::firstOrNew([
            'email' => $crmCustomer->email
        ]);
        $model->hashcode          = $crmCustomer->hashcode;
        $model->email_verified_at = $crmCustomer->status ? now() : null;
        $model->saveOrFail();

        return $model;
    }

    /**
     * Retrieve a trashed customer by the given credentials.
     *
     * @param array $credentials
     * @return \Illuminate\Contracts\Auth\Authenticatable|null
     * @throws \ErrorException If cannot connect to LDAP.
     */
    private function retrieveTrashed(array $credentials): ?Authenticatable
    {
        // * Make changes
        if (empty($credentials)) {
            return null;
        }

        // First we will add each credential element to the query as a where clause.
        // Then we can execute the query and, if we found a customer, return it in a
        // Eloquent User "model" that will be utilized by the Guard instances.
        $query = $this->createModel()->newQuery();

        foreach ($credentials as $key => $value) {
            if (!Str::contains($key, 'password')) {
                $query->where($key, $value);
            }
        }

        /** @var \App\Models\Customer|null $customer */
        return $query->withTrashed()->first();
    }
}