package org.xvsm.transactions;
   
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   import java.util.UUID;
   import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ScheduledFuture;
  
  import org.apache.log4j.Logger;
  import org.xvsm.core.ContainerRef;
  import org.xvsm.interfaces.container.IContainer;
  import org.xvsm.internal.ContainerManager;
  import org.xvsm.internal.EventProcessingPool;
  import org.xvsm.internal.TimeoutSchedulerPool;
  import org.xvsm.internal.exceptions.InvalidTransactionException;
  import org.xvsm.internal.exceptions.XCoreException;
  import org.xvsm.internal.tasks.TransactionTask;
  import org.xvsm.internal.tasks.TransactionTaskType;
  
  /***
   * 
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public final class TransactionManager {
  
  	/***
  	 * The Logger of this Class.
  	 */
  	private static Logger logger = Logger.getLogger(TransactionManager.class);
  
  	/***
  	 * The future object of the transaction manager.
  	 */
  	private static ScheduledFuture<?> tmFuture;
  
  	/***
  	 * 
  	 * @author Christian Schreiber, Michael Proestler
  	 * 
  	 */
  	private class TimeoutHandler implements Runnable {
  
  		/***
  		 * Creates a new TimeoutHandler.
  		 * 
  		 */
  		public TimeoutHandler() {
  		}
  
  		/***
  		 * 
  		 * {@inheritDoc}.
  		 */
  		// @Override
  		public void run() {
  			Thread.currentThread().setName(this.getClass().getName());
  			for (Transaction tx : knownTransaction.values()) {
  				tx.updateTimeout();
  				if (tx.timeoutExpired()) {
  					EventProcessingPool.getInstance().execute(
  							new TransactionTask(TransactionTaskType.ROLLBACK,
  									tx));
  				}
  			}
  		}
  	}
  
  	/***
  	 * The map contains all known Transaction.
  	 */
  	private Map<String, Transaction> knownTransaction = new ConcurrentHashMap<String, Transaction>();
  
  	/***
  	 * static instance.
  	 */
  	private static TransactionManager tm = null;
  
  	/***
  	 * Factory method.
  	 * 
  	 * @return a TransactionManager instance.
  	 */
  	public static synchronized TransactionManager getInstance() {
  		if (tm == null) {
  			tm = new TransactionManager();
  		}
  		return tm;
  	}
  
  	/***
  	 * Destroys the current TransactionManager instance.
  	 * 
  	 */
  	public static synchronized void removeInstance() {
  		if (tmFuture != null) {
 			tmFuture.cancel(true);
 		}
 		tmFuture = null;
 		tm = null;
 	}
 
 	/***
 	 * Invisible default Constructor. Utility Classes must not have a public
 	 * default constructor.
 	 */
 	private TransactionManager() {
 		// Start one timeouthandler for the transactions.
 		// TODO we need some logic to start more then one timeouthandler if
 		// necessary.
 		TimeoutHandler th = new TimeoutHandler();
 		tmFuture = TimeoutSchedulerPool.schedule(th);
 	}
 
 	/***
 	 * Creates a new Transaction.
 	 * 
 	 * @param timeout
 	 *            the timeout of the transaction
 	 * @return a new Transaction.
 	 */
 	public Transaction createTransaction(long timeout) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("createTransaction(" + timeout + ")");
 		}
 
 		Transaction tx = new Transaction(UUID.randomUUID().toString());
 		tx.setTimeout(timeout);
 		this.knownTransaction.put(tx.getId(), tx);
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("createTransaction() transaction created: " + tx);
 		}
 
 		return tx;
 	}
 
 	/***
 	 * Creates a new Transaction which is a child of tx.
 	 * 
 	 * @param tx
 	 *            the father transaction.
 	 * @return a new Transaction.
 	 */
 	public Transaction createSubTransaction(Transaction tx) {
 		Transaction newtx = this.createTransaction(tx.getTimeout());
 		newtx.setFather(tx);
 		return newtx;
 	}
 
 	/***
 	 * Creates a new implicit Transaction.
 	 * 
 	 * @param timeout
 	 *            the timeout of the transaction
 	 * @return a new Transaction.
 	 */
 	public Transaction createImplicitTransaction(long timeout) {
 		Transaction tx = this.createTransaction(timeout);
 		tx.setImplicit(true);
 		return tx;
 	}
 
 	/***
 	 * Removes a {@link Transaction} from the known TransactionManager. This
 	 * method has to be used when a transaction is committed or rolled back.
 	 * 
 	 * @param tx
 	 *            The {@link Transaction} that should be removed.
 	 */
 	public void removeTransaction(Transaction tx) {
 		this.knownTransaction.remove(tx.getId());
 	}
 
 	/***
 	 * Returns if the given {@link Transaction} is valid (eg. correctly created,
 	 * not committed or rolled back).
 	 * 
 	 * @param tx
 	 *            the transaction to check.
 	 * @return <code>true</code> if tx is valid otherwise <code>false</code>
 	 */
 	public boolean isValid(Transaction tx) {
 		return this.knownTransaction.containsKey(tx.getId());
 	}
 
 	/***
 	 * Get the Transaction object according to the given identifier.
 	 * 
 	 * @param id
 	 *            the identifier of the transaction.
 	 * @throws InvalidTransactionException
 	 *             if there is no Transaction with this identifier.
 	 * @return the matching Transaction object.
 	 */
 	public Transaction getTransaction(String id)
 			throws InvalidTransactionException {
 		Transaction tx = this.knownTransaction.get(id);
 		if (tx == null) {
 			throw new InvalidTransactionException();
 		}
 		return tx;
 	}
 
 	/***
 	 * Get a list of all transactions.
 	 * 
 	 * @return a list of all transactions objects.
 	 */
 	public List<Transaction> getAll() {
 		return new ArrayList<Transaction>(this.knownTransaction.values());
 	}
 
 	/***
 	 * Commits a Transaction.
 	 * 
 	 * @param tx
 	 *            the Transaction that should be commited.
 	 * @throws XCoreException
 	 *             if something went wrong during adding the aspect. see
 	 *             .getCause() for the reason
 	 */
 	public void commitTransaction(Transaction tx) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("commitTransaction(" + tx + ")");
 		}
 
 		IContainer cc = ContainerManager.getInstance().getContainerContainer();
 		boolean cctoCommit = false;
 		for (ContainerRef cref : tx.getModifiedContainers()) {
 			IContainer c = ContainerManager.getInstance()
 					.getContainer(tx, cref);
 			if (c != null && c.equals(cc)) {
 				cctoCommit = true;
 			} else {
 				try {
 					c.commit(tx);
 				} catch (NullPointerException e) {
 					logger.warn("Container " + cref
 							+ ": Commit failed because it doesn't exists.");
 					// throw new FatalException(e);
 				}
 			}
 		}
 		if (cctoCommit) {
 			cc.commit(tx);
 		}
 
 		this.removeTransaction(tx);
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("commitTransaction() transaction commited");
 		}
 	}
 
 	/***
 	 * Does a rollback of the given Transaction.
 	 * 
 	 * @param tx
 	 *            the Transaction that should be rollbacked.
 	 * @throws XCoreException
 	 *             if something went wrong during adding the aspect. see
 	 *             .getCause() for the reason
 	 */
 	public void rollbackTransaction(Transaction tx) throws XCoreException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("rollbackTransaction(" + tx + ")");
 		}
 		tx.setUnderRollback(true);
 		IContainer cc = ContainerManager.getInstance().getContainerContainer();
 		boolean cctoRollback = false;
 		for (ContainerRef cref : new ArrayList<ContainerRef>(tx
 				.getModifiedContainers())) {
 			IContainer c = ContainerManager.getInstance()
 					.getContainer(tx, cref);
 			if (c.equals(cc)) {
 				cctoRollback = true;
 			} else {
 				try {
 					c.rollback(tx);
 				} catch (NullPointerException e) {
 					logger.warn("Container " + cref
 							+ ": Commit failed because it doesn't exists.");
 				}
 			}
 		}
 		if (cctoRollback) {
 			cc.rollback(tx);
 		}
 
 		this.removeTransaction(tx);
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("rollbackTransaction() transaction rolled back");
 		}
 
 	}
 }