<?php

namespace bff\auth;

use Users;
use app\User;
use modules\users\models\User as UserModel;
use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Contracts\Hashing\Hasher as HasherContract;
use Illuminate\Contracts\Auth\UserProvider as ProviderContract;

/**
 * Adapted from \Illuminate\Auth\EloquentUserProvider
 * @see https://github.com/illuminate/auth/blob/8.x/LICENSE.md
 */
class EloquentUserProvider implements ProviderContract
{
    /**
     * The hasher implementation.
     * @var \Illuminate\Contracts\Hashing\Hasher
     */
    protected $hasher;

    /**
     * The Eloquent user model.
     * @var string
     */
    protected $model;

    /**
     * @param \Illuminate\Contracts\Hashing\Hasher $hasher
     * @param string $model
     * @return void
     */
    public function __construct(HasherContract $hasher, $model)
    {
        $this->hasher = $hasher;
        $this->model = $model ?: UserModel::class;
    }

    /**
     * Retrieve a user by their unique identifier.
     * @param mixed $identifier
     * @return Authenticatable|null
     */
    public function retrieveById($identifier)
    {
        return $this->createUser(function (Authenticatable $user) use ($identifier) {
            return [
                $user->getAuthIdentifierName() => $identifier,
            ];
        });
    }

    /**
     * Retrieve a user by their unique identifier and "remember me" token.
     * @param mixed $identifier
     * @param string $token
     * @return Authenticatable|null
     */
    public function retrieveByToken($identifier, $token)
    {
        return $this->createUser(function (Authenticatable $user) use ($identifier, $token) {
            return [
                $user->getAuthIdentifierName() => $identifier,
                $user->getRememberTokenName() => $token,
            ];
        });
    }

    /**
     * Update the "remember me" token for the given user in storage.
     * @param Authenticatable $user
     * @param string $token
     * @return void
     */
    public function updateRememberToken(Authenticatable $user, $token)
    {
        if (! empty($user->getRememberTokenName())) {
            Users::model()->userSave($user->getAuthIdentifier(), [
                $user->getRememberTokenName() => $token,
            ]);
        }
    }

    /**
     * Retrieve a user by the given credentials.
     * @param array $credentials
     * @return Authenticatable|null
     */
    public function retrieveByCredentials(array $credentials)
    {
        $filter = [];
        foreach ($credentials as $key => $value) {
            if (mb_strpos($key, 'password') !== false) {
                continue;
            }
            $filter[$key] = $value;
        }

        return $this->createUser($filter);
    }

    /**
     * Validate a user against the given credentials.
     * @param Authenticatable $user
     * @param array $credentials
     * @return bool
     */
    public function validateCredentials(Authenticatable $user, array $credentials)
    {
        if ($user instanceof User) {
            return $user->isCurrentPassword($credentials['password'] ?? '');
        }
        return $this->hasher->check(
            $credentials['password'] ?? '',
            $user->getAuthPassword()
        );
    }

    /**
     * Load user by filter
     * @param array|\Closure $filter
     * @return Authenticatable|null
     */
    protected function createUser($filter)
    {
        $user = new User($this->model, $filter);
        if (is_null($user->getModel())) {
            # Unable to retrieve a user by the given credentials
            return null;
        }
        return $user;
    }
}