/*
 *  Copyright 2017 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.core.authentication.token;

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Base64;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;

import org.ametys.core.datasource.ConnectionHelper;
import org.ametys.core.datasource.dbtype.SQLDatabaseTypeExtensionPoint;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.UserManager;
import org.ametys.core.util.JSONUtils;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

/**
 * The component to handle temporary authentication token.<br>
 * Token can only be used once and are available for a short time only.
 */
public class AuthenticationTokenManager extends AbstractLogEnabled implements Component, Serviceable, Initializable
{
    /** The avalon role */
    public static final String ROLE = AuthenticationTokenManager.class.getName();

    /** The separator in token */
    public static final String TOKEN_SEPARATOR = "#";

    /** The user token type */
    public static final String USER_TOKEN_TYPE = "User";
    
    /** all fields without login and population_id */
    private static final String TOKEN_SQL_GET_FIELDS = "id, token, salt, creation_date, end_date, last_update_date, nb_uses_left, auto_renew_duration, context, type, token_comment";
    
    /** all fields without id and last_update_date */
    private static final String TOKEN_SQL_SET_FIELDS = "login, population_id, token, salt, creation_date, end_date, nb_uses_left, auto_renew_duration, context, type, token_comment";

    private ServiceManager _manager;

    private CurrentUserProvider _currentUserProvider;

    private String _datasourceId;
    
    private SQLDatabaseTypeExtensionPoint _sqlDatabaseTypeExtensionPoint;
    
    private JSONUtils _jsonUtils;
    
    private UserManager _userManager;

    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
        _sqlDatabaseTypeExtensionPoint = (SQLDatabaseTypeExtensionPoint) manager.lookup(SQLDatabaseTypeExtensionPoint.ROLE);
        _jsonUtils = (JSONUtils) manager.lookup(JSONUtils.ROLE);
        _userManager = (UserManager) manager.lookup(UserManager.ROLE);
    }

    public void initialize() throws Exception
    {
        _datasourceId = Config.getInstance() != null ? Config.getInstance().getValue("runtime.assignments.authenticationtokens") : "";
    }

    private CurrentUserProvider _getCurrentUserProvider() throws RuntimeException
    {
        if (_currentUserProvider == null)
        {
            try
            {
                _currentUserProvider = (CurrentUserProvider) _manager.lookup(CurrentUserProvider.ROLE);
            }
            catch (ServiceException e)
            {
                throw new RuntimeException(e);
            }
        }
        return _currentUserProvider;
    }

    /**
     * Get the existing tokens for the connected user
     * 
     * @param type The type of tokens to return. null to return all.
     * @return The tokens
     * @throws RuntimeException If there is no user connected or if there is a
     *             database error
     */
    public List<Token> getTokens(String type) throws RuntimeException
    {
        return getTokens(_getCurrentUserProvider().getUser(), type);
    }

    /**
     * Get the existing tokens for this user
     * 
     * @param type The type of tokens to return. null to return all.
     * @param user The user. Cannot be null
     * @return The tokens identifier and associated comment
     * @throws RuntimeException If the user is null or if there is a database
     *             error
     */
    public List<Token> getTokens(UserIdentity user, String type) throws RuntimeException
    {
        if (user == null)
        {
            throw new RuntimeException("Cannot generate a temporary authentication token for a null user");
        }

        List<Token> tokens = new ArrayList<>();

        Connection connection = null;
        try
        {
            connection = ConnectionHelper.getConnection(_datasourceId);

            // Delete old entries
            _deleteOldTokens(connection);

            try (PreparedStatement selectStatement = _getSelectUserTokenStatement(connection, user.getLogin(), user.getPopulationId(), type);
                    ResultSet resultSet = selectStatement.executeQuery())
            {
                // Find the database entry using this token
                while (resultSet.next())
                {
                    Token token = _getTokenFromResultSet(resultSet, connection);
                    tokens.add(token);
                }
            }
        }
        catch (Exception e)
        {
            getLogger().error("Communication error with the database", e);
        }
        finally
        {
            ConnectionHelper.cleanup(connection);
        }

        return tokens;
    }
    
    /**
     * Generates a new token for the current user
     * 
     * @param duration The time the token is valid in seconds. 0 means for ever
     *            and moreover the ticket will be reusable.
     * @param type The type of token. Mandatory but can be anything you want
     *            between 1 to 32 characters. Such as "Cookie".
     * @param comment An optional token comment to remember the reason of its
     *            creation
     * @return The token
     * @throws RuntimeException If the user is not authenticated, or if there is
     *             a database error
     */
    public String generateToken(long duration, String type, String comment) throws RuntimeException
    {
        return generateToken(_getCurrentUserProvider().getUser(), duration, type, comment);
    }

    /**
     * Generates a new token
     * 
     * @param user The user that will be authenticated with the token
     * @param duration The time the token is valid in seconds. 0 means for ever
     *            and moreover the ticket will be reusable
     * @param type The type of token. Mandatory but can be anything you want
     *            between 1 to 32 characters. Such as "Cookie".
     * @param comment An optional token comment to remember the reason of its
     *            creation
     * @return The token
     * @throws RuntimeException If the user is null or if there is a database
     *             error or if duration is negative
     */
    public String generateToken(UserIdentity user, long duration, String type, String comment) throws RuntimeException
    {
        return generateToken(user, duration, false, null, null, type, comment);
    }
    /**
     * Generates a new token
     * 
     * @param user The user that will be authenticated with the token
     * @param duration The time the token is valid in seconds. 0 means for ever
     *            and moreover the ticket will be reusable
     * @param nbUsesLeft number of available uses (null for no limit)
     * @param type The type of token. Mandatory but can be anything you want
     *            between 1 to 32 characters. Such as "Cookie".
     * @param comment An optional token comment to remember the reason of its
     *            creation
     * @return The token
     * @throws RuntimeException If the user is null or if there is a database
     *             error or if duration is negative
     */
    public String generateToken(UserIdentity user, long duration, Integer nbUsesLeft, String type, String comment) throws RuntimeException
    {
        return generateToken(user, duration, false, nbUsesLeft, null, type, comment);
    }
    
    /**
     * Generates a new token
     * 
     * @param user The user that will be authenticated with the token
     * @param duration The time the token is valid in seconds. 0 means for ever
     *            and moreover the ticket will be reusable
     * @param autoRenewDuration true to automatically renew token if used before it's expiration
     * @param nbUsesLeft number of available uses (null for no limit)
     * @param contexts contexts where the token can be used
     * @param type The type of token. Mandatory but can be anything you want
     *            between 1 to 32 characters. Such as "Cookie".
     * @param comment An optional token comment to remember the reason of its
     *            creation
     * @return The token
     * @throws RuntimeException If the user is null or if there is a database
     *             error or if duration is negative
     */
    public String generateToken(UserIdentity user, long duration, boolean autoRenewDuration, Integer nbUsesLeft, Set<String> contexts, String type, String comment) throws RuntimeException
    {
        if (user == null)
        {
            throw new RuntimeException("Cannot generate a temporary authentication token for a null user");
        }
        else if (duration < 0)
        {
            throw new RuntimeException("Cannot generate a token for a negative duration [" + duration + "]");
        }

        String token = RandomStringUtils.randomAlphanumeric(duration == 0 ? 64 : 16);
        String salt = RandomStringUtils.randomAlphanumeric(48);
        Timestamp creationDateTime = new Timestamp(new Date().getTime());
        Timestamp endTime = duration > 0 ? new Timestamp(System.currentTimeMillis() + duration * 1000) : null;
        String hashedTokenAndSalt = DigestUtils.sha512Hex(token + salt);

        
        _generateToken(user, duration, autoRenewDuration, nbUsesLeft, contexts, type, comment, hashedTokenAndSalt, salt, creationDateTime, endTime);

        String fullToken = user.getPopulationId() + TOKEN_SEPARATOR + user.getLogin() + TOKEN_SEPARATOR + token;
        
        try
        {
            return Base64.getEncoder().withoutPadding().encodeToString(fullToken.getBytes("UTF-8"));
        }
        catch (UnsupportedEncodingException e)
        {
            // can't occur ...
            throw new RuntimeException(e);
        }
    }
    
    private void _generateToken(UserIdentity user, long duration, boolean autoRenewDuration, Integer nbUsesLeft, Set<String> contexts, String type, String comment, String hashedTokenAndSalt, String salt, Timestamp creationDateTime, Timestamp endTime) throws RuntimeException
    {
        ResultSet rs = null;
        Connection connection = null;
        PreparedStatement statement = null;
        try
        {
            connection = ConnectionHelper.getConnection(_datasourceId);
            String dbType = ConnectionHelper.getDatabaseType(connection);
            if (ConnectionHelper.DATABASE_ORACLE.equals(dbType))
            {
                statement = connection.prepareStatement("SELECT seq_authenticationtoken.nextval FROM dual");
                rs = statement.executeQuery();
    
                String id = null;
                if (rs.next())
                {
                    id = rs.getString(1);
                }
                ConnectionHelper.cleanup(rs);
                ConnectionHelper.cleanup(statement);
                statement = connection.prepareStatement(
                        "INSERT INTO Authentication_Token (id, " + TOKEN_SQL_SET_FIELDS + ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
                int nextParam = 1;
                statement.setString(nextParam++, id);
                statement.setString(nextParam++, user.getLogin());
                statement.setString(nextParam++, user.getPopulationId());
                statement.setString(nextParam++, hashedTokenAndSalt);
                statement.setString(nextParam++, salt);
                statement.setTimestamp(nextParam++, creationDateTime);
                statement.setTimestamp(nextParam++, endTime);
                if (nbUsesLeft == null)
                {
                    statement.setNull(nextParam++, java.sql.Types.INTEGER);
                }
                else
                {
                    statement.setInt(nextParam++, nbUsesLeft);
                }
    
                if (!autoRenewDuration)
                {
                    statement.setNull(nextParam++, java.sql.Types.BIGINT);
                }
                else
                {
                    statement.setLong(nextParam++, duration);
                }
                
                if (contexts == null)
                {
                    statement.setNull(nextParam++, java.sql.Types.VARCHAR);
                }
                else
                {
                    String contextString = _contextsToString(contexts);
                    statement.setString(nextParam++, contextString);
                }
                statement.setString(nextParam++, type);
                if (comment == null)
                {
                    statement.setNull(nextParam++, Types.BLOB);
                }
                else
                {
                    _sqlDatabaseTypeExtensionPoint.setBlob(dbType, statement, nextParam++, comment);
                }
            }
            else
            {
                statement = connection.prepareStatement(
                        "INSERT INTO Authentication_Token (" + TOKEN_SQL_SET_FIELDS + ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
                int nextParam = 1;
                statement.setString(nextParam++, user.getLogin());
                statement.setString(nextParam++, user.getPopulationId());
                statement.setString(nextParam++, hashedTokenAndSalt);
                statement.setString(nextParam++, salt);
                statement.setTimestamp(nextParam++, creationDateTime);
                statement.setTimestamp(nextParam++, endTime);
                
                if (nbUsesLeft == null)
                {
                    statement.setNull(nextParam++, java.sql.Types.INTEGER);
                }
                else
                {
                    statement.setInt(nextParam++, nbUsesLeft);
                }
    
                if (!autoRenewDuration)
                {
                    statement.setNull(nextParam++, java.sql.Types.BIGINT);
                }
                else
                {
                    statement.setLong(nextParam++, duration);
                }
                
                if (contexts == null)
                {
                    statement.setNull(nextParam++, java.sql.Types.VARCHAR);
                }
                else
                {
                    String contextString = _contextsToString(contexts);
                    statement.setString(nextParam++, contextString);
                }
                
                statement.setString(nextParam++, type);
                _sqlDatabaseTypeExtensionPoint.setBlob(dbType, statement, nextParam++, comment);
            }
            
            statement.executeUpdate();
        }
        catch (SQLException | UnsupportedEncodingException e)
        {
            throw new RuntimeException(e);
        }
        finally
        {
            ConnectionHelper.cleanup(rs);
            ConnectionHelper.cleanup(connection);
        }
    }
    
    private String _contextsToString(Set<String> contexts)
    {
        return _jsonUtils.convertObjectToJson(contexts);
    }
    
    private Set<String> _convertStringToContexts(String contexts)
    {
        if (contexts == null)
        {
            return Collections.EMPTY_SET;
        }
        try
        {
            List<Object> jsonList = _jsonUtils.convertJsonToList(contexts);
            Set<String> result = jsonList.stream()
                .filter(String.class::isInstance)
                .map(String.class::cast)
                .collect(Collectors.toSet());
            
            return result;
        }
        catch (IllegalArgumentException e)
        {
            // The input is not a json array, so it is just a string
            return Collections.singleton(contexts);
        }
    }

    private UserIdentity _validateToken(String encodedToken, String context, boolean forceRemove)
    {
        String token;
        try
        {
            token = new String(Base64.getDecoder().decode(encodedToken), "UTF-8");
        }
        catch (UnsupportedEncodingException e)
        {
            // can't occur ...
            throw new RuntimeException(e);
        }
        catch (Exception e)
        {
            // Exception occured during token decoding
            return null;
        }
        
        String[] split = StringUtils.split(token, TOKEN_SEPARATOR);
        if (split == null || split.length != 3)
        {
            return null;
        }

        String populationId = split[0];
        String login = split[1];
        String tokenPart = split[2];

        Connection connection = null;
        try
        {
            connection = ConnectionHelper.getConnection(_datasourceId);

            // Delete old entries
            _deleteOldTokens(connection);

            try (
                    PreparedStatement selectStatement = _getSelectUserTokenStatement(connection, login, populationId, null);
                    ResultSet resultSet = selectStatement.executeQuery()
                )
            {
                // Find the database entry using this token
                while (resultSet.next())
                {
                    if (resultSet.getString("token").equals(DigestUtils.sha512Hex(tokenPart + resultSet.getString("salt"))))
                    {
                        Token tokenToUpdate = _getTokenFromResultSet(resultSet, connection);
                        // If the token doesn't have a context, this one is always valid
                        // Else, the token context must be equal to the token context the context method parameter
                        if (tokenToUpdate.getContexts() != null && tokenToUpdate.getContexts().size() > 0 && !tokenToUpdate.getContexts().contains(context))
                        {
                            continue;
                        }
                        
                        // Delete it
                        if (forceRemove)
                        {
                            _deleteUserToken(connection, tokenToUpdate.getId());
                        }
                        else
                        {
                            _updateUserToken(connection, tokenToUpdate);
                        }
                        
                        // Control that the user exists
                        UserIdentity identity = new UserIdentity(login, populationId);
                        if (_userManager.getUser(identity) != null)
                        {
                            return identity;
                        }
                    }
                }
            }
        }
        catch (Exception e)
        {
            getLogger().error("Communication error with the database", e);
        }
        finally
        {
            ConnectionHelper.cleanup(connection);
        }

        return null;
    }

    /**
     * Check if a token is valid and return the user
     * 
     * @param token The token to validate
     * @return The user associated to the valid token, null otherwise
     */
    public UserIdentity validateToken(String token)
    {
        return validateToken(token, null);
    }
    
    /**
     * Check if a token is valid and return the user
     * @param token The token to validate
     * @param context context to validate the token with
     * @return The user associated to the valid token, null otherwise
     */
    public UserIdentity validateToken(String token, String context)
    {
        return _validateToken(token, context, false);
    }

    /**
     * Destroy the given token
     * 
     * @param token The token to remove
     * @param context context of the token (null for no context)
     */
    public void deleteTokenByValue(String token, String context)
    {
        _validateToken(token, context, true);
    }

    /**
     * Destroy the given token
     * 
     * @param tokenId The token identifier to remove
     */
    public void deleteTokenById(Integer tokenId)
    {
        Connection connection = null;
        try
        {
            connection = ConnectionHelper.getConnection(_datasourceId);

            _deleteUserToken(connection, tokenId);
        }
        catch (SQLException e)
        {
            throw new RuntimeException("Could not delete the authentication token with identifier " + tokenId, e);
        }
        finally
        {
            ConnectionHelper.cleanup(connection);
        }
    }

    /**
     * Generates the sql statement that deletes the entries of the users token
     * database that are old
     * 
     * @param connection the database's session
     * @throws SQLException if a sql exception occurs
     */
    private void _deleteOldTokens(Connection connection) throws SQLException
    {
        try (PreparedStatement statement = connection.prepareStatement("DELETE FROM Authentication_Token WHERE end_date < ? OR nb_uses_left = ?"))
        {
            statement.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
            statement.setInt(2, 0);
            statement.executeUpdate();
        }
    }

    /**
     * Generates the statement that selects the users having the specified login
     * in the Authentication_Token table
     * 
     * @param connection the database's session
     * @param login The login of the user
     * @param populationId The populationId of the user
     * @param type The type to filter or null to get all
     * @return the retrieve statement
     * @throws SQLException if a sql exception occurs
     */
    private PreparedStatement _getSelectUserTokenStatement(Connection connection, String login, String populationId, String type) throws SQLException
    {
        String sqlRequest = "SELECT " + TOKEN_SQL_GET_FIELDS + " FROM Authentication_Token WHERE login=? AND population_id=?"
                + (type != null ? " AND type=?" : "");

        PreparedStatement statement = connection.prepareStatement(sqlRequest);
        int nextParam = 1;
        statement.setString(nextParam++, login);
        statement.setString(nextParam++, populationId);
        if (type != null)
        {
            statement.setString(nextParam++, type);
        }

        return statement;
    }
    private Token _getTokenFromResultSet(ResultSet resultSet, Connection connection) throws SQLException, IOException
    {
        String dbType = ConnectionHelper.getDatabaseType(connection);
        String comment = null;
        try (InputStream blob = _sqlDatabaseTypeExtensionPoint.getBlob(dbType, resultSet, "token_comment"))
        {
            if (blob != null)
            {
                comment = IOUtils.toString(blob, "UTF-8");
            }
        }
        
        Integer nbUsesLeft = resultSet.getInt("nb_uses_left");
        if (resultSet.wasNull())
        {
            nbUsesLeft = null;
        }
        
        Long autoRenewDuration = resultSet.getLong("auto_renew_duration");
        if (resultSet.wasNull())
        {
            autoRenewDuration = null;
        }
        String contextString = resultSet.getString("context");
        Set<String> contexts = _convertStringToContexts(contextString);
        Token token = new Token(resultSet.getInt("id"), resultSet.getString("type"), comment, resultSet.getTimestamp("creation_date"),
                resultSet.getTimestamp("end_date"), resultSet.getTimestamp("last_update_date"), nbUsesLeft, autoRenewDuration, contexts);
        return token;
    }

    /**
     * Deletes the database entry that has this token
     * 
     * @param connection the database's session
     * @param id the token id
     * @throws SQLException if an error occurred
     */
    private void _deleteUserToken(Connection connection, Integer id) throws SQLException
    {
        try (PreparedStatement statement = connection.prepareStatement("DELETE FROM Authentication_Token WHERE id = ?"))
        {
            statement.setInt(1, id);
            statement.executeUpdate();
        }
    }

    /**
     * Update the last update date in the database
     * 
     * @param connection the database's session
     * @param token the token
     * @throws SQLException if an error occurred
     */
    private void _updateUserToken(Connection connection, Token token) throws SQLException
    {
        Integer nbUsesLeft = token.getNbUsesLeft();
        if (nbUsesLeft != null && nbUsesLeft > 0)
        {
            nbUsesLeft--;
        }

        // Delete if no uses left
        if (nbUsesLeft != null && nbUsesLeft == 0)
        {
            _deleteUserToken(connection, token.getId());
        }
        // Update last update_date and nb_use_left if needed
        // And update end_date if the token have auto renew
        else if (token.getAutoRenewDuration() != null)
        {
            Long autoRenewDuration = token.getAutoRenewDuration();
            Timestamp endDate = new Timestamp(new Date().getTime() + autoRenewDuration * 1000);

            try (PreparedStatement statement = connection.prepareStatement("UPDATE Authentication_Token SET last_update_date = ?, end_date = ?, nb_uses_left = ? WHERE id = ?"))
            {
                Timestamp lastUpdateDate = new Timestamp(new Date().getTime());
                statement.setTimestamp(1, lastUpdateDate);
                statement.setTimestamp(2, endDate);
                if (nbUsesLeft == null)
                {
                    statement.setNull(3, java.sql.Types.INTEGER);
                }
                else
                {
                    statement.setInt(3, nbUsesLeft);
                }
                statement.setInt(4, token.getId());
                statement.executeUpdate();
            }
        }
        else
        {
            try (PreparedStatement statement = connection.prepareStatement("UPDATE Authentication_Token SET last_update_date = ?, nb_uses_left = ? WHERE id = ?"))
            {
                Timestamp lastUpdateDate = new Timestamp(new Date().getTime());
                statement.setTimestamp(1, lastUpdateDate);
                if (nbUsesLeft == null)
                {
                    statement.setNull(2, java.sql.Types.INTEGER);
                }
                else
                {
                    statement.setInt(2, nbUsesLeft);
                }
                statement.setInt(3, token.getId());
                statement.executeUpdate();
            }
        }
    }

    /**
     * Generate a new authentication token
     * 
     * @param parameters a map of the following parameters for the
     *            authentication token : description
     * @return The generated token
     */
    @Callable
    public String generateAuthenticationToken(Map<String, Object> parameters)
    {
        String description = (String) parameters.get("description");
        String generateToken = generateToken(0, USER_TOKEN_TYPE, description);

        return generateToken;
    }

    /**
     * Delete one or multiples authentication token
     * 
     * @param ids a list of authentication token ids
     */
    @Callable
    public void deleteAuthenticationToken(List<Integer> ids)
    {
        for (Integer tokenId : ids)
        {
            deleteTokenById(tokenId);
        }
    }

    /**
     * An Ametys authentication token
     */
    public static class Token
    {
        /** The token identifier */
        protected Integer _id;

        /** The token type */
        protected String _type;

        /** The token associated comment */
        protected String _comment;

        /** The token creation date */
        protected Date _creationDate;

        /** The token end date */
        protected Date _endDate;

        /** The token last update date */
        protected Date _lastUpdateDate;
        
        /** The token number of use left */
        protected Integer _nbUsesLeft;
        
        /** The token auto renewal duration, in seconds */
        protected Long _autoRenewDuration;
        
        /** The token context */
        protected Set<String> _contexts;

        /**
         * Creates a Token
         * 
         * @param id The identifier
         * @param type The type of token
         * @param comment The comment. Can be null.
         * @param creationDate The creation date. Can be null.
         * @param endDate The end date. Can be null.
         * @param lastUpdateDate The last update date. Can be null.
         * @param nbUsesLeft nb of uses left for this token (null for no limitation)
         * @param autoRenewDuration duration that will be added (from "now") each time the token is updated
         * @param contexts contexts of the token (ressource id for example)
         */
        protected Token(Integer id, String type, String comment, Date creationDate, Date endDate, Date lastUpdateDate, Integer nbUsesLeft, Long autoRenewDuration, Set<String> contexts)
        {
            _id = id;
            _type = type;
            _comment = comment;
            _creationDate = creationDate;
            _endDate = endDate;
            _lastUpdateDate = lastUpdateDate;
            _nbUsesLeft = nbUsesLeft;
            _autoRenewDuration = autoRenewDuration;
            _contexts = contexts;
        }

        /**
         * Get the token identifier
         * 
         * @return The identifier
         */
        public Integer getId()
        {
            return _id;
        }

        /**
         * Get the token type
         * 
         * @return The type
         */
        public String getType()
        {
            return _type;
        }

        /**
         * Get the associated creation comment
         * 
         * @return The comment or null
         */
        public String getComment()
        {
            return _comment;
        }

        /**
         * Get the creation date of the token
         * 
         * @return The creation date or null
         */
        public Date getCreationDate()
        {
            return _creationDate;
        }

        /**
         * Get the end date of the token validity
         * 
         * @return The end date or null
         */
        public Date getEndDate()
        {
            return _endDate;
        }

        /**
         * Get the last update date of the token
         * 
         * @return The last update date or null
         */
        public Date getLastUpdateDate()
        {
            return _endDate;
        }

        /**
         * Get the duration which the token should be automatically renewed on each use, in seconds
         * 
         * @return The auto renewal duration in seconds or null if not applicable
         */
        public Long getAutoRenewDuration()
        {
            return _autoRenewDuration;
        }

        /**
         * Get the context on which the token can be used
         * 
         * @return The token contexts or null if not applicable
         */
        public Set<String> getContexts()
        {
            return _contexts;
        }

        /**
         * Get the number of uses allowed for this token
         * 
         * @return The number of allowed uses or null if not applicable
         */
        public Integer getNbUsesLeft()
        {
            return _nbUsesLeft;
        }
        
        
    }
}