package org.naftulin.configmgr.parsers;

 import java.net.URL;

 import java.sql.Connection;

 import java.sql.PreparedStatement;

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Properties;

 import javax.naming.InitialContext;

 import javax.naming.NamingException;

 import javax.sql.DataSource;

 import org.apache.log4j.Logger;

 import org.naftulin.configmgr.ConfigurationManagementEntry;

 import org.naftulin.configmgr.ConfigurationManagementEntryImpl;

 import org.naftulin.configmgr.ConfigurationManagerException;

 import org.naftulin.configmgr.ConfigurationType;

 import org.naftulin.configmgr.content.NameValuePairImpl;

 /*

  * 

  */

 public class DbJndiParserImpl extends AbstractJndiParser implements ConfigEntryParser {

         private static final Logger log = Logger.getLogger(DbJndiParserImpl.class);

         private static final long serialVersionUID = 1L;

         private final String sql;

         private final String keyColumnName;

         private final String valueColumnName;

         public DbJndiParserImpl(final String jndiName, final String initialContextFactory, final String sql, 

                         final String keyColumnName, final String valueColumnName, final List<NameValuePairImpl> nameValuePairs) {

                 super(jndiName, initialContextFactory, nameValuePairs);

                 this.sql = sql;

                 this.keyColumnName = keyColumnName;

                 this.valueColumnName = valueColumnName;

         }

         /**

          * Returns configuratoin management entry that contains a Map with key-value pairs read from the database based on the sql specified.

          * The steps are: first database connection is established by looking up the database connection in JNDI based on JNDI name,

          * JNDI Context factory if provided and other parameters as provided in cofiguration description. 

          * Second sql provided is executed against the database connection and lastly the results are read based on the columns provided in the

          * configuration.

          * @param key configuration management key

          * @param fileUrl file url is null, since database configuration is not file URL based.

          * @return Configuration management entry.

          */

         public ConfigurationManagementEntry getConfigurationManagementEntry(

                         final String key, final URL fileUrl) throws ConfigurationManagerException {

                 ConfigurationManagementEntry entry = null;

                 // at this point connect to the database, and get the info

                 validateParameters(key);

                 final Properties jndiProperties = new Properties();

                 prepareJndiProperties(jndiProperties);

                 Connection c = null;

                 PreparedStatement stmt = null;

                 ResultSet rs = null;

                 try {

                         InitialContext context = null;

                         context = getJndiContext(key, jndiProperties, context);

                         log.info("Initial context created for JNDI name " + jndiName);

                         c = getJdbcConnection(key, context);

                         log.info("Connected to the database by JNDI name " + jndiName + " and sql " + sql);

                         stmt = c.prepareStatement(sql);

                         log.debug("Statment perpared " + sql + " for database jndi name " + jndiName);

                         rs = stmt.executeQuery();

                         log.debug("Received result set for sql " + sql);

                         entry = createEntryBasedOnNameValuePairs(key, rs);

                         log.info("configuration management entry created for key " + key + " with sql " + sql);

                 } catch (SQLException e) {

                         log.error("Could not connect to the database using jndi name: " + jndiName + " sql " + sql + " and other parameters from configuration " + key, e);

                         throw new ConfigurationManagerException("Could not connect to the database using jndiName: " + jndiName + " sql " + sql + " and other parameters from configuration " + key, e);

                 } finally {

                         DBUtils.closeResultSet(rs);

                         DBUtils.closeStatement(stmt);

                         DBUtils.closeConnection(c);

                 }

                 return entry;

         }

         private ConfigurationManagementEntry createEntryBasedOnNameValuePairs(

                         final String key, final ResultSet rs) throws SQLException {

                 ConfigurationManagementEntry entry;

                 final Map<String, String> configuration = new HashMap<String, String>();

                 String mapKey = null;

                 String mapValue = null;

                 while(rs.next()) {

                         mapKey = rs.getString(keyColumnName);

                         mapValue = rs.getString(valueColumnName);

                         log.debug("getting key " + mapKey + " value " + mapValue + " for sql " + sql);

                         configuration.put(mapKey, mapValue);

                 }

                 final String fileName = "jndiName : " + jndiName +  " sql " + sql;

                 //construct the configuration entry

                 entry = new ConfigurationManagementEntryImpl(key, fileName, configuration, this, ConfigurationType.DB_JNDI);

                 return entry;

         }

         private Connection getJdbcConnection(final String key, final InitialContext context) throws SQLException, ConfigurationManagerException {

                 Connection c = null;

                 try {

                         final DataSource dc = (DataSource) context.lookup(jndiName);

                         c = dc.getConnection();

                 } catch (NamingException e) {

                         log.error("Could not lookup jndi name: " + jndiName + " sql " + sql + " and other parameters from configuration " + key, e);

                         throw new ConfigurationManagerException("Could not lookup jndi name: " + jndiName + " sql " + sql + " and other parameters from configuration " + key, e);

                 }

                 return c;

         }

         /**

          * Validates that key, jndi name, sql, etc are not null parameters 

          * @param key

          * @throws ConfigurationManagerException

          */

         protected void validateParameters(final String key) throws ConfigurationManagerException {

                 super.validateParameters(key);

                 if (sql == null) {

                         throw new ConfigurationManagerException("sql is null, please provide sql in you master configuraton file for external cofiguraton with key =" + key);

                 }

                 if (keyColumnName == null) {

                         throw new ConfigurationManagerException("keyColumnName is null, please provide key column name in you master configuraton file for external cofiguraton with key =" + key);

                 }

                 if (valueColumnName == null) {

                         throw new ConfigurationManagerException("valueColumnName is null, please provide valueColumnName in you master configuraton file for external cofiguraton with key =" + key);

                 }

         }

 }