/*
    * The SmartConfig Library
    * Copyright (C) 2004-2006
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    *
   * This library 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
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   *
   * For further informations on the SmartConfig Library please visit
   *
   *                        http://smartconfig.sourceforge.net
   */
  package net.smartlab.config;
  
  import java.io.PrintWriter;
  import java.sql.CallableStatement;
  import java.sql.Connection;
  import java.sql.DatabaseMetaData;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.sql.SQLWarning;
  import java.sql.Savepoint;
  import java.sql.Statement;
  import java.util.Map;
  
  import javax.sql.DataSource;
  
  /**
   * Represents a configuration expressed through a database table.
   * 
   * @author rlogiacco
   */
  public final class SQLConfiguration extends Configuration {
  
  	/**
  	 * The database connection pool.
  	 */
  	private DataSource pool;
  
  	/**
  	 * Last access time to the underlying byte representation. Used to identify
  	 * a possible need to update the in-memory representation.
  	 */
  	private long updated;
  
  	/**
  	 * Name used to identify the last update time on the database.
  	 */
  	protected final static String LAST_UPDATE = "'smartconfig.last_update'";
  
  
  	/**
  	 * Constructs a configuration structure from a JDBC connection.
  	 * 
  	 * The providen connection must be active and open and should not be closed
  	 * from outside otherwise any subsequent update check will fail.
  	 * 
  	 * @param connection the connection to use to retrieve informations from the
  	 *        database.
  	 * @throws ConfigurationException
  	 */
  	public SQLConfiguration(Connection connection) throws ConfigurationException {
  		this(new SimpleDataSource(connection));
  	}
  
  	/**
  	 * Constructs a configuration structure from a JDBC data source.
  	 * 
  	 * @param pool the data source providing database connections.
  	 * @throws ConfigurationException
  	 */
  	public SQLConfiguration(DataSource pool) throws ConfigurationException {
  		this.pool = pool;
  		this.update();
  	}
  
  	/**
  	 * @see net.smartlab.config.Configuration#isChanged()
  	 */
  	public boolean isChanged() throws ConfigurationException {
  		return this.getLastUpdate(false) > this.updated;
  	}
  
  	/**
  	 * @see net.smartlab.config.Configuration#update()
  	 */
  	public void update() throws ConfigurationException {
  		Connection connection = null;
 		try {
 			connection = pool.getConnection();
 			PreparedStatement statement = connection.prepareStatement("SELECT name, value FROM config WHERE name <> "
 					+ LAST_UPDATE);
 			ResultSet rows = statement.executeQuery();
 			while (rows.next()) {
 				String name = rows.getString(1);
 				String value = rows.getString(2);
 				this.add(name, value);
 			}
 			this.updated = this.getLastUpdate(true);
 		} catch (SQLException sqle) {
 			throw new ConfigurationException(sqle);
 		} finally {
 			try {
 				connection.close();
 			} catch (SQLException sqle) {
 				sqle.printStackTrace();
 			} catch (NullPointerException npe) {
 				System.out.println("Unable to retrieve connection");
 			}
 		}
 	}
 
 	/**
 	 * Extracts the last modification timestamp from the underling database.
 	 * 
 	 * @param set specifies if the last modification time must be set if not
 	 *        found
 	 * @return the last modification timestamp.
 	 * @throws ConfigurationException if something unexpected happens trying to
 	 *         retrieve the last modification timestamp or if the corresponding
 	 *         parameter has not been defined.
 	 */
 	public long getLastUpdate(boolean set) throws ConfigurationException {
 		Connection connection = null;
 		try {
 			connection = pool.getConnection();
 			PreparedStatement statement = connection.prepareStatement("SELECT value FROM config WHERE name = "
 					+ LAST_UPDATE);
 			ResultSet rows = statement.executeQuery();
 			if (rows.next()) {
 				return Long.parseLong(rows.getString(1));
 			} else if (set) {
 				long time = System.currentTimeMillis();
 				this.setLastUpdate(time);
 				return time;
 			} else {
 				throw new ConfigurationException("Cannot find special configuration parameter " + LAST_UPDATE);
 			}
 		} catch (SQLException sqle) {
 			throw new ConfigurationException(sqle);
 		} finally {
 			try {
 				connection.close();
 			} catch (SQLException sqle) {
 				sqle.printStackTrace();
 			} catch (NullPointerException npe) {
 				System.out.println("Unable to retrieve connection");
 			}
 		}
 	}
 
 	/**
 	 * Sets the last modification timestamp into the underling database.
 	 * 
 	 * @param timestamp the last modification timestamp to set.
 	 * @throws ConfigurationException f something unexpected happens trying to
 	 *         set the last modification timestamp.
 	 */
 	public void setLastUpdate(long timestamp) throws ConfigurationException {
 		Connection connection = null;
 		try {
 			connection = pool.getConnection();
 			try {
 				connection.prepareStatement("UPDATE config SET value='" + timestamp + "' WHERE name=" + LAST_UPDATE)
 						.execute();
 			} catch (SQLException sqle) {
 				connection.prepareStatement("INSERT INTO config VALUES (" + LAST_UPDATE + ",'" + timestamp + "')")
 						.execute();
 			}
 		} catch (SQLException sqle) {
 			throw new ConfigurationException(sqle);
 		} finally {
 			try {
 				connection.close();
 			} catch (SQLException sqle) {
 				sqle.printStackTrace();
 			} catch (NullPointerException npe) {
 				System.out.println("Unable to retrieve connection");
 			}
 		}
 	}
 
 	/**
 	 * Adds informations to the in-memory configuration.
 	 * 
 	 * @param fqn the fully qualified name as stored into the table
 	 * @param value the value relative to the fqn providen
 	 * @throws ConfigurationException if somethign wrong occurs while adding the
 	 *         informations to the configuration
 	 */
 	private Element add(String fqn, String value) throws ConfigurationException {
 		String path = null;
 		String name = fqn;
 		int index = -1;
 		String attribute = null;
 		int pathLength = fqn.lastIndexOf(".");
 		int itemSeparator = fqn.indexOf("#");
 		int attributeStart = fqn.indexOf("[");
 		if (pathLength > -1) {
 			path = fqn.substring(0, pathLength);
 			name = fqn.substring(pathLength + 1);
 		}
 		if (itemSeparator > -1) {
 			if (attributeStart > -1) {
 				name = fqn.substring(pathLength + 1, itemSeparator);
 				index = Integer.parseInt(fqn.substring(itemSeparator + 1, attributeStart));
 				attribute = fqn.substring(attributeStart + 1, fqn.length() - 1);
 			} else {
 				name = fqn.substring(pathLength + 1, itemSeparator);
 				index = Integer.parseInt(fqn.substring(itemSeparator + 1));
 			}
 		} else if (attributeStart > -1) {
 			name = fqn.substring(pathLength + 1, attributeStart);
 			attribute = fqn.substring(attributeStart + 1, fqn.length() - 1);
 		}
 		Node parent = null;
 		Element node = null;
 		if (path != null) {
 			parent = this.findNode(this, path);
 			if (parent == null) {
 				parent = (Node)this.add(path, null);
 			}
 			if (index > -1) {
 				try {
 					node = (Element)parent.getElements(name).toArray()[index - 1];
 				} catch (Exception e) {
 					node = null;
 				}
 			} else {
 				node = (Element)parent.getElement(name);
 			}
 		} else if (this.name == null || this.name.equals(name)) {
 			node = this;
 			node.name = name;
 		} else {
 			throw new ConfigurationException("Configuration tree can have only one root node: found " + name
 					+ " conflicting with " + this.name);
 		}
 		if (node == null) {
 			if (attribute != null && attribute.equals(Reference.REFERENCE)) {
 				node = new Reference(parent, name, value);
 			} else {
 				node = new Node(parent, name, null);
 			}
 			if (index > -1) {
 				try {
 					parent.children.set(index - 1, node);
 				} catch (IndexOutOfBoundsException ioobe) {
 					parent.children.add(index - 1, node);
 				}
 			} else {
 				parent.children.add(node);
 			}
 		}
 		if (!(node instanceof Reference)) {
 			if (attribute == null) {
 				if (value != null && value.trim().length() > 0) {
 					((Node)node).setContent(value);
 				}
 			} else {
 				((Node)node).attributes.put(attribute, value);
 			}
 		}
 		return node;
 	}
 
 	/**
 	 * Recursively search a node up in the configuration tree
 	 * 
 	 * @param node
 	 * @param path
 	 * @return
 	 * @throws ConfigurationException
 	 */
 	private Node findNode(Node node, String path) throws ConfigurationException {
 		if (node instanceof SQLConfiguration && path.startsWith(node.name + '.')) {
 			path = path.substring(path.indexOf('.') + 1);
 		}
 		if (node == null || path.equals(node.name)) {
 			return node;
 		}
 		int index = path.indexOf('.');
 		if (index > -1) {
 			String child = path.substring(0, index);
 			return this.findNode((Node)node.getElement(child), path.substring(index + 1));
 		} else {
 			return (Node)node.getElement(path);
 		}
 	}
 
 
 	/**
 	 * A basic datasource implementation to wrap a single database connection.
 	 * 
 	 * @author rlogiacco
 	 * @deprecated
 	 */
 	private static class SimpleDataSource implements DataSource {
 
 		/**
 		 * @uml.property name="connection"
 		 */
 		private Connection connection;
 
 
 		public SimpleDataSource(Connection connection) {
 			this.connection = new ConnectionWrapper(connection);
 		}
 
 		/**
 		 * TODO documentation
 		 * 
 		 * @return
 		 * @throws SQLException
 		 * @uml.property name="connection"
 		 */
 		public Connection getConnection() throws SQLException {
 			return connection;
 		}
 
 		public Connection getConnection(String username, String password) throws SQLException {
 			throw new UnsupportedOperationException();
 		}
 
 		public PrintWriter getLogWriter() throws SQLException {
 			throw new UnsupportedOperationException();
 		}
 
 		public int getLoginTimeout() throws SQLException {
 			throw new UnsupportedOperationException();
 		}
 
 		public void setLogWriter(PrintWriter out) throws SQLException {
 			throw new UnsupportedOperationException();
 		}
 
 		public void setLoginTimeout(int seconds) throws SQLException {
 			throw new UnsupportedOperationException();
 		}
 
 
 		/**
 		 * Wraps a connection to avoid it being closed.
 		 * 
 		 * @author rlogiacco
 		 */
 		private static class ConnectionWrapper implements Connection {
 
 			private Connection connection;
 
 
 			public ConnectionWrapper(Connection connection) {
 				this.connection = connection;
 			}
 
 			/**
 			 * @see java.sql.Connection#clearWarnings()
 			 */
 			public void clearWarnings() throws SQLException {
 				connection.clearWarnings();
 			}
 
 			/**
 			 * @see java.sql.Connection#close()
 			 */
 			public void close() throws SQLException {
 				// Nothing
 			}
 
 			/**
 			 * @see java.sql.Connection#commit()
 			 */
 			public void commit() throws SQLException {
 				connection.commit();
 			}
 
 			/**
 			 * @see java.sql.Connection#createStatement()
 			 */
 			public Statement createStatement() throws SQLException {
 				return connection.createStatement();
 			}
 
 			/**
 			 * @see java.sql.Connection#createStatement(int, int)
 			 */
 			public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
 				return connection.createStatement(resultSetType, resultSetConcurrency);
 			}
 
 			/**
 			 * @see java.sql.Connection#createStatement(int, int, int)
 			 */
 			public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
 					throws SQLException {
 				return connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
 			}
 
 			/**
 			 * @see java.sql.Connection#getAutoCommit()
 			 */
 			public boolean getAutoCommit() throws SQLException {
 				return connection.getAutoCommit();
 			}
 
 			/**
 			 * @see java.sql.Connection#getCatalog()
 			 */
 			public String getCatalog() throws SQLException {
 				return connection.getCatalog();
 			}
 
 			/**
 			 * @see java.sql.Connection#getHoldability()
 			 */
 			public int getHoldability() throws SQLException {
 				return connection.getHoldability();
 			}
 
 			/**
 			 * @see java.sql.Connection#getMetaData()
 			 */
 			public DatabaseMetaData getMetaData() throws SQLException {
 				return connection.getMetaData();
 			}
 
 			/**
 			 * @see java.sql.Connection#getTransactionIsolation()
 			 */
 			public int getTransactionIsolation() throws SQLException {
 				return connection.getTransactionIsolation();
 			}
 
 			/**
 			 * @see java.sql.Connection#getTypeMap()
 			 */
 			public Map getTypeMap() throws SQLException {
 				return connection.getTypeMap();
 			}
 
 			/**
 			 * @see java.sql.Connection#getWarnings()
 			 */
 			public SQLWarning getWarnings() throws SQLException {
 				return connection.getWarnings();
 			}
 
 			/**
 			 * @see java.sql.Connection#isClosed()
 			 */
 			public boolean isClosed() throws SQLException {
 				return connection.isClosed();
 			}
 
 			/**
 			 * @see java.sql.Connection#isReadOnly()
 			 */
 			public boolean isReadOnly() throws SQLException {
 				return connection.isReadOnly();
 			}
 
 			/**
 			 * @see java.sql.Connection#nativeSQL(java.lang.String)
 			 */
 			public String nativeSQL(String sql) throws SQLException {
 				return connection.nativeSQL(sql);
 			}
 
 			/**
 			 * @see java.sql.Connection#prepareCall(java.lang.String)
 			 */
 			public CallableStatement prepareCall(String sql) throws SQLException {
 				return connection.prepareCall(sql);
 			}
 
 			/**
 			 * @see java.sql.Connection#prepareCall(java.lang.String, int, int)
 			 */
 			public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency)
 					throws SQLException {
 				return connection.prepareCall(sql, resultSetType, resultSetConcurrency);
 			}
 
 			/**
 			 * @see java.sql.Connection#prepareCall(java.lang.String, int, int,
 			 *      int)
 			 */
 			public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
 					int resultSetHoldability) throws SQLException {
 				return connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
 			}
 
 			/**
 			 * @see java.sql.Connection#prepareStatement(java.lang.String)
 			 */
 			public PreparedStatement prepareStatement(String sql) throws SQLException {
 				return connection.prepareStatement(sql);
 			}
 
 			/**
 			 * @see java.sql.Connection#prepareStatement(java.lang.String, int)
 			 */
 			public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
 				return connection.prepareStatement(sql, autoGeneratedKeys);
 			}
 
 			/**
 			 * @see java.sql.Connection#prepareStatement(java.lang.String,
 			 *      int[])
 			 */
 			public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
 				return connection.prepareStatement(sql, columnIndexes);
 			}
 
 			/**
 			 * @see java.sql.Connection#prepareStatement(java.lang.String,
 			 *      java.lang.String[])
 			 */
 			public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
 				return connection.prepareStatement(sql, columnNames);
 			}
 
 			/**
 			 * @see java.sql.Connection#prepareStatement(java.lang.String, int,
 			 *      int)
 			 */
 			public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
 					throws SQLException {
 				return connection.prepareStatement(sql, resultSetType, resultSetConcurrency);
 			}
 
 			/**
 			 * @see java.sql.Connection#prepareStatement(java.lang.String, int,
 			 *      int, int)
 			 */
 			public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
 					int resultSetHoldability) throws SQLException {
 				return connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
 			}
 
 			/**
 			 * @see java.sql.Connection#releaseSavepoint(java.sql.Savepoint)
 			 */
 			public void releaseSavepoint(Savepoint savepoint) throws SQLException {
 				connection.releaseSavepoint(savepoint);
 			}
 
 			/**
 			 * @see java.sql.Connection#rollback()
 			 */
 			public void rollback() throws SQLException {
 				connection.rollback();
 			}
 
 			/**
 			 * @see java.sql.Connection#rollback(java.sql.Savepoint)
 			 */
 			public void rollback(Savepoint savepoint) throws SQLException {
 				connection.rollback(savepoint);
 			}
 
 			/**
 			 * @see java.sql.Connection#setAutoCommit(boolean)
 			 */
 			public void setAutoCommit(boolean autoCommit) throws SQLException {
 				connection.setAutoCommit(autoCommit);
 			}
 
 			/**
 			 * @see java.sql.Connection#setCatalog(java.lang.String)
 			 */
 			public void setCatalog(String catalog) throws SQLException {
 				connection.setCatalog(catalog);
 			}
 
 			/**
 			 * @see java.sql.Connection#setHoldability(int)
 			 */
 			public void setHoldability(int holdability) throws SQLException {
 				connection.setHoldability(holdability);
 			}
 
 			/**
 			 * @see java.sql.Connection#setReadOnly(boolean)
 			 */
 			public void setReadOnly(boolean readOnly) throws SQLException {
 				connection.setReadOnly(readOnly);
 			}
 
 			/**
 			 * @see java.sql.Connection#setSavepoint()
 			 */
 			public Savepoint setSavepoint() throws SQLException {
 				return connection.setSavepoint();
 			}
 
 			/**
 			 * @see java.sql.Connection#setSavepoint(java.lang.String)
 			 */
 			public Savepoint setSavepoint(String name) throws SQLException {
 				return connection.setSavepoint(name);
 			}
 
 			/**
 			 * @see java.sql.Connection#setTransactionIsolation(int)
 			 */
 			public void setTransactionIsolation(int level) throws SQLException {
 				connection.setTransactionIsolation(level);
 			}
 
 			/**
 			 * @see java.sql.Connection#setTypeMap(java.util.Map)
 			 */
 			public void setTypeMap(Map typeMap) throws SQLException {
 				connection.setTypeMap(typeMap);
 			}
 		}
 	}
 }