/*
    * 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.
   */
  /*
   * Created on 2005/07/31
   */
  package org.seasar.tuigwaa.database;
  
  import java.sql.Connection;
  import java.sql.SQLException;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.transaction.Synchronization;
  import javax.transaction.Transaction;
  import javax.transaction.TransactionManager;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.hibernate.FlushMode;
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.seasar.extension.jdbc.util.ConnectionUtil;
  import org.seasar.framework.exception.SQLRuntimeException;
  import org.seasar.framework.util.TransactionManagerUtil;
  import org.seasar.framework.util.TransactionUtil;
  
  /***
   * @author nishioka
   */
  public class DynaSessionFactoryImpl implements DynaSessionFactory,
  		Synchronization {
  
  	private Log log = LogFactory.getLog(getClass());
  
  	private final Map configManager = Collections
  			.synchronizedMap(new HashMap());
  
  	private final TransactionManager transactionManager;
  
  	private final BasicDatabaseService dbService;
  
  	private final Map txSessions = Collections.synchronizedMap(new HashMap());
  
  	public DynaSessionFactoryImpl(TransactionManager transactionManager,
  			BasicDatabaseService dbService) {
  		this.transactionManager = transactionManager;
  		this.dbService = dbService;
  	}
  
  	public void deleteConfiguration(String domainName) {
  		removeConfiguration(domainName);
  	}
  
  	public TransactionManager getTransactionManager() {
  		return transactionManager;
  	}
  
  	public synchronized SessionFactory getSessionFactory() {
  		return getSessionFactory(null);
  	}
  
  	public synchronized SessionFactory getSessionFactory(String domainName) {
  		DynaConfiguration cfg = getConfiguration(domainName);
  		SessionFactory factory = null;
  		factory = cfg.getSessionFactory();
  		return factory;
  	}
  
  	public DynaConfiguration getConfiguration(String domainName) {
  		DynaConfiguration cfg = (DynaConfiguration) configManager.get(domainName);
  		if (cfg == null) {
  			String driver = dbService.getDriver(domainName);
  			cfg = new DynaConfiguration(driver);
  			putConfiguration(domainName, cfg);
  		}
  		return cfg;
  	}
  
  	public int getTxSessionSize() {
  		return txSessions.size();
  	}
  
  	public Session getSession() {
  		return getSession(null);
  	}
 
 	public Session getSession(String domainName) {
 		Transaction tx = getTransaction();
 		if (tx == null) {
 			return createSession(domainName);
 		}
 		Session session = (Session) txSessions.get(tx);
 		if (session != null && session.isOpen()) {
 			return session;
 		}
 		return bindSession(tx, domainName);
 	}
 
 	public Connection getConnection(String domainName) {
 		try {
 			return dbService.getConnection(domainName);
 		} catch (SQLException e) {	
 			throw new SQLRuntimeException(e);
 		}
 	}
 
 	public void beforeCompletion() {
 		flushSession();
 	}
 
 	public void afterCompletion(int arg0) {
 		closeSession();
 	}
 
 	// [Start] ----- Private Method -----
 
 	private Session bindSession(Transaction tx, String schema) {
 		Session session = (Session) txSessions.get(tx);
 		if (session != null && session.isOpen()) {
 			return session;
 		}
 		session = createSession(schema);
 		txSessions.put(tx, session);
 		TransactionUtil.registerSynchronization(tx, this);
 		return session;
 	}
 
 	private void closeSession() {
 		Transaction tx = getTransaction();
 		if (tx == null) {
 			return;
 		}
 
 		Session session = (Session) txSessions.remove(tx);
 		if (session != null && session.isOpen()) {
 			try {
 				session.clear();
 			} finally {
 				Connection con = session.close();
 				ConnectionUtil.close(con);
 			}
 		}
 	}
 
 	private void flushSession() {
 		Transaction tx = getTransaction();
 		if (tx == null) {
 			return;
 		}
 		Session session = (Session) txSessions.get(tx);
 		if (session == null || !session.isOpen()
 				|| session.getFlushMode().equals(FlushMode.NEVER)) {
 			return;
 		}
 		session.flush();
 	}
 
 	private void putConfiguration(String domainName, DynaConfiguration cfg) {
 		configManager.put(domainName, cfg);
 		log.info("Put Configuration :" + cfg);
 	}
 
 	private void removeConfiguration(String domainName) {
 		configManager.remove(domainName);
 	}
 
 	private Transaction getTransaction() {
 		return TransactionManagerUtil.getTransaction(getTransactionManager());
 	}
 
 	private Session createSession(String domainName) {
 		SessionFactory factory = getSessionFactory(domainName);
 		return factory.openSession(getConnection(domainName));
 	}
 }