<?php namespace MapGuesser\Controller;

use DateInterval;
use DateTime;
use SokoWeb\Http\Request;
use SokoWeb\Interfaces\Response\IContent;
use SokoWeb\Interfaces\Response\IRedirect;
use SokoWeb\Mailing\Mail;
use SokoWeb\OAuth\GoogleOAuth;
use MapGuesser\PersistentData\Model\User;
use MapGuesser\PersistentData\Model\UserConfirmation;
use MapGuesser\PersistentData\Model\UserPasswordResetter;
use MapGuesser\Repository\UserConfirmationRepository;
use MapGuesser\Repository\UserPasswordResetterRepository;
use MapGuesser\Repository\UserPlayedPlaceRepository;
use MapGuesser\Repository\UserRepository;
use MapGuesser\Util\UsernameGenerator;
use SokoWeb\Response\HtmlContent;
use SokoWeb\Response\JsonContent;
use SokoWeb\Response\Redirect;
use SokoWeb\Util\CaptchaValidator;
use SokoWeb\Util\JwtParser;

class LoginController
{
    private UserRepository $userRepository;

    private UserConfirmationRepository $userConfirmationRepository;

    private UserPasswordResetterRepository $userPasswordResetterRepository;

    private UserPlayedPlaceRepository $userPlayedPlaceRepository;

    private string $redirectUrl;

    public function __construct()
    {
        $this->userRepository = new UserRepository();
        $this->userConfirmationRepository = new UserConfirmationRepository();
        $this->userPasswordResetterRepository = new UserPasswordResetterRepository();
        $this->userPlayedPlaceRepository = new UserPlayedPlaceRepository();
        $this->redirectUrl = \Container::$request->session()->has('redirect_after_login') ?
            \Container::$request->session()->get('redirect_after_login') :
            \Container::$routeCollection->getRoute('index')->generateLink();
    }

    public function getLoginForm()
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
        }

        return new HtmlContent('login/login', ['redirectUrl' => $this->redirectUrl]);
    }

    public function getGoogleLoginRedirect(): IRedirect
    {
        $state = bin2hex(random_bytes(16));
        $nonce = bin2hex(random_bytes(16));

        \Container::$request->session()->set('oauth_state', $state);
        \Container::$request->session()->set('oauth_nonce', $nonce);

        $oAuth = new GoogleOAuth(new Request());
        $url = $oAuth->getDialogUrl(
            $state,
            \Container::$request->getBase() . \Container::$routeCollection->getRoute('login-google-action')->generateLink(),
            $nonce
        );

        return new Redirect($url, IRedirect::TEMPORARY);
    }

    public function getSignupForm()
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
        }

        if (\Container::$request->session()->has('tmp_user_data')) {
            $tmpUserData = \Container::$request->session()->get('tmp_user_data');

            $data = ['email' => $tmpUserData['email']];
        } else {
            $data = [];
        }

        return new HtmlContent('login/signup', $data);
    }

    public function getSignupSuccess()
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
        }

        return new HtmlContent('login/signup_success');
    }

    public function getSignupWithGoogleForm()
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
        }

        if (!\Container::$request->session()->has('google_user_data')) {
            return new Redirect(\Container::$routeCollection->getRoute('login-google')->generateLink(), IRedirect::TEMPORARY);
        }

        $userData = \Container::$request->session()->get('google_user_data');

        $user = $this->userRepository->getByEmail($userData['email']);

        return new HtmlContent('login/google_signup', ['found' => $user !== null, 'email' => $userData['email'], 'redirectUrl' => $this->redirectUrl]);
    }

    public function getRequestPasswordResetForm()
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
        }

        return new HtmlContent('login/password_reset_request', ['email' => \Container::$request->query('email')]);
    }

    public function getRequestPasswordResetSuccess(): IContent
    {
        return new HtmlContent('login/password_reset_request_success');
    }

    public function getResetPasswordForm()
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
        }

        $token = \Container::$request->query('token');
        $resetter = $this->userPasswordResetterRepository->getByToken($token);

        if ($resetter === null || $resetter->getExpiresDate() < new DateTime()) {
            return new HtmlContent('login/reset_password', ['success' => false]);
        }

        $user = $this->userRepository->getById($resetter->getUserId());

        return new HtmlContent('login/reset_password', ['success' => true, 'token' => $token, 'email' => $user->getEmail(), 'redirectUrl' => $this->redirectUrl]);
    }

    public function login(): IContent
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new JsonContent(['success' => true]);
        }

        $user = $this->userRepository->getByEmailOrUsername(\Container::$request->post('email'));

        if ($user === null) {
            if (strlen(\Container::$request->post('password')) < 6) {
                return new JsonContent([
                    'error' => [
                        'errorText' => 'The given password is too short. Please choose a password that is at least 6 characters long!'
                    ]
                ]);
            }

            $tmpUser = new User();
            $tmpUser->setPlainPassword(\Container::$request->post('password'));

            \Container::$request->session()->set('tmp_user_data', [
                'email' => \Container::$request->post('email'),
                'password_hashed' => $tmpUser->getPassword()
            ]);

            return new JsonContent([
                'redirect' => [
                    'target' => \Container::$routeCollection->getRoute('signup')->generateLink()
                ]
            ]);
        }

        if (!$user->getActive()) {
            $this->resendConfirmationEmail($user);

            return new JsonContent([
                'error' => [
                    'errorText' => 'User found with the given email address / username, but the account is not activated. ' .
                        'Please check your email and click on the activation link!'
                ]
            ]);
        }

        if (!$user->checkPassword(\Container::$request->post('password'))) {
            return new JsonContent([
                'error' => [
                    'errorText' => 'The given password is wrong. You can <a href="/password/requestReset?email=' .
                        urlencode($user->getEmail()) . '" title="Request password reset">request password reset</a>!'
                ]
            ]);
        }

        \Container::$request->setUser($user);

        $this->deleteRedirectUrl();
        return new JsonContent(['success' => true]);
    }

    public function loginWithGoogle()
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
        }

        if (\Container::$request->query('state') !== \Container::$request->session()->get('oauth_state')) {
            return new HtmlContent('login/google_login');
        }

        $oAuth = new GoogleOAuth(new Request());
        $tokenData = $oAuth->getToken(
            \Container::$request->query('code'),
            \Container::$request->getBase() . \Container::$routeCollection->getRoute('login-google-action')->generateLink()
        );

        if (!isset($tokenData['id_token'])) {
            return new HtmlContent('login/google_login');
        }

        $jwtParser = new JwtParser($tokenData['id_token']);
        $idToken = $jwtParser->getPayload();

        if ($idToken['nonce'] !== \Container::$request->session()->get('oauth_nonce')) {
            return new HtmlContent('login/google_login');
        }

        if (!$idToken['email_verified']) {
            return new HtmlContent('login/google_login');
        }

        $user = $this->userRepository->getByGoogleSub($idToken['sub']);

        if ($user === null) {
            \Container::$request->session()->set('google_user_data', ['sub' => $idToken['sub'], 'email' => $idToken['email']]);

            return new Redirect(\Container::$routeCollection->getRoute('signup-google')->generateLink(), IRedirect::TEMPORARY);
        }

        \Container::$request->setUser($user);

        $this->deleteRedirectUrl();
        return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
    }

    public function logout(): IRedirect
    {
        \Container::$request->setUser(null);

        return new Redirect(\Container::$routeCollection->getRoute('index')->generateLink(), IRedirect::TEMPORARY);
    }

    public function signup(): IContent
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new JsonContent(['redirect' => ['target' => $this->redirectUrl]]);
        }

        $newUser = new User();

        $googleUserData = \Container::$request->session()->get('google_user_data');
        if ($googleUserData !== null) {
            $user = $this->userRepository->getByEmail($googleUserData['email']);

            if ($user !== null) {
                return new JsonContent([
                    'error' => [
                        'errorText' => 'There is a user already registered with the email address of this Google account, ' .
                            'but Google account is not linked to the user. Please <a href="/login?email=' .
                            urlencode($googleUserData['email']) . '" title="Login">login</a> first to link your Google account!'
                    ]
                ]);
            }

            $newUser->setActive(true);
            $newUser->setEmail($googleUserData['email']);
            $newUser->setGoogleSub($googleUserData['sub']);
        } else {
            $user = $this->userRepository->getByEmailOrUsername(\Container::$request->post('email'));

            if ($user !== null) {
                if ($user->getActive()) {
                    if (!$user->checkPassword(\Container::$request->post('password'))) {
                        return new JsonContent([
                            'error' => [
                                'errorText' => 'There is a user already registered with the given email address / username, ' .
                                    'but the given password is wrong. You can <a href="/password/requestReset?email=' .
                                    urlencode($user->getEmail()) . '" title="Request password reset">request password reset</a>!'
                            ]
                        ]);
                    }

                    \Container::$request->setUser($user);

                    $this->deleteRedirectUrl();
                    $data = ['redirect' => ['target' => $this->redirectUrl]];
                } else {
                    $data = [
                        'error' => [
                            'errorText' => 'There is a user already registered with the given email address / username. ' .
                                'Please check your email and click on the activation link!'
                        ]
                    ];
                }
                return new JsonContent($data);
            }

            if (!empty($_ENV['RECAPTCHA_SITEKEY'])) {
                if (!\Container::$request->post('g-recaptcha-response')) {
                    return new JsonContent(['error' => ['errorText' => 'Please check "I\'m not a robot" in the reCAPTCHA box!']]);
                }

                $captchaValidator = new CaptchaValidator();
                $captchaResponse = $captchaValidator->validate(\Container::$request->post('g-recaptcha-response'));
                if (!$captchaResponse['success']) {
                    return new JsonContent(['error' => ['errorText' => 'reCAPTCHA challenge failed. Please try again!']]);
                }
            }

            if (filter_var(\Container::$request->post('email'), FILTER_VALIDATE_EMAIL) === false) {
                return new JsonContent(['error' => ['errorText' => 'The given email address is not valid.']]);
            }

            if (\Container::$request->session()->has('tmp_user_data')) {
                $tmpUserData = \Container::$request->session()->get('tmp_user_data');

                $tmpUser = new User();
                $tmpUser->setPassword($tmpUserData['password_hashed']);

                if (!$tmpUser->checkPassword(\Container::$request->post('password'))) {
                    return new JsonContent(['error' => ['errorText' => 'The given passwords do not match.']]);
                }
            } else {
                if (strlen(\Container::$request->post('password')) < 6) {
                    return new JsonContent([
                        'error' => [
                            'errorText' => 'The given password is too short. Please choose a password that is at least 6 characters long!'
                        ]
                    ]);
                }

                if (\Container::$request->post('password') !== \Container::$request->post('password_confirm')) {
                    return new JsonContent(['error' => ['errorText' => 'The given passwords do not match.']]);
                }
            }

            $newUser->setActive(false);
            $newUser->setEmail(\Container::$request->post('email'));
            $newUser->setPlainPassword(\Container::$request->post('password'));
        }

        if (strlen(\Container::$request->post('username')) > 0) {
            $username = \Container::$request->post('username');

            if (preg_match('/^[a-zA-Z0-9_\-\.]+$/', $username) !== 1) {
                return new JsonContent(['error' => ['errorText' => 'Username can contain only english letters, digits, - (hyphen), . (dot), _ (underscore).']]);
            }

            if ($this->userRepository->getByUsername($username) !== null) {
                return new JsonContent(['error' => ['errorText' => 'The given username is already taken.']]);
            }
        } else {
            $usernameGenerator = new UsernameGenerator();
            do {
                $username = $usernameGenerator->generate();
            } while ($this->userRepository->getByUsername($username));
        }

        $newUser->setUsername($username);
        $newUser->setCreatedDate(new DateTime());

        \Container::$persistentDataManager->saveToDb($newUser);

        if ($googleUserData !== null) {
            $this->sendWelcomeEmail($newUser->getEmail());

            \Container::$request->setUser($newUser);
        } else {
            $token = bin2hex(random_bytes(16));

            $confirmation = new UserConfirmation();
            $confirmation->setUser($newUser);
            $confirmation->setToken($token);
            $confirmation->setLastSentDate(new DateTime());

            \Container::$persistentDataManager->saveToDb($confirmation);

            $this->sendConfirmationEmail($newUser->getEmail(), $token, $newUser->getCreatedDate());
        }

        \Container::$request->session()->delete('tmp_user_data');
        \Container::$request->session()->delete('google_user_data');

        return new JsonContent(['success' => true]);
    }

    public function resetSignup(): IContent
    {
        \Container::$request->session()->delete('tmp_user_data');

        return new JsonContent(['success' => true]);
    }

    public function resetGoogleSignup(): IContent
    {
        \Container::$request->session()->delete('google_user_data');

        return new JsonContent(['success' => true]);
    }

    public function activate()
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
        }

        $confirmation = $this->userConfirmationRepository->getByToken(substr(\Container::$request->query('token'), 0, 32));

        if ($confirmation === null) {
            return new HtmlContent('login/activate');
        }

        \Container::$persistentDataManager->deleteFromDb($confirmation);

        $user = $this->userRepository->getById($confirmation->getUserId());
        $user->setActive(true);

        \Container::$persistentDataManager->saveToDb($user);

        \Container::$request->setUser($user);

        $this->deleteRedirectUrl();
        return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
    }

    public function cancel()
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
        }

        $confirmation = $this->userConfirmationRepository->getByToken(substr(\Container::$request->query('token'), 0, 32));

        if ($confirmation === null) {
            return new HtmlContent('login/cancel', ['success' => false]);
        }

        \Container::$persistentDataManager->deleteFromDb($confirmation);

        $user = $this->userRepository->getById($confirmation->getUserId());

        foreach ($this->userPlayedPlaceRepository->getAllByUser($user) as $userPlayedPlace) {
            \Container::$persistentDataManager->deleteFromDb($userPlayedPlace);
        }

        \Container::$persistentDataManager->deleteFromDb($user);

        return new HtmlContent('login/cancel', ['success' => true]);
    }

    public function requestPasswordReset(): IContent
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new JsonContent([
                'redirect' => [
                    'target' => $this->redirectUrl
                ]
            ]);
        }

        if (!empty($_ENV['RECAPTCHA_SITEKEY'])) {
            if (!\Container::$request->post('g-recaptcha-response')) {
                return new JsonContent(['error' => ['errorText' => 'Please check "I\'m not a robot" in the reCAPTCHA box!']]);
            }

            $captchaValidator = new CaptchaValidator();
            $captchaResponse = $captchaValidator->validate(\Container::$request->post('g-recaptcha-response'));
            if (!$captchaResponse['success']) {
                return new JsonContent(['error' => ['errorText' => 'reCAPTCHA challenge failed. Please try again!']]);
            }
        }

        $user = $this->userRepository->getByEmailOrUsername(\Container::$request->post('email'));

        if ($user === null) {
            return new JsonContent([
                'error' => [
                    'errorText' => 'No user found with the given email address / username. You can <a href="/signup" title="Sign up">sign up</a>!'
                ]
            ]);
        }

        if (!$user->getActive()) {
            $this->resendConfirmationEmail($user);

            return new JsonContent([
                'error' => [
                    'errorText' => 'User found with the given email address / username, but the account is not activated. ' .
                        'Please check your email and click on the activation link!'
                ]
            ]);
        }

        $existingResetter = $this->userPasswordResetterRepository->getByUser($user);

        if ($existingResetter !== null && $existingResetter->getExpiresDate() > new DateTime()) {
            return new JsonContent([
                'error' => [
                    'errorText' => 'Password reset was recently requested for this account. Please check your email, or try again later!'
                ]
            ]);
        }

        $token = bin2hex(random_bytes(16));
        $expires = new DateTime('+1 hour');

        $passwordResetter = new UserPasswordResetter();
        $passwordResetter->setUser($user);
        $passwordResetter->setToken($token);
        $passwordResetter->setExpiresDate($expires);

        if ($existingResetter !== null) {
            \Container::$persistentDataManager->deleteFromDb($existingResetter);
        }

        \Container::$persistentDataManager->saveToDb($passwordResetter);

        $this->sendPasswordResetEmail($user->getEmail(), $token, $expires);

        return new JsonContent(['success' => true]);
    }


    public function resetPassword(): IContent
    {
        if (\Container::$request->user() !== null) {
            $this->deleteRedirectUrl();
            return new JsonContent([
                'redirect' => [
                    'target' => $this->redirectUrl
                ]
            ]);
        }

        $token = \Container::$request->query('token');
        $resetter = $this->userPasswordResetterRepository->getByToken($token);

        if ($resetter === null || $resetter->getExpiresDate() < new DateTime()) {
            return new JsonContent([
                'redirect' => [
                    'target' => \Container::$routeCollection->getRoute('password-reset')->generateLink(['token' => $token])
                ]
            ]);
        }

        if (strlen(\Container::$request->post('password')) < 6) {
            return new JsonContent([
                'error' => [
                    'errorText' => 'The given password is too short. Please choose a password that is at least 6 characters long!'
                ]
            ]);
        }

        if (\Container::$request->post('password') !== \Container::$request->post('password_confirm')) {
            return new JsonContent(['error' => ['errorText' => 'The given passwords do not match.']]);
        }

        \Container::$persistentDataManager->deleteFromDb($resetter);

        $user = $this->userRepository->getById($resetter->getUserId());
        $user->setPlainPassword(\Container::$request->post('password'));

        \Container::$persistentDataManager->saveToDb($user);

        \Container::$request->setUser($user);

        $this->deleteRedirectUrl();
        return new JsonContent(['success' => true]);
    }

    private function sendConfirmationEmail(string $email, string $token, DateTime $created): void
    {
        $mail = new Mail();
        $mail->addRecipient($email);
        $mail->setSubject('Welcome to ' . $_ENV['APP_NAME'] . ' - Activate your account');
        $mail->setBodyFromTemplate('signup', [
            'EMAIL' => $email,
            'ACTIVATE_LINK' => \Container::$request->getBase() .
                \Container::$routeCollection->getRoute('signup.activate')->generateLink(['token' => $token]),
            'CANCEL_LINK' => \Container::$request->getBase() .
                \Container::$routeCollection->getRoute('signup.cancel')->generateLink(['token' => $token]),
            'ACTIVATABLE_UNTIL' => (clone $created)->add(new DateInterval('P1D'))->format('Y-m-d H:i T')
        ]);
        $mail->send();
    }

    private function resendConfirmationEmail(User $user): bool
    {
        $confirmation = $this->userConfirmationRepository->getByUser($user);

        if ($confirmation === null || (clone $confirmation->getLastSentDate())->add(new DateInterval('PT1H')) > new DateTime()) {
            return false;
        }

        $confirmation->setLastSentDate(new DateTime());

        \Container::$persistentDataManager->saveToDb($confirmation);

        $this->sendConfirmationEmail($user->getEmail(), $confirmation->getToken(), $user->getCreatedDate());

        return true;
    }

    private function sendWelcomeEmail(string $email): void
    {
        $mail = new Mail();
        $mail->addRecipient($email);
        $mail->setSubject('Welcome to ' . $_ENV['APP_NAME']);
        $mail->setBodyFromTemplate('signup-noconfirm', [
            'EMAIL' => $email,
        ]);
        $mail->send();
    }

    private function sendPasswordResetEmail(string $email, string $token, DateTime $expires): void
    {
        $mail = new Mail();
        $mail->addRecipient($email);
        $mail->setSubject($_ENV['APP_NAME'] . ' - Password reset');
        $mail->setBodyFromTemplate('password-reset', [
            'EMAIL' => $email,
            'RESET_LINK' => \Container::$request->getBase() .
                \Container::$routeCollection->getRoute('password-reset')->generateLink(['token' => $token]),
            'EXPIRES' => $expires->format('Y-m-d H:i T')
        ]);
        $mail->send();
    }

    private function deleteRedirectUrl(): void
    {
        \Container::$request->session()->delete('redirect_after_login');
    }
}