*      Copyright (c) 2004-2014 Stuart Boston

*

*      This file is part of TheMovieDB API.

*

*      TheMovieDB API is free software: you can redistribute it and/or modify

*      it under the terms of the GNU General Public License as published by

*      the Free Software Foundation, either version 3 of the License, or

*      any later version.

*

*      TheMovieDB API is distributed in the hope that it will be useful,

*      but WITHOUT ANY WARRANTY; without even the implied warranty of

*      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

*      GNU General Public License for more details.

*

*      You should have received a copy of the GNU General Public License

*      along with TheMovieDB API.  If not, see <http://www.gnu.org/licenses/>.

*

*/

* The MovieDb API

* <p>

* This is for version 3 of the API as specified here:

* http://help.themoviedb.org/kb/api/about-3

*

* @author stuart.boston

*/

    private static final Logger LOG = LoggerFactory.getLogger(TheMovieDbApi.class);

    private String apiKey;

    private CommonHttpClient httpClient;

    private TmdbConfiguration tmdbConfig;

    // API Methods

    private static final String BASE_MOVIE = "movie/";

    private static final String BASE_PERSON = "person/";

    private static final String BASE_COMPANY = "company/";

    private static final String BASE_GENRE = "genre/";

    private static final String BASE_AUTH = "authentication/";

    private static final String BASE_COLLECTION = "collection/";

    private static final String BASE_ACCOUNT = "account/";

    private static final String BASE_SEARCH = "search/";

    private static final String BASE_LIST = "list/";

    private static final String BASE_KEYWORD = "keyword/";

    private static final String BASE_JOB = "job/";

    private static final String BASE_DISCOVER = "discover/";

    private static final String URL_MOVIES = "/movies";

    private static final String URL_IMAGES = "/images";

    // Jackson JSON configuration

    private static ObjectMapper mapper = new ObjectMapper();

    // Constants

    private static final String MOVIE_ID = "movie_id";

    private static final int YEAR_LENGTH = 4;

    private static final int RATING_MAX = 10;

    private static final int POST_SUCCESS_STATUS_CODE = 12;

    /**

     * API for The Movie Db.

     *

     * @param apiKey

     * @throws MovieDbException

     */

    public TheMovieDbApi(String apiKey) throws MovieDbException {

        this(apiKey, null);

    }

    /**

     * API for The Movie Db.

     *

     * @param apiKey

     * @param httpClient The httpClient to use for web requests.

     * @throws MovieDbException

     */

    public TheMovieDbApi(String apiKey, CommonHttpClient httpClient) throws MovieDbException {

        this.apiKey = apiKey;

        this.httpClient = httpClient;

        ApiUrl apiUrl = new ApiUrl(apiKey, "configuration");

        URL configUrl = apiUrl.buildUrl();

        String webpage = requestWebPage(configUrl);

        try {

            WrapperConfig wc = mapper.readValue(webpage, WrapperConfig.class);

            tmdbConfig = wc.getTmdbConfiguration();

        } catch (IOException ex) {

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, "Failed to read configuration", configUrl, ex);

        }

    }

    /**

     * Get the API key that is to be used

     *

     * @return

     */

    public String getApiKey() {

        return apiKey;

    }

    private String requestWebPage(URL url) throws MovieDbException {

        return requestWebPage(url, null, Boolean.FALSE);

    }

    private String requestWebPage(URL url, String jsonBody) throws MovieDbException {

        return requestWebPage(url, jsonBody, Boolean.FALSE);

    }

    private String requestWebPage(URL url, String jsonBody, boolean isDeleteRequest) throws MovieDbException {

        String webpage;

        // use HTTP client implementation

        if (httpClient == null) {

            // use web browser

            webpage = WebBrowser.request(url, jsonBody, isDeleteRequest);

        } else {

            try {

                HttpGet httpGet = new HttpGet(url.toURI());

                httpGet.addHeader("accept", "application/json");

                if (StringUtils.isNotBlank(jsonBody)) {

                    // TODO: Add the json body to the request

                    throw new MovieDbException(MovieDbExceptionType.UNKNOWN_CAUSE, "Unable to proces JSON request", url);

                }

                if (isDeleteRequest) {

                    //TODO: Handle delete request

                    throw new MovieDbException(MovieDbExceptionType.UNKNOWN_CAUSE, "Unable to proces delete request", url);

                }

                webpage = httpClient.requestContent(httpGet);

            } catch (URISyntaxException ex) {

                throw new MovieDbException(MovieDbException.MovieDbExceptionType.CONNECTION_ERROR, null, url, ex);

            } catch (IOException ex) {

                throw new MovieDbException(MovieDbException.MovieDbExceptionType.CONNECTION_ERROR, null, url, ex);

            } catch (RuntimeException ex) {

                throw new MovieDbException(MovieDbException.MovieDbExceptionType.HTTP_503_ERROR, "Service Unavailable", url, ex);

            }

        }

        return webpage;

    }

    /**

     * Set the proxy information

     *

     * @param host

     * @param port

     * @param username

     * @param password

     */

    public void setProxy(String host, int port, String username, String password) {

        // should be set in HTTP client already

        if (httpClient != null) {

            return;

        }

        WebBrowser.setProxyHost(host);

        WebBrowser.setProxyPort(port);

        WebBrowser.setProxyUsername(username);

        WebBrowser.setProxyPassword(password);

    }

    /**

     * Set the connection and read time out values

     *

     * @param connect

     * @param read

     */

    public void setTimeout(int connect, int read) {

        // should be set in HTTP client already

        if (httpClient != null) {

            return;

        }

        WebBrowser.setWebTimeoutConnect(connect);

        WebBrowser.setWebTimeoutRead(read);

    }

    /**

     * Compare the MovieDB object with a title & year

     *

     * @param moviedb The moviedb object to compare too

     * @param title The title of the movie to compare

     * @param year The year of the movie to compare exact match

     * @return True if there is a match, False otherwise.

     */

    public static boolean compareMovies(MovieDb moviedb, String title, String year) {

        return compareMovies(moviedb, title, year, 0);

    }

    /**

     * Compare the MovieDB object with a title & year

     *

     * @param moviedb The moviedb object to compare too

     * @param title The title of the movie to compare

     * @param year The year of the movie to compare

     * @param maxDistance The Levenshtein Distance between the two titles. 0 =

     * exact match

     * @param caseSensitive true if the comparison is to be case sensitive

     * @return True if there is a match, False otherwise.

     */

    public static boolean compareMovies(MovieDb moviedb, String title, String year, int maxDistance, boolean caseSensitive) {

        if ((moviedb == null) || (StringUtils.isBlank(title))) {

            return Boolean.FALSE;

        }

        String cmpTitle, cmpOtherTitle, cmpOriginalTitle;

        if (caseSensitive) {

            cmpTitle = title;

            cmpOtherTitle = moviedb.getOriginalTitle();

            cmpOriginalTitle = moviedb.getTitle();

        } else {

            cmpTitle = title.toLowerCase();

            cmpOtherTitle = moviedb.getTitle().toLowerCase();

            cmpOriginalTitle = moviedb.getOriginalTitle().toLowerCase();

        }

        if (isValidYear(year) && isValidYear(moviedb.getReleaseDate())) {

            // Compare with year

            String movieYear = moviedb.getReleaseDate().substring(0, YEAR_LENGTH);

            if (movieYear.equals(year)) {

                if (compareDistance(cmpOriginalTitle, cmpTitle, maxDistance)) {

                    return Boolean.TRUE;

                }

                if (compareDistance(cmpOtherTitle, cmpTitle, maxDistance)) {

                    return Boolean.TRUE;

                }

            }

        }

        // Compare without year

        if (compareDistance(cmpOriginalTitle, cmpTitle, maxDistance)) {

            return Boolean.TRUE;

        }

        if (compareDistance(cmpOtherTitle, cmpTitle, maxDistance)) {

            return Boolean.TRUE;

        }

        return Boolean.FALSE;

    }

    /**

     * Compare the MovieDB object with a title & year, case sensitive

     *

     * @param moviedb

     * @param title

     * @param year

     * @param maxDistance

     * @return

     */

    public static boolean compareMovies(MovieDb moviedb, String title, String year, int maxDistance) {

        return compareMovies(moviedb, title, year, maxDistance, true);

    }

    /**

     * Compare the Levenshtein Distance between the two strings

     *

     * @param title1

     * @param title2

     * @param distance

     */

    private static boolean compareDistance(String title1, String title2, int distance) {

        return StringUtils.getLevenshteinDistance(title1, title2) <= distance;

    }

    /**

     * Check the year is not blank or UNKNOWN

     *

     * @param year

     */

    private static boolean isValidYear(String year) {

        return StringUtils.isNotBlank(year) && !"UNKNOWN".equals(year);

    }

    //<editor-fold defaultstate="collapsed" desc="Configuration Functions">

    /**

     * Get the configuration information

     *

     * @return

     */

    public TmdbConfiguration getConfiguration() {

        return tmdbConfig;

    }

    /**

     * Generate the full image URL from the size and image path

     *

     * @param imagePath

     * @param requiredSize

     * @return

     * @throws MovieDbException

     */

    public URL createImageUrl(String imagePath, String requiredSize) throws MovieDbException {

        if (!tmdbConfig.isValidSize(requiredSize)) {

            throw new MovieDbException(MovieDbExceptionType.INVALID_IMAGE, requiredSize, "");

        }

        StringBuilder sb = new StringBuilder(tmdbConfig.getBaseUrl());

        sb.append(requiredSize);

        sb.append(imagePath);

        try {

            return new URL(sb.toString());

        } catch (MalformedURLException ex) {

            LOG.warn("Failed to create image URL: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.INVALID_URL, sb.toString(), "", ex);

        }

    }

    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Authentication Functions">

    /**

     * This method is used to generate a valid request token for user based

     * authentication.

     *

     * A request token is required in order to request a session id.

     *

     * You can generate any number of request tokens but they will expire after

     * 60 minutes.

     *

     * As soon as a valid session id has been created the token will be

     * destroyed.

     *

     * @return

     * @throws MovieDbException

     */

    public TokenAuthorisation getAuthorisationToken() throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_AUTH, "token/new");

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            return mapper.readValue(webpage, TokenAuthorisation.class);

        } catch (IOException ex) {

            LOG.warn("Failed to get Authorisation Token: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.AUTHORISATION_FAILURE, webpage, url, ex);

        }

    }

    /**

     * This method is used to generate a session id for user based

     * authentication.

     *

     * A session id is required in order to use any of the write methods.

     *

     * @param token

     * @return

     * @throws MovieDbException

     */

    public TokenSession getSessionToken(TokenAuthorisation token) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_AUTH, "session/new");

        if (!token.getSuccess()) {

            LOG.warn("Session token was not successful!");

            throw new MovieDbException(MovieDbExceptionType.AUTHORISATION_FAILURE, "Authorisation token was not successful!", apiUrl.buildUrl());

        }

        apiUrl.addArgument(PARAM_TOKEN, token.getRequestToken());

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            return mapper.readValue(webpage, TokenSession.class);

        } catch (IOException ex) {

            LOG.warn("Failed to get Session Token: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * This method is used to generate a guest session id.

     *

     * A guest session can be used to rate movies without having a registered

     * TMDb user account.

     *

     * You should only generate a single guest session per user (or device) as

     * you will be able to attach the ratings to a TMDb user account in the

     * future.

     *

     * There are also IP limits in place so you should always make sure it's the

     * end user doing the guest session actions.

     *

     * If a guest session is not used for the first time within 24 hours, it

     * will be automatically discarded.

     *

     * @return

     * @throws MovieDbException

     */

    public TokenSession getGuestSessionToken() throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_AUTH, "guest_session/new");

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            return mapper.readValue(webpage, TokenSession.class);

        } catch (IOException ex) {

            LOG.warn("Failed to get Guest Session Token: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * Get the basic information for an account. You will need to have a valid

     * session id.

     *

     * @param sessionId

     * @return

     * @throws MovieDbException

     */

    public Account getAccount(String sessionId) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_ACCOUNT.replace("/", ""));

        apiUrl.addArgument(PARAM_SESSION, sessionId);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            return mapper.readValue(webpage, Account.class);

        } catch (IOException ex) {

            LOG.warn("Failed to get Account: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    public List<MovieDb> getFavoriteMovies(String sessionId, int accountId) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_ACCOUNT, accountId + "/favorite_movies");

        apiUrl.addArgument(PARAM_SESSION, sessionId);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            return mapper.readValue(webpage, WrapperMovie.class).getMovies();

        } catch (IOException ex) {

            LOG.warn("Failed to get favorite movies: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    public StatusCode changeFavoriteStatus(String sessionId, int accountId, Integer movieId, boolean isFavorite) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_ACCOUNT, accountId + "/favorite");

        apiUrl.addArgument(PARAM_SESSION, sessionId);

        Map<String, Object> body = new HashMap<String, Object>();

        body.put(MOVIE_ID, movieId);

        body.put("favorite", isFavorite);

        String jsonBody = convertToJson(body);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url, jsonBody);

        try {

            return mapper.readValue(webpage, StatusCode.class);

        } catch (IOException ex) {

            LOG.warn("Failed to get favorite status: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * Add a movie to an accounts watch list.

     *

     * @param sessionId

     * @param accountId

     * @param movieId

     * @return

     * @throws MovieDbException

     */

    public StatusCode addToWatchList(String sessionId, int accountId, Integer movieId) throws MovieDbException {

        return modifyWatchList(sessionId, accountId, movieId, true);

    }

    /**

     * Remove a movie from an accounts watch list.

     *

     * @param sessionId

     * @param accountId

     * @param movieId

     * @return

     * @throws MovieDbException

     */

    public StatusCode removeFromWatchList(String sessionId, int accountId, Integer movieId) throws MovieDbException {

        return modifyWatchList(sessionId, accountId, movieId, false);

    }

    private StatusCode modifyWatchList(String sessionId, int accountId, Integer movieId, boolean add) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_ACCOUNT, accountId + "/movie_watchlist");

        apiUrl.addArgument(PARAM_SESSION, sessionId);

        Map<String, Object> body = new HashMap<String, Object>();

        body.put(MOVIE_ID, movieId);

        body.put("movie_watchlist", add);

        String jsonBody = convertToJson(body);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url, jsonBody);

        try {

            return mapper.readValue(webpage, StatusCode.class);

        } catch (IOException ex) {

            LOG.warn("Failed to modify watch list: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Movie Functions">

    /**

     * This method is used to retrieve all of the basic movie information.

     *

     * It will return the single highest rated poster and backdrop.

     *

     * MovieDbExceptionType.MOVIE_ID_NOT_FOUND will be thrown if there are no

     * movies found.

     *

     * @param movieId

     * @param language

     * @param appendToResponse

     * @return

     * @throws MovieDbException

     */

    public MovieDb getMovieInfo(int movieId, String language, String... appendToResponse) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_MOVIE);

        apiUrl.addArgument(PARAM_ID, movieId);

        if (StringUtils.isNotBlank(language)) {

            apiUrl.addArgument(PARAM_LANGUAGE, language);

        }

        apiUrl.appendToResponse(appendToResponse);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            MovieDb movie = mapper.readValue(webpage, MovieDb.class);

            if (movie == null || movie.getId() == 0) {

                LOG.warn("No movie found for ID '{}'", movieId);

                throw new MovieDbException(MovieDbExceptionType.MOVIE_ID_NOT_FOUND, "No movie found for ID: " + movieId, url);

            }

            return movie;

        } catch (IOException ex) {

            LOG.warn("Failed to get movie info: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * This method is used to retrieve all of the basic movie information.

     *

     * It will return the single highest rated poster and backdrop.

     *

     * MovieDbExceptionType.MOVIE_ID_NOT_FOUND will be thrown if there are no

     * movies found.

     *

     * @param imdbId

     * @param language

     * @param appendToResponse

     * @return

     * @throws MovieDbException

     */

    public MovieDb getMovieInfoImdb(String imdbId, String language, String... appendToResponse) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_MOVIE);

        apiUrl.addArgument(PARAM_ID, imdbId);

        if (StringUtils.isNotBlank(language)) {

            apiUrl.addArgument(PARAM_LANGUAGE, language);

        }

        apiUrl.appendToResponse(appendToResponse);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            MovieDb movie = mapper.readValue(webpage, MovieDb.class);

            if (movie == null || movie.getId() == 0) {

                LOG.warn("No movie found for IMDB ID: '{}'", imdbId);

                throw new MovieDbException(MovieDbExceptionType.MOVIE_ID_NOT_FOUND, "No movie found for IMDB ID: " + imdbId, url);

            }

            return movie;

        } catch (IOException ex) {

            LOG.warn("Failed to get movie info: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, "Failed to get movie info", url, ex);

        }

    }

    /**

     * This method is used to retrieve all of the alternative titles we have for

     * a particular movie.

     *

     * @param movieId

     * @param country

     * @param appendToResponse

     * @return

     * @throws MovieDbException

     */

    public TmdbResultsList<AlternativeTitle> getMovieAlternativeTitles(int movieId, String country, String... appendToResponse) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_MOVIE, "/alternative_titles");

        apiUrl.addArgument(PARAM_ID, movieId);

        if (StringUtils.isNotBlank(country)) {

            apiUrl.addArgument(PARAM_COUNTRY, country);

        }

        apiUrl.appendToResponse(appendToResponse);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            WrapperAlternativeTitles wrapper = mapper.readValue(webpage, WrapperAlternativeTitles.class);

            TmdbResultsList<AlternativeTitle> results = new TmdbResultsList<AlternativeTitle>(wrapper.getTitles());

            results.copyWrapper(wrapper);

            return results;

        } catch (IOException ex) {

            LOG.warn("Failed to get movie alternative titles: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * Get the cast information for a specific movie id.

     *

     * TODO: Add a function to enrich the data with the people methods

     *

     * @param movieId

     * @param appendToResponse

     * @return

     * @throws MovieDbException

     */

    public TmdbResultsList<Person> getMovieCasts(int movieId, String... appendToResponse) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_MOVIE, "/casts");

        apiUrl.addArgument(PARAM_ID, movieId);

        apiUrl.appendToResponse(appendToResponse);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            WrapperMovieCasts wrapper = mapper.readValue(webpage, WrapperMovieCasts.class);

            TmdbResultsList<Person> results = new TmdbResultsList<Person>(wrapper.getAll());

            results.copyWrapper(wrapper);

            return results;

        } catch (IOException ex) {

            LOG.warn("Failed to get movie casts: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * This method should be used when you’re wanting to retrieve all of the

     * images for a particular movie.

     *

     * @param movieId

     * @param language

     * @param appendToResponse

     * @return

     * @throws MovieDbException

     */

    public TmdbResultsList<Artwork> getMovieImages(int movieId, String language, String... appendToResponse) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_MOVIE, URL_IMAGES);

        apiUrl.addArgument(PARAM_ID, movieId);

        if (StringUtils.isNotBlank(language)) {

            apiUrl.addArgument(PARAM_LANGUAGE, language);

        }

        apiUrl.appendToResponse(appendToResponse);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            WrapperImages wrapper = mapper.readValue(webpage, WrapperImages.class);

            TmdbResultsList<Artwork> results = new TmdbResultsList<Artwork>(wrapper.getAll());

            results.copyWrapper(wrapper);

            return results;

        } catch (IOException ex) {

            LOG.warn("Failed to get movie images: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * This method is used to retrieve all of the keywords that have been added

     * to a particular movie.

     *

     * Currently, only English keywords exist.

     *

     * @param movieId

     * @param appendToResponse

     * @return

     * @throws MovieDbException

     */

    public TmdbResultsList<Keyword> getMovieKeywords(int movieId, String... appendToResponse) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_MOVIE, "/keywords");

        apiUrl.addArgument(PARAM_ID, movieId);

        apiUrl.appendToResponse(appendToResponse);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            WrapperMovieKeywords wrapper = mapper.readValue(webpage, WrapperMovieKeywords.class);

            TmdbResultsList<Keyword> results = new TmdbResultsList<Keyword>(wrapper.getKeywords());

            results.copyWrapper(wrapper);

            return results;

        } catch (IOException ex) {

            LOG.warn("Failed to get movie keywords: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * This method is used to retrieve all of the release and certification data

     * we have for a specific movie.

     *

     * @param movieId

     * @param language

     * @param appendToResponse

     * @return

     * @throws MovieDbException

     */

    public TmdbResultsList<ReleaseInfo> getMovieReleaseInfo(int movieId, String language, String... appendToResponse) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_MOVIE, "/releases");

        apiUrl.addArgument(PARAM_ID, movieId);

        apiUrl.addArgument(PARAM_LANGUAGE, language);

        apiUrl.appendToResponse(appendToResponse);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            WrapperReleaseInfo wrapper = mapper.readValue(webpage, WrapperReleaseInfo.class);

            TmdbResultsList<ReleaseInfo> results = new TmdbResultsList<ReleaseInfo>(wrapper.getCountries());

            results.copyWrapper(wrapper);

            return results;

        } catch (IOException ex) {

            LOG.warn("Failed to get movie release information: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * This method is used to retrieve all of the trailers for a particular

     * movie.

     *

     * Supported sites are YouTube and QuickTime.

     *

     * @param movieId

     * @param language

     * @param appendToResponse

     * @return

     * @throws MovieDbException

     */

    public TmdbResultsList<Trailer> getMovieTrailers(int movieId, String language, String... appendToResponse) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_MOVIE, "/trailers");

        apiUrl.addArgument(PARAM_ID, movieId);

        if (StringUtils.isNotBlank(language)) {

            apiUrl.addArgument(PARAM_LANGUAGE, language);

        }

        apiUrl.appendToResponse(appendToResponse);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            WrapperTrailers wrapper = mapper.readValue(webpage, WrapperTrailers.class);

            TmdbResultsList<Trailer> results = new TmdbResultsList<Trailer>(wrapper.getAll());

            results.copyWrapper(wrapper);

            return results;

        } catch (IOException ex) {

            LOG.warn("Failed to get movie trailers: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * This method is used to retrieve a list of the available translations for

     * a specific movie.

     *

     * @param movieId

     * @param appendToResponse

     * @return

     * @throws MovieDbException

     */

    public TmdbResultsList<Translation> getMovieTranslations(int movieId, String... appendToResponse) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_MOVIE, "/translations");

        apiUrl.addArgument(PARAM_ID, movieId);

        apiUrl.appendToResponse(appendToResponse);

        URL url = apiUrl.buildUrl();

        String webpage = requestWebPage(url);

        try {

            WrapperTranslations wrapper = mapper.readValue(webpage, WrapperTranslations.class);

            TmdbResultsList<Translation> results = new TmdbResultsList<Translation>(wrapper.getTranslations());

            results.copyWrapper(wrapper);

            return results;

        } catch (IOException ex) {

            LOG.warn("Failed to get movie tranlations: {}", ex.getMessage(), ex);

            throw new MovieDbException(MovieDbExceptionType.MAPPING_FAILED, webpage, url, ex);

        }

    }

    /**

     * The similar movies method will let you retrieve the similar movies for a

     * particular movie.

     *

     * This data is created dynamically but with the help of users votes on

     * TMDb.

     *

     * The data is much better with movies that have more keywords

     *

     * @param movieId

     * @param language

     * @param page

     * @param appendToResponse

     * @return

     * @throws MovieDbException

     */

    public TmdbResultsList<MovieDb> getSimilarMovies(int movieId, String language, int page, String... appendToResponse) throws MovieDbException {

        ApiUrl apiUrl = new ApiUrl(apiKey, BASE_MOVIE, "/similar_movies");

        apiUrl.addArgument(PARAM_ID, movieId);

        if (StringUtils.isNotBlank(language)) {