/*
    * Copyright 2004-2006 the Seasar Foundation and the Others.
    *
    * 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.seasar.tuigwaa.database;
  
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.dom4j.Document;
  import org.hibernate.HibernateException;
  import org.hibernate.MappingException;
  import org.hibernate.SessionFactory;
  import org.hibernate.cfg.Configuration;
  import org.hibernate.cfg.HbmBinder;
  import org.hibernate.cfg.Mappings;
  import org.hibernate.dialect.Dialect;
  import org.hibernate.engine.Mapping;
  import org.hibernate.mapping.Column;
  import org.hibernate.mapping.ForeignKey;
  import org.hibernate.mapping.PersistentClass;
  import org.hibernate.mapping.Property;
  import org.hibernate.mapping.Table;
  import org.hibernate.tool.hbm2ddl.DatabaseMetadata;
  import org.hibernate.tool.hbm2ddl.TableMetadata;
  import org.hibernate.type.Type;
  import org.hibernate.util.CollectionHelper;
  import org.seasar.framework.util.ResourceUtil;
  import org.seasar.tuigwaa.model.core.TgwAttribute;
  import org.seasar.tuigwaa.model.core.TgwEntity;
  import org.seasar.tuigwaa.model.core.impl.FkAttribute;
  import org.seasar.tuigwaa.util.TgwResource;
  import org.seasar.tuigwaa.util.TgwUtils;
  
  import com.isenshi.util.extlib.HSQL18Dialect;
  
  /***
   * @author nishioka
   */
  public class DynaConfiguration extends Configuration {
  
  	private static final long serialVersionUID = 188829885451057673L;
  
  	private Log log = LogFactory.getLog(getClass());
  
  	private SessionFactory factory_;
  
  	private Map managedEntittyMap_ = new HashMap(); //key:entityName value:entity
  
  	private static final String DEFAULT_CONFIG_PATH = "hibernate.cfg.xml";
  
  	private String dialect;
  
  	public DynaConfiguration(String driver) throws HibernateException {
  		super();
  		super.configure(ResourceUtil.getResource(DEFAULT_CONFIG_PATH));
  		this.dialect = TgwResource.getProperty("hibernate." + driver);
  		build();
  	}
  
  	private Mapping map = new Mapping() {
  
  		public Type getIdentifierType(String persistentClass) throws MappingException {
  			PersistentClass pc = ( (PersistentClass) classes.get( persistentClass ) );
  			if ( pc == null ) {
  				throw new MappingException( "persistent class not known: " + persistentClass );
  			}
  			return pc.getIdentifier().getType();
  		}
  
  		public String getIdentifierPropertyName(String persistentClass) throws MappingException {
  			final PersistentClass pc = (PersistentClass) classes.get( persistentClass );
  			if ( pc == null ) {
  				throw new MappingException( "persistent class not known: " + persistentClass );
  			}
  			if ( !pc.hasIdentifierProperty() ) return null;
  			return pc.getIdentifierProperty().getName();
  		}
  
  		public Type getReferencedPropertyType(String persistentClass, String propertyName) throws MappingException {
  			final PersistentClass pc = (PersistentClass) classes.get( persistentClass );
 			if ( pc == null ) {
 				throw new MappingException( "persistent class not known: " + persistentClass );
 			}
 			Property prop = pc.getReferencedProperty( propertyName );
 			if ( prop == null ) {
 				throw new MappingException(
 						"property not known: " + 
 						persistentClass + '.' + propertyName
 					);
 			}
 			return prop.getType();
 
 		}
 	};
 
 	public synchronized SessionFactory getSessionFactory()
 			throws HibernateException {
 		if (factory_ == null) {
 			build();
 		}
 		return factory_;
 	}
 
 	public String getCreateSQLString(Table table) throws HibernateException {
 		Dialect dialect = Dialect.getDialect(getProperties());
 		return table.sqlCreateString(dialect, map, null, null);
 	}
 
 	public String getDropSQLString(Table table) throws HibernateException {
 		Dialect dialect = Dialect.getDialect(getProperties());
 		return table.sqlDropString(dialect, null, null);
 	}
 
 	public Iterator getAlterSQLString(Table table, DatabaseMetadata dbMetadata,
 			String schema) throws HibernateException, SQLException {
 		Dialect dialect = Dialect.getDialect(getProperties());
 		TableMetadata tableMetadata = dbMetadata.getTableMetadata(table
 				.getName(), null, null);
 
 		return table.sqlAlterStrings(dialect, map, tableMetadata, null, null);
 	}
 
 	public String getCreateSchemaSQLString(String schema) {
 		Dialect dialect = Dialect.getDialect(getProperties());
 		if (dialect instanceof HSQL18Dialect) {
 			return "create schema " + schema + " authorization dba";
 		} else {
 			return "create schema " + schema;
 		}
 	}
 
 	public String getDropSchemaSQLString(String schema) {
 		// return "drop schema " + schema; for postgre
 		// return "drop schema " + schema + " authorization dba";
 		return "drop schema " + schema + " cascade";
 	}
 
 	public String getForeignKeySQLString(ForeignKey fk) {
 		Dialect dialect = Dialect.getDialect(getProperties());
 		fk.setCascadeDeleteEnabled(true); //cascade true
 		return fk.sqlCreateString(dialect, null, null, null);
 	}
 
 	public Table addTable(String schema, TgwEntity entity) throws HibernateException,
 			ClassNotFoundException {
 		return addTable(schema, entity, true);
 	}
 
 	public Table addTable(String schema, TgwEntity entity, boolean needRebuild)
 			throws HibernateException, ClassNotFoundException {
 		Mappings mappings = createMappings();
 		Table table = addTable(schema, entity, mappings);
 		if (needRebuild) {
 			build();
 		}
 		putEntity(entity);
 		return table;
 	}
 
 	public Table alterTable(String schema, TgwEntity entity) throws Exception {
 		doDeleteTable(schema, entity.getName(), false);
 		Table table = addTable(schema, entity, false);
 		resetConfiguration(schema);
 		return table;
 	}
 
 	public void deleteTable(String schema, String name) throws Exception {
 		doDeleteTable(schema, name, true);
 	}
 
 	public void deleteTable(String schema, String[] names) throws Exception {
 		for (int i = 0; i < names.length; i++) {
 			doDeleteTable(schema, names[i], false);
 		}
 		resetConfiguration(schema);
 	}
 
 	// [Start] ----- Private Method -----
 
 	private void resetConfiguration(String schema) throws HibernateException,
 			ClassNotFoundException {
 		super.reset();
 
 		synchronized (managedEntittyMap_) {
 			Iterator itr = managedEntittyMap_.values().iterator();
 			while (itr.hasNext()) {
 				TgwEntity entitiy = (TgwEntity) itr.next();
 				addTable(schema, entitiy, false);
 			}
 		}
 		build();
 	}
 
 	private void putEntity(TgwEntity entity) {
 		String name = entity.getName();
 		synchronized (managedEntittyMap_) {
 			managedEntittyMap_.put(name, entity);
 		}
 	}
 
 	private void removeEntity(String name) {
 		synchronized (managedEntittyMap_) {
 			managedEntittyMap_.remove(name);
 		}
 	}
 
 	public void build() throws HibernateException {
 		Properties props = getProperties();
 		props.setProperty("hibernate.dialect", dialect);
 		setProperties(props);
 		factory_ = buildSessionFactory();
 		log.info("Build Session Factory : " + factory_);
 	}
 
 	private Table addTable(String schema, TgwEntity entity, Mappings mappings)
 			throws ClassNotFoundException, HibernateException {
 
 		Document doc = HbmDocumentFactory.create(schema, entity);
 		HbmBinder.bindRoot(doc, mappings, CollectionHelper.EMPTY_MAP);
 
 		Table table = null;
 
 		String tableName = TgwUtils.toTableName(entity);
 
 		for (Iterator i = getTableMappings(); i.hasNext();) {
 			Table aTable = (Table) i.next();
 			String aTableName = aTable.getName();
 
 			if (tableName.equalsIgnoreCase(aTableName)) {
 				table = aTable;
 				// someda added for to work with foreign key
 				bindForeignKey(entity, table);
 				// end
 				break;
 			}
 		}
 		return table;
 	}
 
 	private void bindForeignKey(TgwEntity entity, Table table) {
 		Iterator fields = entity.getFieldIterator();
 		while (fields.hasNext()) {
 			TgwAttribute field = (TgwAttribute) fields.next();
 			if (field instanceof FkAttribute) {
 				FkAttribute fk = (FkAttribute) field;
 				List list = toColumnList(fk, table);
 				table.createForeignKey(null, list, fk.getRefEntity()
 						.getJavaClass().getName());
 			}
 		}
 	}
 
 	private List toColumnList(FkAttribute attr, Table table) {
 		List list = new ArrayList();
 		Iterator columns = table.getColumnIterator();
 		while (columns.hasNext()) {
 			Column col = (Column) columns.next();
 			if (attr.getName().equalsIgnoreCase(col.getName())) {
 				list.add(col);
 				break;
 			}
 		}
 		return list;
 	}
 
 	private void doDeleteTable(String schema, String name, boolean needResetConfiguration)
 			throws Exception {
 		removeEntity(name);
 		if (needResetConfiguration) {
 			resetConfiguration(schema);
 		}
 	}
 
 	// [End] ----- Private Method -----
 }