package com.piotrkalitka.Placer.api.v1;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.piotrkalitka.Placer.api.v1.apiModels.addImage.AddImageResponseBody;
import com.piotrkalitka.Placer.api.v1.apiModels.addPlace.AddPlaceRequestModel;
import com.piotrkalitka.Placer.api.v1.apiModels.addPlace.AddPlaceResponseModel;
import com.piotrkalitka.Placer.api.v1.apiModels.changePassword.ChangePasswordRequestModel;
import com.piotrkalitka.Placer.api.v1.apiModels.getMyPlaces.GetMyPlacesResponseModel;
import com.piotrkalitka.Placer.api.v1.apiModels.getPlace.GetPlaceResponseModel;
import com.piotrkalitka.Placer.api.v1.apiModels.getUserFavourites.GetUserFavouritesResponseModel;
import com.piotrkalitka.Placer.api.v1.apiModels.login.LoginRequestModel;
import com.piotrkalitka.Placer.api.v1.apiModels.login.LoginResponseModel;
import com.piotrkalitka.Placer.api.v1.apiModels.ratePlace.RatePlaceRequestModel;
import com.piotrkalitka.Placer.api.v1.apiModels.ratings.GetRatingsResponseModel;
import com.piotrkalitka.Placer.api.v1.apiModels.refresh.RefreshRequestModel;
import com.piotrkalitka.Placer.api.v1.apiModels.refresh.RefreshResponseModel;
import com.piotrkalitka.Placer.api.v1.apiModels.register.RegisterRequestModel;
import com.piotrkalitka.Placer.api.v1.apiModels.updatePlace.UpdatePlaceRequestModel;
import com.piotrkalitka.Placer.api.v1.apiModels.updatePlace.UpdatePlaceResponseModel;
import com.piotrkalitka.Placer.api.v1.dbModels.Place;
import com.piotrkalitka.Placer.api.v1.dbModels.Rating;
import com.piotrkalitka.Placer.api.v1.dbModels.User;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.List;

@Component
@RestController
@RequestMapping(value = "/v1")
public class ApiController {

    private DataManager dataManager = new DataManager();

    /////////////////////////////////////// AUTH ///////////////////////////////////////////////////

    @RequestMapping(value = "/auth/register", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<Object> register(@RequestBody RegisterRequestModel requestModel) {
        String email = requestModel.getEmail();
        String name = requestModel.getName();
        String surname = requestModel.getSurname();
        String password = requestModel.getPassword();
        String passwordConfirmation = requestModel.getPasswordConfirmation();

        if (isEmpty(email, name, surname, password, passwordConfirmation)) {
            ApiError error = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.REGISTER_MISSING_DATA);
            return new ResponseEntity<>(error, new HttpHeaders(), error.getStatus());
        } else if (!DataValidator.isEmailValid(email)) {
            ApiError error = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.REGISTER_EMAIL_INVALID);
            return new ResponseEntity<>(error, new HttpHeaders(), error.getStatus());
        } else if (!password.equals(passwordConfirmation)) {
            ApiError error = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.REGISTER_PASSWORDS_NOT_MATCHES);
            return new ResponseEntity<>(error, new HttpHeaders(), error.getStatus());
        } else if (dataManager.isEmailRegistered(email)) {
            ApiError error = new ApiError(HttpStatus.CONFLICT, ErrorMessages.REGISTER_EMAIL_TAKEN);
            return new ResponseEntity<>(error, new HttpHeaders(), error.getStatus());
        }

        dataManager.addUser(email, name, surname, PasswordEncoder.encodePasswordSHA256(password));
        return new ResponseEntity<>(HttpStatus.CREATED);
    }

    @RequestMapping(value = "/auth/login", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<Object> login(@RequestBody LoginRequestModel requestModel) {
        String email = requestModel.getEmail();
        String password = requestModel.getPassword();

        if (!dataManager.isEmailRegistered(email)) {
            ApiError error = new ApiError(HttpStatus.NOT_FOUND, ErrorMessages.LOGIN_EMAIL_NOT_FOUND);
            return new ResponseEntity<>(error, new HttpHeaders(), error.getStatus());
        }

        User user = dataManager.getUser(email);

        if (!PasswordEncoder.encodePasswordSHA256(password).equals(user.getPassword())) {
            ApiError error = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.LOGIN_WRONG_PASSWORD);
            return new ResponseEntity<>(error, new HttpHeaders(), error.getStatus());
        }

        String accessToken = generateAccessToken(user.getId(), user.getEmail());
        String refreshToken = generateRefreshToken(user.getId(), user.getEmail());
        return new ResponseEntity<>(new LoginResponseModel(user.getEmail(), accessToken, refreshToken), new HttpHeaders(), HttpStatus.OK);
    }

    @RequestMapping(value = "/auth/refresh", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<Object> refresh(@RequestBody RefreshRequestModel requestModel) {
        String refreshToken = requestModel.getRefreshToken();
        if (isEmpty(refreshToken)) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.REFRESH_MISSING_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }
        if (!DataManager.isTokenValid(refreshToken)) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.REFRESH_TOKEN_INVALID);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }
        User user = dataManager.getUserByToken(refreshToken);
        String accessToken = generateAccessToken(user.getId(), user.getEmail());
        refreshToken = generateRefreshToken(user.getId(), user.getEmail());

        RefreshResponseModel responseModel = new RefreshResponseModel(user.getEmail(), accessToken, refreshToken);
        return new ResponseEntity<>(responseModel, new HttpHeaders(), HttpStatus.OK);
    }

    @RequestMapping(value = "/auth/changePassword", method = RequestMethod.PATCH)
    @ResponseBody
    public ResponseEntity<Object> changePassword(@RequestBody ChangePasswordRequestModel requestModel) {

        String email = requestModel.getEmail();
        String oldPassword = requestModel.getOldPassword();
        String password = requestModel.getPassword();
        String passwordConfirmation = requestModel.getPasswordConfirmation();

        if (isEmpty(email, oldPassword, password, passwordConfirmation)) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.CHANGE_PASSWORD_MISSING_DATA);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        User user = dataManager.getUser(email);

        if (user == null) {
            ApiError apiError = new ApiError(HttpStatus.NOT_FOUND, ErrorMessages.CHANGE_PASSWORD_USER_NOT_FOUND);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }
        if (!PasswordEncoder.encodePasswordSHA256(oldPassword).equals(user.getPassword())) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.CHANGE_PASSWORD_WRONG_PASSWORD);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        dataManager.changePassword(user.getId(), PasswordEncoder.encodePasswordSHA256(password));
        return new ResponseEntity<>(HttpStatus.OK);
    }

    /////////////////////////////////////// PLACES /////////////////////////////////////////////////

    @RequestMapping(value = "/places/{placeId}", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<Object> getPlace(@PathVariable("placeId") int placeId) {
        Place place = dataManager.getPlace(placeId);
        if (place == null) {
            ApiError apiError = new ApiError(HttpStatus.NOT_FOUND, ErrorMessages.GET_PLACE_NOT_FOUND);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }
        return new ResponseEntity<>(new GetPlaceResponseModel(place), new HttpHeaders(), HttpStatus.OK);
    }

    @RequestMapping(value = "/places", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<Object> getPlaces(@RequestParam(required = false, name = "limit") Integer limit) {
        if (limit == null) limit = 100;
        List<Place> places = dataManager.getPlaces(limit);
        return new ResponseEntity<>(places, new HttpHeaders(), HttpStatus.OK);
    }

    /////////////////////////////////////// PLACES - RATING ////////////////////////////////////////

    @RequestMapping(value = "/places/{placeId}/ratings", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<Object> rate(@RequestBody RatePlaceRequestModel requestModel, @PathVariable("placeId") int placeId, @RequestHeader("Authorization") String authToken) {
        if (!DataManager.isTokenValid(authToken)) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.INVALID_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        int rate = requestModel.getRate();

        if (rate < 1 || rate > 5) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.RATE_PLACE_RATE_RANGE);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        int userId = getUserIdFromToken(authToken);

        if (dataManager.isRated(userId, placeId)) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.RATE_PLACE_ALREADY_RATED);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        dataManager.rate(userId, placeId, rate);
        return new ResponseEntity<>(HttpStatus.CREATED);
    }

    @RequestMapping(value = "/places/{placeId}/ratings", method = RequestMethod.DELETE)
    @ResponseBody
    public ResponseEntity<Object> removeRate(@PathVariable int placeId, @RequestHeader("Authorization") String authToken) {
        if (!DataManager.isTokenValid(authToken)) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.INVALID_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        int userId = getUserIdFromToken(authToken);

        if (!dataManager.isRated(userId, placeId)) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.REMOVE_RATE_NOT_RATED);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        dataManager.removeRate(placeId, userId);
        return new ResponseEntity<>(HttpStatus.NO_CONTENT);

    }

    @RequestMapping(value = "/places/{placeId}/ratings", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<Object> getRatings(@PathVariable("placeId") int placeId) {
        List<Rating> ratings = dataManager.getRatings(placeId);

        GetRatingsResponseModel responseModel = new GetRatingsResponseModel(ratings);
        return new ResponseEntity<>(responseModel, new HttpHeaders(), HttpStatus.OK);
    }

    /////////////////////////////////////// USER ///////////////////////////////////////////////////

    @RequestMapping(value = "/user/places", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<Object> getMyPlaces(@RequestHeader("Authorization") String authToken) {

        if (!DataManager.isTokenValid(authToken)) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.INVALID_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        int userId = getUserIdFromToken(authToken);
        List<Place> places = dataManager.getUserPlaces(userId);

        GetMyPlacesResponseModel model = new GetMyPlacesResponseModel(places);

        return new ResponseEntity<>(model, new HttpHeaders(), HttpStatus.OK);
    }

    @RequestMapping(value = "/user/places", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<Object> addPlace(@RequestBody AddPlaceRequestModel requestModel, @RequestHeader("Authorization") String authToken) {
        String name = requestModel.getName();
        String address = requestModel.getAddress();
        String website = requestModel.getWebsite();
        String phoneNumber = requestModel.getPhoneNumber();
        String description = requestModel.getDescription();

        if (!DataManager.isTokenValid(authToken)) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.INVALID_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        if (isEmpty(name, address, website, phoneNumber, description)) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.ADD_PLACE_MISSING_DATA);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        User user = dataManager.getUserByToken(authToken);
        int userId = user.getId();

        int placeId = dataManager.addPlace(userId, name, address, website, phoneNumber, description);
        Place place = new Place(placeId, userId, name, address, website, phoneNumber, description);
        AddPlaceResponseModel model = new AddPlaceResponseModel(place);
        return new ResponseEntity<>(model, new HttpHeaders(), HttpStatus.CREATED);
    }

    @RequestMapping(value = "/user/places/{placeId}", method = RequestMethod.PATCH)
    @ResponseBody
    public ResponseEntity<Object> updatePlace(@RequestBody UpdatePlaceRequestModel requestModel, @RequestHeader("Authorization") String authToken, @PathVariable("placeId") int placeId) {

        String newName = requestModel.getName();
        String newAddress = requestModel.getAddress();
        String newWebsite = requestModel.getWebsite();
        String newPhoneNumber = requestModel.getPhoneNumber();
        String newDescription = requestModel.getDescription();

        Place place = dataManager.getPlace(placeId);
        User user = dataManager.getUserByToken(authToken);

        if (place == null) {
            ApiError apiError = new ApiError(HttpStatus.NOT_FOUND, ErrorMessages.UPDATE_PLACE_NOT_FOUND);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }
        if (place.getUserId() != user.getId()) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.UPDATE_PLACE_FORBIDDEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        if (isEmpty(newName)) newName = place.getName();
        if (isEmpty(newAddress)) newAddress = place.getAddress();
        if (isEmpty(newWebsite)) newWebsite = place.getWebsite();
        if (isEmpty(newPhoneNumber)) newPhoneNumber = place.getPhoneNumber();
        if (isEmpty(newDescription)) newDescription = place.getDescription();

        dataManager.updatePlace(placeId, user.getId(), newName, newAddress, newWebsite, newPhoneNumber, newDescription);
        UpdatePlaceResponseModel model = new UpdatePlaceResponseModel(new Place(placeId, user.getId(), newName, newAddress, newWebsite, newPhoneNumber, newDescription));
        return new ResponseEntity<>(model, new HttpHeaders(), HttpStatus.OK);
    }

    @RequestMapping(value = "/user/places/{placeId}", method = RequestMethod.DELETE)
    @ResponseBody
    public ResponseEntity<Object> removePlace(@PathVariable("placeId") int placeId, @RequestHeader("Authorization") String authToken) {
        if (!DataManager.isTokenValid(authToken)) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.INVALID_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        int userId = dataManager.getUserByToken(authToken).getId();
        Place place = dataManager.getPlace(placeId);

        if (place == null) {
            ApiError apiError = new ApiError(HttpStatus.NOT_FOUND, ErrorMessages.REMOVE_PLACE_NOT_FOUND);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }
        if (place.getUserId() != userId) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.REMOVE_PLACE_FORBIDDEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        dataManager.removePlace(placeId);
        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }

    /////////////////////////////////////// PLACES - IMAGES ////////////////////////////////////////

    @RequestMapping(value = "/user/places/{placeId}/images", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<Object> addImage(@RequestHeader("Authorization") String authToken, @PathVariable("placeId") int placeId, @RequestParam("image") MultipartFile image) {
        if (!DataManager.isTokenValid(authToken)) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.INVALID_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }
        if (image.isEmpty()) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.ADD_IMAGE_IMAGE_EMPTY);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        User user = dataManager.getUserByToken(authToken);
        Place place = dataManager.getPlace(placeId);

        if (user.getId() != place.getUserId()) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.ADD_IMAGE_FORBIDDEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        String filePath = dataManager.saveImage(placeId, image);

        if (filePath == null) {
            ApiError apiError = new ApiError(HttpStatus.BAD_GATEWAY, ErrorMessages.ADD_IMAGE_ERROR);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        int imageId = dataManager.addImage(placeId, filePath);
        AddImageResponseBody model = new AddImageResponseBody(imageId, filePath);

        return new ResponseEntity<>(model, new HttpHeaders(), HttpStatus.CREATED);
    }

    @RequestMapping(value = "/user/places/{placeId}/images/{imageId}", method = RequestMethod.DELETE)
    @ResponseBody
    public ResponseEntity<Object> removeImage(@RequestHeader("Authorization") String authToken, @PathVariable("placeId") int placeId, @PathVariable("imageId") int imageId) {
        if (!DataManager.isTokenValid(authToken)) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.INVALID_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        User user = dataManager.getUserByToken(authToken);
        Place place = dataManager.getPlace(placeId);

        if (place.getUserId() != user.getId()) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.REMOVE_IMAGE_FORBIDDEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }
        if (!dataManager.doesImageExist(imageId)) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.REMOVE_IMAGE_IMAGE_NOT_EXIST);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        dataManager.removeImage(imageId);
        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }

    @RequestMapping(value = "/user/places/{placeId}/image", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<Object> getImagesForPlace(@PathVariable("placeId") int placeId) {
        return null;
    }

    /////////////////////////////////////// USER-FAVOURITES ////////////////////////////////////////

    @RequestMapping(value = "/user/favourites/{placeId}", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<Object> addUserToFavourites(@PathVariable("placeId") int placeId, @RequestHeader("Authorization") String authToken) {
        if (!DataManager.isTokenValid(authToken)) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.INVALID_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }
        int userId = getUserIdFromToken(authToken);

        if (dataManager.isFavourite(userId, placeId)) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.ADD_FAVOURITE_ALREADY_ADDED);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        dataManager.addFavourite(userId, placeId);

        return new ResponseEntity<>(HttpStatus.OK);
    }

    @RequestMapping(value = "/user/favourites", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<Object> getUserFavourites(@RequestHeader("Authorization") String authToken) {
        if (!DataManager.isTokenValid(authToken)) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.INVALID_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        int userId = getUserIdFromToken(authToken);
        List<Place> places = dataManager.getUserFavourites(userId);
        GetUserFavouritesResponseModel model = new GetUserFavouritesResponseModel(places);
        return new ResponseEntity<>(model, new HttpHeaders(), HttpStatus.OK);
    }

    @RequestMapping(value = "/user/favourites/{id}", method = RequestMethod.DELETE)
    @ResponseBody
    public ResponseEntity<Object> removeFromFavourites(@PathVariable("id") int placeId, @RequestHeader("Authorization") String authToken) {
        if (!DataManager.isTokenValid(authToken)) {
            ApiError apiError = new ApiError(HttpStatus.FORBIDDEN, ErrorMessages.INVALID_TOKEN);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        int userId = getUserIdFromToken(authToken);
        if (!dataManager.isFavourite(userId, placeId)) {
            ApiError apiError = new ApiError(HttpStatus.BAD_REQUEST, ErrorMessages.REMOVE_FAVOURITE_PLACE_NOT_FAVOURITE);
            return new ResponseEntity<>(apiError, new HttpHeaders(), apiError.getStatus());
        }

        dataManager.removeFromFavourite(userId, placeId);
        return new ResponseEntity<>(HttpStatus.OK);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////

    private static boolean isEmpty(String string) {
        return string == null || string.equals("");
    }

    private static boolean isEmpty(String... strings) {
        for (String string : strings) {
            if (isEmpty(string)) return true;
        }
        return false;
    }

    @Nullable
    private static String generateAccessToken(int userId, String email) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(Constants.JWT_SECRET);
            return JWT.create()
                    .withExpiresAt(new Date(new Date().getTime() + Constants.ACCESS_TOKEN_DURATION_MILLIS))
                    .withClaim("id", userId)
                    .withClaim("email", email)
                    .sign(algorithm);
        } catch (UnsupportedEncodingException ignore) {
            return null;
        }
    }

    @Nullable
    private static String generateRefreshToken(int userId, String email) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(Constants.JWT_SECRET);
            return JWT.create()
                    .withExpiresAt(new Date(new Date().getTime() + Constants.REFRESH_TOKEN_DURATION_MILLIS))
                    .withClaim("id", userId)
                    .withClaim("email", email)
                    .sign(algorithm);
        } catch (UnsupportedEncodingException ignore) {
            return null;
        }
    }

    private static int getUserIdFromToken(String token) {
        DecodedJWT decodedJWT = JWT.decode(token);
        return decodedJWT.getClaim("id").asInt();
    }

}