package org.xvsm.coordinators;
   
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   
   import org.xvsm.core.AtomicEntry;
   import org.xvsm.core.Entry;
  import org.xvsm.core.Tuple;
  import org.xvsm.core.Entry.EntryTypes;
  import org.xvsm.interfaces.IImplicitCoordinator;
  import org.xvsm.interfaces.container.IContainer;
  import org.xvsm.internal.exceptions.CannotShiftException;
  import org.xvsm.internal.exceptions.ContainerFullException;
  import org.xvsm.internal.exceptions.CountNotMetException;
  import org.xvsm.internal.exceptions.TransactionLockException;
  import org.xvsm.selectors.LindaSelector;
  import org.xvsm.selectors.Selector;
  import org.xvsm.transactions.Transaction;
  
  /***
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public class LindaCoordinator extends IImplicitCoordinator {
  
  	/***
  	 * The SerialVersionUID of this Class.
  	 */
  	private static final long serialVersionUID = 3867508050161659712L;
  
  	/***
  	 * The maximum size of the container where this LindaCoordinator belongs to.
  	 */
  	private int maxSize = 0;
  
  	/***
  	 * Contains all entries.
  	 */
  	private Map<String, Entry> entries = new HashMap<String, Entry>();
  
  	/***
  	 * Entries which have been deleted.
  	 */
  	private Map<Transaction, List<Entry>> deleted = new HashMap<Transaction, List<Entry>>();
  
  	/***
  	 * {@inheritDoc}.
  	 */
  	public void commit(Transaction tx) throws TransactionLockException {
  		deleted.remove(tx);
  		// super.commitEntryLocks(tx);
  	}
  
  	/***
  	 * {@inheritDoc}
  	 */
  	@Override
  	public void commitSubTransaction(Transaction tx) {
  		List<Entry> entries = this.deleted.get(tx);
  		if (entries != null) {
  			this.deleted.put(tx.getFather(), entries);
  		}
  	}
  
  	/***
  	 * {@inheritDoc}.
  	 */
  	public void delete(Transaction tx, Entry e) throws TransactionLockException {
  		List<Entry> dentries = this.deleted.get(tx);
  		if (dentries == null) {
  			dentries = new ArrayList<Entry>();
  			this.deleted.put(tx, dentries);
  		}
  		dentries.add(e);
  		// super.deleteLockEntry(e, tx);
  		this.entries.remove(e.getId());
  	}
  
  	/***
  	 * {@inheritDoc}.
  	 */
  	public Class<? extends Selector> getDefaultSelector() {
  		return LindaSelector.class;
  	}
  
  	/***
  	 * {@inheritDoc}.
  	 */
  	public List<Entry> read(Transaction tx, Selector selector,
  			List<Entry> centries) throws TransactionLockException,
  			CountNotMetException {
  		int count = selector.getCount();
  		LindaSelector ls = (LindaSelector) selector;
  
  		// If the amount of the given entries is smaller than
  		// the count of the selector, it cannot match.
  		List<Entry> allEntries = null;
 		if (centries == null) {
 			allEntries = new ArrayList<Entry>(this.entries.values());
 		} else {
 			allEntries = centries;
 		}
 		if (allEntries.size() < count) {
 			throw new CountNotMetException(
 					"There are not enoug matching entries.");
 		}
 
 		List<Entry> results = new ArrayList<Entry>();
 
 		for (Entry e : allEntries) {
 			if (this.matches(e, ls.getTemplate())) {
 				// try {
 				if (e.canBeRead(tx)) {
 					// super.readLockEntry(e, tx);
 					results.add(e);
 					if (results.size() == count) {
 						break;
 					}
 				}
 				// } catch (TransactionLockException e1) {
 				// // skip
 				// }
 			}
 		}
 
 		if (count != Selector.CNT_ALL && results.size() < count) {
 			throw new CountNotMetException(
 					"There are not enoug matching entries.");
 		}
 
 		return results;
 	}
 
 	/***
 	 * Tries to match the private template entry against the given one.
 	 * 
 	 * @param entry
 	 *            the entry against which the template tries to match.
 	 * @param tmpl
 	 *            the template on which the match is performed.
 	 * @return true if the template matches, false if not.
 	 */
 	private boolean matches(Entry entry, Entry tmpl) {
 		if (tmpl == null || tmpl.getEntryType() == null) {
 			return true;
 		}
 
 		// If the type of the template and the given entry is different, it
 		// cannot match.
 		if (tmpl.getEntryType() != entry.getEntryType()) {
 			return false;
 		}
 
 		// Both template and given entry are either of type AtomicEntry
 		if (tmpl.getEntryType() == EntryTypes.ATOMICENTRY) {
 			@SuppressWarnings("unchecked")
 			AtomicEntry<Object> t = (AtomicEntry<Object>) tmpl;
 			@SuppressWarnings("unchecked")
 			AtomicEntry<Object> e = (AtomicEntry<Object>) entry;
 
 			// If the valueClass of the template is different than the one of
 			// the given entry, it cannot match.
 			if (t.getValueClass() != e.getValueClass()) {
 				return false;
 			}
 
 			// Both template and given entry have the same value class.
 			// If the value in the template is set, the entry has to have the
 			// same value.
 			// If the value in the template is null, the value is no criterion
 			if (t.getValue() == null) {
 				return true;
 			}
 
 			// Since the value is a constrain, template and given entry have to
 			// have the same value.
 			if (t.getValue().equals(e.getValue())) {
 				return true;
 			}
 		}
 		// Both template and given entry are either of type Tuple
 		if (tmpl.getEntryType() == EntryTypes.TUPLE) {
 			@SuppressWarnings("unchecked")
 			Tuple t = (Tuple) tmpl;
 			@SuppressWarnings("unchecked")
 			Tuple e = (Tuple) entry;
 
 			// If the amount of entries inside a tuple is different, it cannot
 			// match.
 			if (t.size() != e.size()) {
 				return false;
 			}
 
 			boolean matches = true;
 			for (int i = 0; i < t.size(); i++) {
 				matches = this.matches(e.getEntryAt(i), t.getEntryAt(i));
 				if (!matches) {
 					return false;
 				}
 			}
 			return true;
 		}
 
 		// Logical unreachable code
 		return false;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public void rollback(Transaction tx) throws TransactionLockException {
 		List<Entry> dentries = this.deleted.get(tx);
 		if (dentries != null) {
 			for (Entry e : dentries) {
 				this.entries.put(e.getId(), e);
 			}
 		}
 		// OPTIMIZE: avoid the iteration over all entries!
 		for (Entry e : new ArrayList<Entry>(this.entries.values())) {
 			e.removeReadLock(tx);
 			if (e.removeOnRollback(tx)) {
 				this.entries.remove(e.getId());
 			}
 		}
 
 		this.deleted.remove(tx);
 		// super.rollbackEntryLocks(tx);
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public void setMaxContainerSize(int max) {
 		this.maxSize = max;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public Entry shift(Entry e, Transaction tx, Selector s)
 			throws TransactionLockException, CannotShiftException {
 		try {
 			this.write(e, tx, s);
 			// we did not shift anything
 			return null;
 		} catch (ContainerFullException e1) {
 			List<Entry> read;
 			try {
 				read = this.read(tx, s, null);
 			} catch (CountNotMetException e2) {
 				throw new CannotShiftException(
 						"Can not find an entry to shift.");
 			}
 			if (read == null || read.size() < 1) {
 				throw new CannotShiftException(
 						"Can not find an entry to shift.");
 			}
 			this.delete(tx, read.get(0));
 			try {
 				this.write(e, tx, s);
 			} catch (ContainerFullException e2) {
 				// TODO throw Fatal exception?
 				throw new CannotShiftException(
 						"Can not find an entry to shift.");
 			}
 			// super.deleteLockEntry(read.get(0), tx);
 			return read.get(0);
 		}
 
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public void write(Entry e, Transaction tx, Selector s)
 			throws ContainerFullException, TransactionLockException {
 		if (this.maxSize != IContainer.INFINITE_SIZE
 				&& this.entries.size() >= this.maxSize) {
 			throw new ContainerFullException();
 		}
 		// super.writeLockEntry(e, tx);
 		this.entries.put(e.getId(), e);
 	}
 
 }