/**
    * Copyright 2005-2008 the original author or authors.
    *
    * Licensed under the Gnu General Pubic 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.opensource.org/licenses/gpl-license.php
    *
   * This program 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.
   */
  package org.figure8.join.businessobjects.security.persistence;
  
  import org.figure8.join.core.EntityObject;
  import org.figure8.join.core.InfrastructureException;
  import org.figure8.join.businessobjects.security.User;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  import org.springframework.jdbc.core.RowMapper;
  import org.springframework.jdbc.core.JdbcTemplate;
  
  import javax.sql.DataSource;
  
  import java.util.List;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  /**
   * This is an implementation of {@link UserDao} using row Jdbc.
   * @author <a href="mailto:jerome.evrard@gmail.com">Jerome Evrard</a>
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.2 $
   */
  public class JdbcUserDao implements UserDao{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger */
     private static final Log log = LogUtil.getLog(JdbcUserDao.class);
  
  
     // Attributes ---------------------------------------------------------------
  
     /** Cache the select clause with provided columns */
     private String selectClause = null;
  
     /** Spring Jdbc template helper */
     private JdbcTemplate jt;
     /** Jdbc datasource allowing access to userTable */
     private DataSource dataSource;
  
     /** Column representing unique identifier */
     private String idColumn = "n_id";
     /** Column representing user login */
     private String loginColumn = "s_login";
     /** Column representing user password */
     private String passwordColumn = "s_password";
     /** Column representing user lastname */
     private String lastnameColumn = "s_lastname";
     /** Column representing user firstname */
     private String firstnameColumn = "s_firstname";
     /** Column representing user mail address */
     private String mailColumn = "s_mail";
     /** Column representing user phone number */
     private String phoneColumn = "s_phone";
     /** Column representing user team description */
     private String teamColumn = "s_team";
  
     /** Table containing user definitions */
     private String userTable = "join_users";
  
  
     // Constructors -------------------------------------------------------------
  
     /** Creates a new instance of JdbcUserDao */
     public JdbcUserDao(){
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** @return Column representing unique identifier */
     public String getIdColumn(){
        return idColumn;
     }
     /** @param idColumn Column representing unique identifier */
     public void setIdColumn(String idColumn){
        this.idColumn = idColumn;
     }
     /** @return Column representing user login */
     public String getLoginColumn(){
        return loginColumn;
     }
     /** @param loginColumn Column representing user login */
     public void setLoginColumn(String loginColumn){
        this.loginColumn = loginColumn;
    }
    /** @return Column representing user password */
    public String getPasswordColumn(){
       return passwordColumn;
    }
    /** @param passwordColumn Column representing user password */
    public void setPasswordColumn(String passwordColumn){
       this.passwordColumn = passwordColumn;
    }
    /** @return Column representing user lastname */
    public String getLastnameColumn(){
       return lastnameColumn;
    }
    /** @param lastnameColumn Column representing user lastname */
    public void setLastnameColumn(String lastnameColumn){
       this.lastnameColumn = lastnameColumn;
    }
    /** @return Column representing user firstname */
    public String getFirstnameColumn(){
       return firstnameColumn;
    }
    /** @param firstnameColumn Column representing user firstname */
    public void setFirstnameColumn(String firstnameColumn){
       this.firstnameColumn = firstnameColumn;
    }
    /** @return Column representing user mail address */
    public String getMailColumn(){
       return mailColumn;
    }
    /** @param mailColumn Column representing user mail address */
    public void setMailColumn(String mailColumn){
       this.mailColumn = mailColumn;
    }
    /** @return Column representing user phone number */
    public String getPhoneColumn(){
       return phoneColumn;
    }
    /** @param phoneColumn Column representing user phone number */
    public void setPhoneColumn(String phoneColumn){
       this.phoneColumn = phoneColumn;
    }
    /** @return Column representing user team description */
    public String getTeamColumn(){
       return teamColumn;
    }
    /** @param teamColumn Column representing user team description */
    public void setTeamColumn(String teamColumn){
       this.teamColumn = teamColumn;
    }
 
    /** @return Table containing user definitions */
    public String getUserTable(){
       return userTable;
    }
    /** @param userTable Table containing user definitions */
    public void setUserTable(String userTable){
       this.userTable = userTable;
    }
 
    /** @param dataSource The Datasource allowing access to userTable */
    public void setDataSource(DataSource dataSource){
       this.dataSource = dataSource;
    }
 
 
    // Implementation of UserDao ------------------------------------------------
 
    /**
     * @param login User login (should be a unique identifier)
     * @return The user object corresponding to <b>login</b>
     */
    public User getUser(String login){
       User user = findUser(login);
       if (user == null)
          log.warn("User with login '" + login + "' is not defined or defined multiple times !");
       return user;
    }
 
    /**
     * Retrieve all users having lastname 'like' the specified one
     * @param lastname The string that users lastname should contain
     * @return A List of {@code org.figure8.join.businessobjects.security.User}
     */
    public List getUsersWithLastnameLike(String lastname){
       List users = findUsers(lastnameColumn, lastname, lastnameColumn);
       if (log.isDebugEnabled())
          log.debug("Users having lastname like '" + lastname + "' are: " + users.size());
       return users;
    }
 
 
    // Implementation of ObjectDao ----------------------------------------------
 
    /**
     * Save the given entity into underlying datastore.
     * @param entityobject EntityObject to save
     */
    public void save(EntityObject entityobject){
       // Check that we have a user and cast it.
       if (!(entityobject instanceof User))
          throw new IllegalArgumentException("JdbcUserDao only support User not " + entityobject.getClass());
       User user = (User)entityobject;
       // Create a template and dissociate create/update.
       jt = new JdbcTemplate(dataSource);
       if (user.isTransient()){
          // TODO : Find a better method to determine next identifier for user.
          long maxId = jt.queryForLong("select max(" + idColumn + " from " + userTable);
          // Execute an insertion into datastore.
          StringBuffer query = new StringBuffer("insert into ").append(userTable).append(" (");
          query.append(idColumn).append(", ").append(loginColumn).append(", ").append(passwordColumn).append(", ");
          query.append(lastnameColumn).append(", ").append(firstnameColumn);
          // Append optional columns if provided.
          if (mailColumn != null || !"null".equals(mailColumn))
             query.append(", ").append(mailColumn);
          if (phoneColumn != null || !"null".equals(phoneColumn))
             query.append(", ").append(phoneColumn);
          if (teamColumn != null || !"null".equals(teamColumn))
             query.append(", ").append(teamColumn);
          // Append values (mandatory and optionals).
          query.append(") values (").append(maxId + 1).append(", ");
          query.append("'").append(user.getLogin()).append("', '").append(user.getPassword()).append("', ");
          query.append("'").append(user.getLastname()).append("', '").append(user.getFirstname()).append("'");
          if (mailColumn != null || !"null".equals(mailColumn))
             query.append(", '").append(user.getMail()).append("'");
          if (phoneColumn != null || !"null".equals(phoneColumn))
             query.append(", '").append(user.getPhone()).append("'");
          if (teamColumn != null || !"null".equals(teamColumn))
             query.append(", ").append(user.getTeam()).append("'");
          query.append(")");
          // Log and execute query.
          if (log.isDebugEnabled())
             log.debug("Inserting a new User with: " + query.toString());
          jt.execute(query.toString());
       }
       else{
          // Realize an update of row into datastore.
          StringBuffer query = new StringBuffer("update ").append(userTable);
          query.append(" set ").append(loginColumn).append("='").append(user.getLogin()).append("', ");
          query.append(passwordColumn).append("='").append(user.getPassword()).append("', ");
          query.append(lastnameColumn).append("='").append(user.getLastname()).append("', ");
          query.append(firstnameColumn).append("='").append(user.getFirstname()).append("'");
          // Append optional columns if provided.
          if (mailColumn != null || !"null".equals(mailColumn))
             query.append(", ").append(mailColumn).append("='").append(user.getMail()).append("'");
          if (phoneColumn != null || !"null".equals(phoneColumn))
             query.append(", ").append(phoneColumn).append("='").append(user.getPhone()).append("'");
          if (teamColumn != null || !"null".equals(teamColumn))
             query.append(", ").append(teamColumn).append("='").append(user.getTeam()).append("'");
          // Append where clause.
          query.append(" where ").append(idColumn).append("=").append(user.getId());
          // Log and execute query.
          if (log.isDebugEnabled())
             log.debug("Updating existing User with: " + query.toString());
          int rows = jt.update(query.toString());
       }
    }
 
    /**
     * Remove the given entity object from underlying datastore.
     * @param entityobject EntityObject to remove
     */
    public void remove(EntityObject entityobject){
       throw new InfrastructureException("JdbcUserDao does not implement remove() method");
    }
 
    /**
     * Re-read the content of the given entity from underlying datastore.
     * @param entityobject EntityObject to refresh content
     */
    public void refresh(EntityObject entityobject){
       // Check that we have a user and cast it.
       if (!(entityobject instanceof User))
          throw new IllegalArgumentException("JdbcUserDao only support User not " + entityobject.getClass());
       User user = (User)entityobject;
       // Refreshing fomr database.
       user = findUser(user.getId());
    }
 
    /**
     * Force initialization of the given entity from underlying datastore
     * (this may involves initialization of lazily loaded relations fields)
     * @param entityobject EntityObject to initialize
     */
    public void initialize(EntityObject entityobject){
       // User do not have lazy loaded fields so just refresh its state.
       refresh(entityobject);
    }
 
    /**
     * Force initialization of the given entity association from underlying datastore
     * @param entityobject EntityObject whose association shoud be initialized
     * @param proxy A proxy object representing entoty association (this may be a collection)
     */
    public void initializeAssociation(EntityObject entityobject, Object proxy){
       // User do not have lazy loaded fields so just refresh its state.
       refresh(entityobject);
    }
 
    /**
     * Check if an object (EntityObject or association proxy) is initialized from datastore
     * @param object The object to check initialization for
     * @return true if object has been loaded from datastore, false otherwise
     */
    public boolean isInitialized(Object object){
       return (object instanceof User);
    }
 
    /**
     * Persist the object state throughout the cluster.
     * @param obj The object to replicate
     */
    public void replicate(Object obj){
       // Check that we have a user and cast it.
       if (!(obj instanceof User))
          throw new IllegalArgumentException("JdbcUserDao only support User not " + obj.getClass());
       // No second level cache is used so just save the object.
       save((User)obj);
    }
 
    /**
     * Find all entity objects associated with this Dao.
     * @return A List of EntityObjects
     */
    public List findAll(){
       return findUsers(null, null, null);
    }
 
    /**
     * Find all entity objects asscoiated with this Dao.
     * The result list is sorted by <b>sortField</b> criteria.
     * @param sortField Field for sorting criteria
     * @return A List of EntityObjects
     */
    public List findAllSorted(String sortField){
       if ("login".equals(sortField))
          return findUsers(null, null, loginColumn);
       if ("lastname".equals(sortField))
          return findUsers(null, null, lastnameColumn);
       if ("firstname".equals(sortField))
          return findUsers(null, null, firstnameColumn);
       // Default is to find all.
       return findAll();
    }
 
    /**
     * Get the persistent class associated to this Dao.
     * @return The class of the persistent object
     */
    public Class getPersistentClass(){
       return org.figure8.join.businessobjects.security.User.class;
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * Find a unique User using its identifier
     * @param id The identifier of User to retrieve
     * @return The corresponding User or null.
     */
    protected User findUser(long id){
       StringBuffer query = new StringBuffer(getSelectClause());
       // Append where clause.
       query.append(" where ").append(idColumn).append("=").append(id);
       // Execute and map result.
       jt = new JdbcTemplate(dataSource);
       List users = jt.query(query.toString(), getUserRowMapper());
       // Check that there's only one user.
       if (users.size() > 1){
          log.error("Expected only one User but found many when looking for id: " + id);
          throw new InfrastructureException("Expected only one User but found many when looking for id: " + id);
       }
       if (!users.isEmpty())
          return (User)users.get(0);
       return null;
    }
 
    /**
     * Find a unique User using its login
     * @param login The login of User to retrieve
     * @return The corresponding User object or null.
     */
    protected User findUser(String login){
       StringBuffer query = new StringBuffer(getSelectClause());
       // Append where clause.
       query.append(" where ").append(loginColumn).append("='").append(login).append("'");
       // Execute and map result.
       jt = new JdbcTemplate(dataSource);
       List users = jt.query(query.toString(), getUserRowMapper());
       // Check that there's only one user.
       if (users.size() > 1){
          log.error("Expected only one User but found many when looking for login: " + login);
          throw new InfrastructureException("Expected only one User but found many when looking for login: " + login);
       }
       if (!users.isEmpty())
          return (User)users.get(0);
       return null;
    }
 
    /**
     * Find many users using a criterion column and its value.
     * @param criterionColumn The column that appears in where clause
     * @param value The value of select criterion
     * @param sortColumn The column to use for sorting results
     * @return A list of User objects
     */
    protected List findUsers(String criterionColumn, String value, String sortColumn){
       StringBuffer query = new StringBuffer(getSelectClause());
       // Append where clause if needed.
       if (criterionColumn != null)
          query.append(" where ").append(criterionColumn).append(" like '%").append(value).append("%'");
       // Append sort clause if needed.
       if (sortColumn != null)
          query.append(" order by ").append(sortColumn).append(" asc");
       // Execute and map results.
       jt = new JdbcTemplate(dataSource);
       return jt.query(query.toString(), getUserRowMapper());
    }
 
    /**
     * Retrieve the where clause depending on specified columns and table name
     * @return The where clause of SQL query from 'select' to 'from table '
     */
    protected String getSelectClause(){
       if (selectClause == null){
          StringBuffer buffer = new StringBuffer("select ").append(idColumn).append(", ");
          buffer.append(loginColumn).append(", ").append(passwordColumn).append(", ");
          buffer.append(lastnameColumn).append(", ").append(firstnameColumn);
          // Append optional columns if provided.
          if (mailColumn != null || !"null".equals(mailColumn))
             buffer.append(", ").append(mailColumn);
          if (phoneColumn != null || !"null".equals(phoneColumn))
             buffer.append(", ").append(phoneColumn);
          if (teamColumn != null || !"null".equals(teamColumn))
             buffer.append(", ").append(teamColumn);
          // Append table name.
          buffer.append(" from ").append(userTable);
          selectClause = buffer.toString();
       }
       return selectClause;
    }
 
    /**
     * Retrieve a Spring row mappper for User object
     * @return A RowMapper implementation for User object
     */
    protected RowMapper getUserRowMapper(){
       return new RowMapper(){
          /**
           * Map each row of data in the ResultSet. This method should not call
           * next() on the ResultSet, but extract the current values.
           * @param rs the ResultSet to map
           * @param rowNum The number of the current row
           * @throws SQLException if a SQLException is encountered getting
           * column values (that is, there's no need to catch SQLException)
           */
          public Object mapRow(ResultSet rs, int rowNum) throws SQLException{
             User user = new User();
             user.setId(rs.getLong(idColumn));
             user.setLogin(rs.getString(loginColumn));
             user.setPassword(rs.getString(passwordColumn));
             user.setLastname(rs.getString(lastnameColumn));
             user.setFirstname(rs.getString(firstnameColumn));
             // Map optional columns if provided.
             if (mailColumn != null || !"null".equals(mailColumn))
                user.setMail(rs.getString(mailColumn));
             if (phoneColumn != null || !"null".equals(phoneColumn))
                user.setPhone(rs.getString(phoneColumn));
             if (teamColumn != null || !"null".equals(teamColumn))
                user.setTeam(rs.getString(teamColumn));
             return user;
          }
       };
    }
 }