package org.xvsm.transactions;
   
   import java.io.Serializable;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.StringTokenizer;
   import java.util.TreeMap;
  
  import org.xvsm.configuration.ConfigurationManager;
  import org.xvsm.core.ContainerRef;
  import org.xvsm.core.Entry;
  import org.xvsm.interfaces.ICapi;
  import org.xvsm.interfaces.ICoordinator;
  import org.xvsm.internal.exceptions.FatalException;
  import org.xvsm.remote.TransportHandler;
  
  /***
   * 
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public class Transaction implements Serializable {
  	/***
  	 * Auto generated serial version uid.
  	 */
  	private static final long serialVersionUID = -2895233282572881371L;
  
  	/***
  	 * An unique identifier for this transaction.
  	 */
  	private String id;
  
  	private boolean underRollback = false;
  
  	/***
  	 * indicates whether this transaction is an implicit transaction.
  	 */
  	private boolean implicit = false;
  
  	/***
  	 * A {@link List} of {@link Entry}s which have been modified under this
  	 * {@link Transaction}.
  	 */
  	// private TreeMap<String, Entry> modifiedEntries = new TreeMap<String,
  	// Entry>();
  	private transient TreeMap<ContainerRef, TreeMap<String, Entry>> modifiedEntries = new TreeMap<ContainerRef, TreeMap<String, Entry>>();
  
  	/***
  	 * The remaining timeout of this transaction.
  	 */
  	private long timeout;
  
  	/***
  	 * The time when the timeout has been updated.
  	 */
  	private long lastTimeoutUpdate;
  
  	/***
  	 * A {@link List} of {@link ICoordinator}s which have been used under this
  	 * {@link Transaction}.
  	 */
  	private transient List<ICoordinator> modifiedCoordinators = new ArrayList<ICoordinator>();
  
  	/***
  	 * A {@link List} of {@link ContainerRef}s which have been used under this
  	 * {@link Transaction}.
  	 */
  	private transient List<ContainerRef> modifiedContainers = new ArrayList<ContainerRef>();
  
  	/***
  	 * The father transaction.
  	 */
  	private Transaction father = null;
  
  	/***
  	 * The site on which this transaction has been created.
  	 */
  	private URI site = null;
  
  
  	/***
  	 * Create a new Transaction.
  	 * 
  	 * @param id
  	 *            the unique identifier for the new transaction.
  	 */
  	public Transaction(String id) {
  		this.id = id;
  		this.lastTimeoutUpdate = System.currentTimeMillis();
  	}
  
  	/***
  	 * Create a new Transaction.
  	 * 
  	 * @param id
  	 *            the unique identifier for the new transaction.
  	 * @param father
 	 *            the father of this transaction.
 	 */
 	public Transaction(String id, Transaction father) {
 		this(id);
 		this.father = father;
 	}
 
 	/***
 	 * Creates a new transaction.
 	 * 
 	 * @param uri
 	 *            the URI which represents the transaction. This URI has to have
 	 *            the same format as URIs returned with {@link #asURI()}.
 	 */
 	public Transaction(URI uri) {
 		try {
 			this.site = new URI(uri.getScheme() + "://" + uri.getAuthority());
 			String path = uri.getPath();
 			StringTokenizer st = new StringTokenizer(path, "/");
 			// ignore the first token. This is the word "transactions".
 			st.nextToken();
 			this.id = st.nextToken();
 		} catch (URISyntaxException e) {
 			throw new FatalException(e);
 		}
 	}
 
 	/***
 	 * Create a new Transaction.
 	 * 
 	 * @param id
 	 *            the unique identifier for the new transaction.
 	 * @param implicit
 	 *            indicates whether this transaction is an implicit transaction.
 	 */
 	public Transaction(String id, boolean implicit) {
 		this(id);
 		this.implicit = implicit;
 	}
 
 	/***
 	 * Adds an {@link Entry} to the list of modified Entries if it has not
 	 * already been added.
 	 * 
 	 * @param e
 	 *            the Entry to add.
 	 * @param cref
 	 *            the ContainerRef of the container where the entry was
 	 *            modified.
 	 */
 	public void addEntry(ContainerRef cref, Entry e) {
 		// if (!this.modifiedEntries.contains(e)) {
 		// this.modifiedEntries.add(e);
 		// }
 		// this.modifiedEntries.put(e.getId(), e);
 		TreeMap<String, Entry> map = this.modifiedEntries.get(cref);
 		if (map == null) {
 			map = new TreeMap<String, Entry>();
 			this.modifiedEntries.put(cref, map);
 		}
 		map.put(e.getId(), e);
 	}
 
 	/***
 	 * Returns an Array with all Entries which have been modified under this
 	 * Transaction in the Container with the given ContainerRef.
 	 * 
 	 * @param cref
 	 *            the ContainerRef of the Container from which the modified
 	 *            entries should be returned.
 	 * 
 	 * @return the Array with the Entries.
 	 */
 	public List<Entry> getModifiedEntries(ContainerRef cref) {
 		// return this.modifiedEntries;
 		// return new ArrayList<Entry>(this.modifiedEntries.values());
 		TreeMap<String, Entry> map = this.modifiedEntries.get(cref);
 		if (map == null) {
 			return new ArrayList<Entry>();
 		} else {
 			return new ArrayList<Entry>(map.values());
 		}
 	}
 
 	/***
 	 * Removes an Entry from the modified List of this Transaction.
 	 * 
 	 * @param cref
 	 *            the ContainerRef of the Container were the Entry should be
 	 *            removed from the modified list.
 	 * @param e
 	 *            the Entry that should be removed.
 	 */
 	public void removeEntry(ContainerRef cref, Entry e) {
 		TreeMap<String, Entry> map = this.modifiedEntries.get(cref);
 		if (map == null) {
 			return;
 		}
 		map.remove(e.getId());
 	}
 
 	/***
 	 * Add the Coordinator to the list of coordinators that have been used with
 	 * this transaction.
 	 * 
 	 * @param c
 	 *            the new coordinator.
 	 */
 	public void addCoordinator(ICoordinator c) {
 		if (!this.modifiedCoordinators.contains(c)) {
 			this.modifiedCoordinators.add(c);
 		}
 	}
 
 	/***
 	 * Get the coordinators of this Transaction.
 	 * 
 	 * @return the modifiedCoordinators
 	 */
 	public List<ICoordinator> getModifiedCoordinators() {
 		return modifiedCoordinators;
 	}
 
 	/***
 	 * Delete the coordinator from this Transaction.
 	 * 
 	 * @param coordinator
 	 *            the coordinator to remove.
 	 */
 	public void removeCoordinator(ICoordinator coordinator) {
 		this.modifiedCoordinators.remove(coordinator);
 	}
 
 	/***
 	 * Removes the cref from this transaction.
 	 * 
 	 * @param cref
 	 *            the cref to remove.
 	 */
 	public void removeContainerRef(ContainerRef cref) {
 		this.modifiedContainers.remove(cref);
 	}
 
 	/***
 	 * Adds a cref to the list of modified containers.
 	 * 
 	 * @param cref
 	 *            the cref to add.
 	 */
 	public void addContainerRef(ContainerRef cref) {
 		if (!this.modifiedContainers.contains(cref)) {
 			this.modifiedContainers.add(cref);
 		}
 	}
 
 	/***
 	 * Returs the list of modified containers.
 	 * 
 	 * @return the containerRefs.
 	 */
 	public List<ContainerRef> getModifiedContainers() {
 		// OPTIMIZE Can we avoid the copy?
 		return new ArrayList<ContainerRef>(this.modifiedContainers);
 	}
 
 	/***
 	 * Get the Identifier of this Transaction.
 	 * 
 	 * @return the id
 	 */
 	public String getId() {
 		return id;
 	}
 
 	/***
 	 * Get the boolean of this Transaction.
 	 * 
 	 * @return the implicit
 	 */
 	public boolean isImplicit() {
 		return implicit;
 	}
 
 	/***
 	 * Set the boolean of this Transaction.
 	 * 
 	 * @param implicit
 	 *            the implicit to set
 	 */
 	public void setImplicit(boolean implicit) {
 		this.implicit = implicit;
 	}
 
 	/***
 	 * Get the father of this Transaction.
 	 * 
 	 * @return the father
 	 */
 	public Transaction getFather() {
 		return father;
 	}
 
 	/***
 	 * Set the father of this Transaction.
 	 * 
 	 * @param father
 	 *            the father to set
 	 */
 	public void setFather(Transaction father) {
 		this.father = father;
 	}
 
 	/***
 	 * Determines whether this transaction can be used with tx. The method
 	 * returns true if this transaction is equals tx or tx is an ancestor of
 	 * this.
 	 * 
 	 * @param tx
 	 *            the transaction to check.
 	 * @return <code>true</code> if tx is equals to this or tx is an ancestor
 	 *         of this. Otherwise <code>false</code>
 	 */
 	public boolean canUse(Transaction tx) {
 		if (this.equals(tx)) {
 			return true;
 		}
 		if (this.father != null) {
 			return this.father.canUse(tx);
 		}
 		return false;
 	}
 
 	/***
 	 * Determines if this Transaction is an ancestor of the given on.
 	 * 
 	 * @param tx
 	 *            the transaction to determine wether this transaction is an
 	 *            ancestor of it or not.
 	 * @return true if it is an ancestor or it is the same transaction. false
 	 *         otherwise.
 	 */
 	public boolean isAncestorOf(Transaction tx) {
 		boolean ret = this.equals(tx);
 		if (!ret && tx.getFather() != null) {
 			return this.isAncestorOf(tx.getFather());
 		}
 		return ret;
 	}
 
 	/***
 	 * Get the timeout of this Transaction.
 	 * 
 	 * @return the timeout
 	 */
 	public long getTimeout() {
 		return timeout;
 	}
 
 	/***
 	 * Set the timeout of this Transaction.
 	 * 
 	 * @param timeout
 	 *            the timeout to set
 	 */
 	public void setTimeout(long timeout) {
 		this.timeout = timeout;
 	}
 
 	/***
 	 * Updates the timeout of this transaction.
 	 * 
 	 */
 	public void updateTimeout() {
 		if (this.timeout != ICapi.INFINITE_TIMEOUT) {
 			long now = System.currentTimeMillis();
 			this.timeout -= now - this.lastTimeoutUpdate;
 			this.lastTimeoutUpdate = now;
 		}
 	}
 
 	/***
 	 * Returns <code>true</code> if the timeout of this transactoin has been
 	 * expired.
 	 * 
 	 * @return <code>true</code> if the timeout of this transactoin has been
 	 *         expired
 	 */
 	public boolean timeoutExpired() {
 		return this.timeout != ICapi.INFINITE_TIMEOUT && this.timeout <= 0;
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public String toString() {
 		String s = "Transaction: " + this.id + " implicit: " + this.implicit;
 		if (this.father != null) {
 			Transaction tx = this.father;
 			while (tx.getFather() != null) {
 				tx = tx.getFather();
 			}
 			s += " Origin: " + tx.getId();
 		}
 		return s;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
 		result = prime * result + ((id == null) ? 0 : id.hashCode());
 		return result;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public boolean equals(Object obj) {
 		// FIXME: ist this enough? do we have to compare other values?
 		return (obj instanceof Transaction)
 				&& (this.id.equals(((Transaction) obj).getId()));
 	}
 
 	/***
 	 * @return the site
 	 */
 	public URI getSite() {
 		return site;
 	}
 
 	/***
 	 * Returns the URI representing this transaction. <br>
 	 * Format: <code>
 	 * 	&ltprotocol&gt://&lthost&gt:&ltport&gt/transactions/&ltidentifier&gt
 	 * </code>
 	 * 
 	 * @return the uri representation of this transaction
 	 */
 	public URI asURI() {
 		try {
 			if (this.getSite() != null) {
 				return new URI(this.getSite().toASCIIString()
 						+ "/transactions/" + this.id);
 			} else {
 				URI uri = TransportHandler.getInstance().getListener(
 						ConfigurationManager.getInstance().getStringSetting(
 								"DefaultAnswerToProtocol")).getUri();
 				return new URI(uri.toASCIIString() + "/transactions/" + this.id);
 			}
 		} catch (URISyntaxException e) {
 			throw new FatalException(e);
 		}
 	}
 
 	/***
 	 * @param site
 	 *            the site to set
 	 */
 	public void setSite(URI site) {
 		this.site = site;
 	}
 
 	public boolean isUnderRollback() {
 		return underRollback;
 	}
 
 	public void setUnderRollback(boolean underRollback) {
 		this.underRollback = underRollback;
 	}
 }