/*
    * 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.Connection;
  import java.sql.PreparedStatement;
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.hibernate.HibernateException;
  import org.hibernate.cfg.Configuration;
  import org.hibernate.dialect.Dialect;
  import org.hibernate.mapping.ForeignKey;
  import org.hibernate.mapping.Table;
  import org.hibernate.tool.hbm2ddl.DatabaseMetadata;
  import org.seasar.tuigwaa.model.core.TgwEntity;
  import org.seasar.tuigwaa.util.TgwUtils;
  
  import com.isenshi.util.TableMap;
  
  /***
   * @author nishioka
   */
  public class DynaDatabaseServiceImpl implements DynaDatabaseService {
  
  	private Log log = LogFactory.getLog(getClass());
  
  	private BasicDatabaseService db;
  
  	private DynaSessionFactory factory_;
  
  	private TableMap tableNameMap = new TableMap();
  
  	public DynaDatabaseServiceImpl(BasicDatabaseService basicDBService,
  			DynaSessionFactory factory) {
  		this.db = basicDBService;
  		this.factory_ = factory;
  	}
  
  	public void createSchema(String domainName) throws Exception {
  		if (db.useBaseDatabase(domainName) && !db.existSchema(domainName)) {
  			DynaConfiguration cfg = factory_.getConfiguration(domainName);
  			String sql = cfg.getCreateSchemaSQLString(domainName);
  			executeSQL(domainName, sql);
  		}
  	}
  
  	public void dropSchema(String domainName) throws Exception {
  		if (db.useBaseDatabase(domainName) && db.existSchema(domainName)) {
  			DynaConfiguration cfg = factory_.getConfiguration(domainName);
  			String sql = cfg.getDropSchemaSQLString(domainName);
  			executeSQL(domainName, sql);
  		}else{
  			db.removeExternalDatabaseMapping(domainName);
  		}
  		factory_.deleteConfiguration(domainName);
  	}
  
  	public void createTable(TgwEntity entity) {
  		String domainName = entity.getDomainName();
  		DynaConfiguration cfg = factory_.getConfiguration(domainName);
  
  		try {
  			// change configuration
  			Table table = addTable(cfg, domainName, entity, true);
  
  			// change physical database
  			if (!existTable(entity)) {
  				doCreateTable(cfg, domainName, table);
  				doCreateForeignKey(cfg, domainName, table);
  			}
  		} catch (SQLException e) {
  			e.printStackTrace();
  			throw new RuntimeException(e);
  		} catch (HibernateException e) {
  			e.printStackTrace();
  			throw new RuntimeException(e);
  		} catch (ClassNotFoundException e) {
  			e.printStackTrace();
  			throw new RuntimeException(e);
 		}
 	}
 
 	public void createTables(String domainName, Collection entityList) {
 		DynaConfiguration cfg = factory_.getConfiguration(domainName);
 		List tableList = new ArrayList();
 		try {
 			// change configuration
 			Iterator itr = entityList.iterator();
 			while (itr.hasNext()) {
 				TgwEntity entity = (TgwEntity) itr.next();
 				Table table = addTable(cfg, domainName, entity, false);
 				if (!existTable(entity)) {
 					tableList.add(table);
 				}
 			}
 			cfg.build();
 
 			// change physical database
 			itr = tableList.iterator();
 			while (itr.hasNext()) {
 				Table table = (Table) itr.next();
 				doCreateTable(cfg, domainName, table);
 				doCreateForeignKey(cfg, domainName, table);
 			}
 		} catch (HibernateException e) {
 			e.printStackTrace();
 		} catch (ClassNotFoundException e) {
 			e.printStackTrace();
 		} catch (SQLException e) {
 			e.printStackTrace();
 		}
 	}
 
 	public List readTables(String domainName) {
 		List list = new ArrayList();
 		try {
 			Map map = db.createEntityMap(domainName);
 			list.addAll(map.values());
 		} catch (SQLException e) {
 			// TODO
 			log.info("Can't read database");
 		}
 		return list;
 	}
 
 	public void alterTable(TgwEntity entity) throws Exception {
 		String domainName = entity.getDomainName();
 
 		DynaConfiguration cfg = factory_.getConfiguration(domainName);
 
 		String schema = db.getSchemaName(domainName);
 
 		// change configuration
 		Table table = cfg.alterTable(schema, entity);
 
 		// Physical Database Manipulate
 		DatabaseMetadata metadata = getDatabaseMetadata(domainName);
 
 		Iterator itr = cfg.getAlterSQLString(table, metadata, schema);
 		while (itr.hasNext()) {
 			String sql = (String) itr.next();
 			executeSQL(domainName, sql);
 		}
 	}
 
 	public void dropTable(String domainName, String entityName)
 			throws Exception {
 		DynaConfiguration cfg = factory_.getConfiguration(domainName);
 
 		if (db.useBaseDatabase(domainName)) {
 			String schema = db.getSchemaName(domainName);
 			cfg.deleteTable(schema, entityName);
 			doDropTable(cfg, domainName, schema, entityName);
 		}
 	}
 
 	public void dropTables(String domainName, String[] entityNames)
 			throws Exception {
 		DynaConfiguration cfg = factory_.getConfiguration(domainName);
 		if (db.useBaseDatabase(domainName)) {
 			String schema = db.getSchemaName(domainName);
 			cfg.deleteTable(schema, entityNames);
 			for (int i = 0; i < entityNames.length; i++) {
 				doDropTable(cfg, domainName, schema, entityNames[i]);
 			}
 		}
 	}
 
 	// [Start] ----- Private Method -----
 
 	private void executeSQL(String domainName, String sql) throws SQLException,
 			HibernateException {
 		Connection conn = db.getConnection(domainName);
 		PreparedStatement stmt = conn.prepareStatement(sql);
 		log.info("execute SQL: " + sql);
 		stmt.executeUpdate();
 	}
 
 	private DatabaseMetadata getDatabaseMetadata(String domainName)
 			throws SQLException {
 		Connection conn = db.getConnection(domainName);
 		Configuration cfg = factory_.getConfiguration(domainName);
 		Dialect dialect = Dialect.getDialect(cfg.getProperties());
 		DatabaseMetadata metadata = new DatabaseMetadata(conn, dialect);
 		return metadata;
 	}
 
 	private void doCreateTable(DynaConfiguration cfg, String domainName,
 			Table table) throws HibernateException, SQLException {
 		String sql = cfg.getCreateSQLString(table);
 		executeSQL(domainName, sql);
 	}
 
 	private boolean existTable(TgwEntity entity) {
 		String domainName = entity.getDomainName();
 		String tableName = TgwUtils.toTableName(entity);
 		return db.existTable(domainName, tableName);
 	}
 
 	private void doCreateForeignKey(DynaConfiguration cfg, String schema,
 			Table table) throws HibernateException, SQLException {
 		Iterator fks = table.getForeignKeyIterator();
 		while (fks.hasNext()) {
 			ForeignKey fk = (ForeignKey) fks.next();
 			executeSQL(schema, cfg.getForeignKeySQLString(fk));
 		}
 	}
 
 	private void doDropTable(DynaConfiguration cfg, String domainName,
 			String schema, String entityName) throws HibernateException,
 			SQLException {
 		Table table = new Table();
 		if (schema != null) {
 			table.setSchema(schema);
 		}
 
 		String tableName = (String) tableNameMap.get(domainName, entityName);
 		if (tableName != null) {
 			table.setName(tableName);
 			String sql = cfg.getDropSQLString(table);
 			executeSQL(domainName, sql);
 		}
 	}
 
 	private Table addTable(DynaConfiguration cfg, String domainName,
 			TgwEntity entity, boolean needRebuild) throws HibernateException,
 			ClassNotFoundException {
 		String tableName = TgwUtils.toTableName(entity);
 		String schema = db.getSchemaName(domainName);
 
 		tableNameMap.put(tableName, domainName, entity.getName());
 		return cfg.addTable(schema, entity, needRebuild);
 	}
 }