<?php

namespace Slovocast\Domain\Repository\User;

use DateTime;
use DateTimeImmutable;
use Slovocast\Domain\Entity\User;
use Slovocast\Exception\EntityNotFoundException;
use Slovocast\Infrastructure\Api\User\UserAuthorizationInterface;
use Slovocast\Infrastructure\Api\Database\DatabaseHandlerInterface;

class UserRepository implements UserRepositoryInterface
{
    const QUERY_CREATE = "INSERT INTO users (email, password, name)
                          VALUES (:email, :password, :name)";

    const QUERY_UPDATE = "UPDATE users 
                          SET email = :email,
                              name = :name,
                              password = :password
                          WHERE id = :id";

    const QUERY_SELECT_BY_ID = "";
    const QUERY_SELECT_BY_EMAIL = "";

    public function __construct(
        private DatabaseHandlerInterface $db,
        private UserAuthorizationInterface $userAuth
    ) {}

    /**
     * @param array $results The Query Results asking for all properties from
     *                       the database tables.
     * @return User
     */
    protected function userFromQueryResults(array $results): User
    {
        return User::fromArray([
            'id' => $results['id'],
            'email' => $results['email'],
            'password' => $results['password'],
            'name' => $results['name'],
            'createdAt' => $results['created_at'],
            'updatedAt' => $results['updated_at']
        ]);
    }

    /**
     * Get a single instance of the User Entity.
     */
    public function get(int $id): User
    {
        $query = "SELECT * FROM users WHERE id = :id LIMIT 1";

        $results = $this->db->query($query, [ ':id' => $id ]);

        if (!is_array($results) || empty($results)) {
            throw new EntityNotFoundException("Unable to find User");
        }

        return $this->userFromQueryResults($results);
    }

    /**
     * Get a single instance of the User Entity by their Email address.
     *
     * @param string $email
     * @return User
     */
    public function getFromEmail(string $email): User
    {
        $query = "SELECT * FROM users WHERE email = :email LIMIT 1";
        $results = $this->db->query($query, [ ':email' => $email ]);

        if (!is_array($results) || empty($results)) {
            throw new EntityNotFoundException("Unable to find User");
        }

        return $this->userFromQueryResults($results);
    }

    public function create(User $user): bool 
    {
        $results = $this->db->execute(self::QUERY_CREATE, [
            ':email' => $user->getEmail(),
            ':password' => $this->userAuth->hash($user->getPassword()),
            ':name' => $user->getName(),
        ]);

        if ($results) {
            $insertId = $this->db->getConnection()->lastInsertId();
            $user->setId($insertId);
            $user->setCreatedAt(new DateTimeImmutable());
            $user->setUpdatedAt(new DateTime());
        }
        
        return $results;
    }

    public function update(User $user): bool
    {
        $results = $this->db->execute(self::QUERY_UPDATE, [
            ':email' => $user->getEmail(),
            ':name' => $user->getName(),
            ':password' => $this->userAuth->hash($user->getPassword()),
            ':id' => $user->getId()
        ]);

        if ($results == true) {
            $user->setUpdatedAt(new DateTime());
        }

        return $results;
    }

    /**
     * @TODO Figure out soft/hard delete logic for users
     */
    public function delete(User $user): bool
    {
        return false;
    }

    public function verifyPassword(string $email, string $password): bool
    {
        try {
            $user = $this->getFromEmail($email);
            return $this->authUser->verify($password, $user->getPassword());
        } catch (\Exception $e) {
            return false;
        }
    }
}