package org.xvsm.coordinators;
   
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   import java.util.Properties;
   import java.util.Set;
   
  import org.apache.log4j.Logger;
  import org.xvsm.core.AtomicEntry;
  import org.xvsm.core.Entry;
  import org.xvsm.core.Tuple;
  import org.xvsm.interfaces.IExplicitCoordinator;
  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.FatalException;
  import org.xvsm.internal.exceptions.TransactionLockException;
  import org.xvsm.selectors.LabelSelector;
  import org.xvsm.selectors.Selector;
  import org.xvsm.transactions.Transaction;
  
  /***
   * 
   * @version 1 created 12.03.2008
   * @author robby
   * 
   */
  // TODO LabelCoordinator and KeyCoordinator share a lot of code. Perhaps it can
  // be refactored to be better maintainable.
  public class LabelCoordinator extends IExplicitCoordinator {
  
  	/***
  	 * The logger.
  	 */
  	private static Logger logger = Logger.getLogger(LabelCoordinator.class);
  
  	/***
  	 * The SerialVersionUID of this Class.
  	 */
  	private static final long serialVersionUID = 3027037571449489139L;
  
  	/***
  	 * Contains all entries which have been written with a KeySelector. (old)
  	 * unique Key: only one entry for one key String name of Key , Map (key ,
  	 * entry) (new) -> MultiKeys : String name of Key , Map (key , List(entry))
  	 * 
  	 */
  	private MultiMapList<String, Object, Entry> entries = new MultiMapList<String, Object, Entry>();
  
  	/***
  	 * The maximum size of the container where this KeyCoordinator belongs to.
  	 */
  	private int maxSize;
  
  	/***
  	 * The amount of entries currently managed by this coordinator.
  	 */
  	private int currentSize;
  
  	/***
  	 * Contains entries and selectors which have been deleted. This information
  	 * is necessary to rollback a transaction.
  	 */
  	private MultiMapList<Transaction, Entry, LabelSelector> deletedEntries = new MultiMapList<Transaction, Entry, LabelSelector>();
  
  	/***
  	 * We need to store which entry has been written with which selector.
  	 * Otherwise we need to iterate over all entries on delete.
  	 */
  	private MultiMap<Entry, LabelSelector> reverseMap = new MultiMap<Entry, LabelSelector>();
  
  	private Map<String, Class> typeMap = new HashMap<String, Class>();
  
  	public static class KeyType {
  		public String keyName;
  		public Class keyType;
  
  		public KeyType(String keyName, Class keyType) {
  			this.keyName = keyName;
  			this.keyType = keyType;
  		}
  	}
  
  	/***
  	 * Default Constructor.
  	 * 
  	 */
  	public LabelCoordinator() {
  	}
  
  	public LabelCoordinator(KeyType... keyTypes) {
  		for (KeyType kt : keyTypes) {
  			this.typeMap.put(kt.keyName, kt.keyType);
  		}
  	}
  
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public void commit(Transaction tx) throws TransactionLockException {
 		// remove the information about the deleted entries.
 		this.deletedEntries.removeAll(tx);
 	}
 
 	/***
 	 * {@inheritDoc}
 	 * 
 	 * @throws TransactionLockException
 	 * 
 	 * @Override
 	 * 
 	 */
 	@Override
 	public void commitSubTransaction(Transaction tx)
 			throws TransactionLockException {
 
 		/*
 		 * for keySelector Map<Entry, KeySelector> deletedUnderChildTx =
 		 * deletedEntries.get(tx); if (deletedUnderChildTx != null) {
 		 * deletedEntries.put(tx.getFather(), deletedUnderChildTx); }
 		 */
 
 		MultiMap<Entry, LabelSelector> deletedUnderChildTx = deletedEntries
 				.get(tx);
 		if (deletedUnderChildTx != null) {
 			deletedEntries.add(tx.getFather(), deletedUnderChildTx);
 		}
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public void delete(Transaction tx, Entry e) throws TransactionLockException {
 		LabelSelector ks = this.reverseMap.getFirst(e);
 		if (logger.isDebugEnabled()) {
 			logger.debug("delete KeySelector: " + ks);
 		}
 		if (ks != null) {
 			this.delete(tx, e, ks);
 		}
 	}
 
 	/***
 	 * Removes the entry with a specific key. It stores it in
 	 * this.deletedEntries for rollback.
 	 * 
 	 * @param e
 	 *            the entry to remove
 	 * @param ks
 	 *            the selector for the entry.
 	 * @param tx
 	 *            the Transaction.
 	 */
 	public void delete(Transaction tx, Entry e, LabelSelector ks) {
 		if (this.entries.remove(ks.getKeyName(), ks.getKeyValue(), e) == null) {
 			return; // nothing removed
 		}
 		this.currentSize--;
 		this.reverseMap.remove(e, ks);
 		deletedEntries.add(tx, e, ks);
 		// super.deleteLockEntry(e, tx);??
 
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 * 
 	 * Read {@link Entry}s that match with the Selector.
 	 * 
 	 * @param selector
 	 *            The Selector that must match.
 	 * @param tx
 	 *            A Transaction under which the operation executes
 	 * @param centries
 	 *            A {@link List} of {@link Entry}s to operate on. Null if it
 	 *            should operates on all known entries.
 	 * @throws CountNotMetException
 	 *             thrown if there are not enough entries to fulfill the count
 	 *             of the selector.
 	 * @throws TransactionLockException
 	 *             thrown if a lock can not be aquired because another
 	 *             transaction uses it.
 	 * @return a List of all matching entries.
 	 */
 	@Override
 	public List<Entry> read(Transaction tx, Selector selector,
 			List<Entry> centries) throws TransactionLockException,
 			CountNotMetException {
 		LabelSelector<?> ks = (LabelSelector<?>) selector;
 		int count = selector.getCount();
 
 		List<Entry> allEntries = null;
 		if (centries == null) {
 			allEntries = this.entries.get(ks.getKeyName(), ks.getKeyValue());
 		} else {
 			allEntries = this.getIntersection(this.entries.get(ks.getKeyName(),
 					ks.getKeyValue()), centries);
 			// System.out.println("allEntries:" + allEntries.size());
 		}
 		// If the amount of the given entries is smaller than
 		// the count of the selector, it cannot match.
 		if (allEntries == null || allEntries.size() == 0) {
 			throw new CountNotMetException("No matching entries with "
 					+ ks.getKeyName() + " : " + ks.getKeyValue() + "!");
 		}
 
 		List<Entry> retVal;
 		if (count == Selector.CNT_ALL) {
 			retVal = allEntries;
 		} else {
 			retVal = new ArrayList<Entry>();
 			for (Entry e : allEntries) {
 				if (e.canBeRead(tx) && retVal.size() < count) {
 					retVal.add(e);
 				}
 			}
 		}
 		if (count != Selector.CNT_ALL && retVal.size() < count) {
 			throw new CountNotMetException(
 					"There are not enough matching entries.");
 		}
 		return retVal;
 	}
 
 	/***
 	 * Gets list of elements, which are in both lists.
 	 * 
 	 * @param a
 	 *            list a
 	 * @param b
 	 *            list b
 	 * @return intersection list
 	 * 
 	 */
 	private List<Entry> getIntersection(List<Entry> a, List<Entry> b) {
 		List<Entry> inter = new ArrayList<Entry>();
 		for (Entry entA : a) {
 			if (b.contains(entA)) {
 				inter.add(entA);
 			}
 		}
 		return inter;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public void rollback(Transaction tx) throws TransactionLockException {
 		// remove entries which have been written under tx:
 		for (Entry e : tx.getModifiedEntries(this.getCref())) {
 			// TODO rollback written values
 			// ???? entry with which keyselector ??
 			List<LabelSelector> ls = this.reverseMap.get(e);
 			if (ls != null) {
 				for (LabelSelector ks : ls) {
 					if (ks != null) {
 						// TODO Avoid the creation of the copy
 						// (currently CuncurrentModifictionException is thrown
 						// if
 						// the list is not copied
 						for (Entry entry : new ArrayList<Entry>(this.entries
 								.get(ks.getKeyName(), ks.getKeyValue()))) {
 							if (entry.removeOnRollback(tx)) {
 								entries.remove(ks.getKeyName(), ks
 										.getKeyValue(), e);
 							}
 						}
 					}
 				}
 			}
 		}
 
 		// write entries which have been deleted under tx:
 		MultiMap<Entry, LabelSelector> deleted = this.deletedEntries.get(tx);
 		if (deleted != null) {
 			for (Entry delEntry : deleted.keySet()) {
 				if (delEntry.addOnRollback(tx)) {
 					List<LabelSelector> ksList = deleted.get(delEntry);
 					for (LabelSelector ksDel : ksList) {
 						this.entries.add(ksDel.getKeyName(), ksDel
 								.getKeyValue(), delEntry);
 						this.currentSize++;
 					}
 				}
 			}
 		}
 
 		deletedEntries.removeAll(tx);
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public void setMaxContainerSize(int size) {
 		this.maxSize = size;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public Entry shift(Entry e, Transaction tx, Selector s)
 			throws TransactionLockException, CannotShiftException {
 
 		LabelSelector<?> ks = (LabelSelector<?>) s;
 
 		if (!this.typeMap.containsKey(ks.getKeyName())) {
 			throw new FatalException(ks.getKeyName() + " does not exist");
 		}
 
 		Entry shifted = null;
 		if (this.currentSize >= this.maxSize
 				&& this.maxSize != IContainer.INFINITE_SIZE) {
 			shifted = shiftRemove(ks, e);
 			this.deletedEntries.add(tx, shifted, ks);
 		} else {
 			this.currentSize++;
 		}
 
 		// store the new entry.
 		this.entries.add(ks.getKeyName(), ks.getKeyValue(), e);
 		this.reverseMap.add(e, ks);
 		return shifted;
 	}
 
 	/***
 	 * Removes an entry.
 	 * 
 	 * Shift Remove Strategie: first try: remove equal entry second try: remove
 	 * entry with same key, value third try: remove entry with same key last
 	 * try: remove a element
 	 * 
 	 * @param ks -
 	 *            actual KeySelector
 	 * @param e -
 	 *            actual Entry
 	 * 
 	 * @return removed Entry
 	 * 
 	 */
 	private Entry shiftRemove(LabelSelector<?> ks, Entry e) {
 		Entry shifted = null;
 		// remove one value for SHIFT
 		// first, try to remove an equal element.
 		shifted = entries.remove(ks.getKeyName(), ks.getKeyValue(), e);
 		if (shifted != null) { // Is an entry removed?
 			return shifted;
 		}
 		// exists entries with equal key and value
 		List<Entry> entryList = this.entries.get(ks.getKeyName(), ks
 				.getKeyValue());
 		if (entryList != null) {
 			return entryList.remove(0);
 		}
 		// exists entries with equal key
 		MultiMap<Object, Entry> mMap = this.entries.get(ks.getKeyName());
 		if (mMap != null) {
 
 			// remove first Element of MultiMap
 			return mMap.removeFirst();
 		}
 		return removeFirstEntry();
 	}
 
 	/***
 	 * Deletes a first Entry in Entry list.
 	 * 
 	 * @return - deleted entry.
 	 * 
 	 */
 	private Entry removeFirstEntry() {
 		Entry delEntry = null;
 		// take an element and delete it
 		for (String keyName : entries.keySet()) {
 			MultiMap<Object, Entry> mMap = entries.get(keyName);
 			Set<Object> keyValList = mMap.keySet();
 			for (Object keyVal : keyValList) {
 				delEntry = mMap.getFirst(keyVal);
 				entries.remove(keyName, keyVal, delEntry);
 
 			}
 		}
 		return delEntry;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public void write(Entry e, Transaction tx, Selector s)
 			throws ContainerFullException, TransactionLockException {
 
 		LabelSelector ks = (LabelSelector) s;
 		if (!this.typeMap.containsKey(ks.getKeyName())) {
 			throw new FatalException(ks.getKeyName() + " does not exist");
 		}
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("LabelSelector: " + ks);
 		}
 
 		// is there place left?
 		if (this.currentSize == this.maxSize
 				&& this.maxSize != IContainer.INFINITE_SIZE) {
 			throw new ContainerFullException();
 		}
 
 		this.entries.add(ks.getKeyName(), ks.getKeyValue(), e);
 		this.reverseMap.add(e, ks);
 
 		this.currentSize++;
 	}
 
 	/***
 	 * 
 	 * 
 	 * 
 	 */
 	public void printEntries() {
 		this.entries.printMap();
 	}
 
 	/***
 	 * Prints list on Standard OutputStream.
 	 * 
 	 * @param list -
 	 *            list of entries to print
 	 * 
 	 */
 	public void printList(List<Entry> list) {
 		System.out.println(" list:");
 		if (list == null) {
 			return;
 		}
 		for (Entry a : list) {
 			System.out.print(((AtomicEntry) a).getValue());
 		}
 		System.out.println();
 
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 * 
 	 * @Override
 	 * 
 	 */
 	@Override
 	public Class<? extends Selector> getDefaultSelector() {
 		return LabelSelector.class;
 	}
 
 	@Override
 	public Properties getProperties() {
 		Tuple t = new Tuple();
 		for (String keyname : this.typeMap.keySet()) {
 			t.add(new Tuple(new AtomicEntry<String>(keyname),
 					new AtomicEntry<String>(typeMap.get(keyname)
 							.getSimpleName().toLowerCase())));
 		}
 		this.properties.put("keys", t);
 		return this.properties;
 	}
 
 	@Override
 	public void setProperties(Properties properties) {
 		try {
 			Tuple keys = (Tuple) properties.get("keys");
 			for (Entry e : keys) {
 				Tuple t = (Tuple) e;
 				String keyName = (String) ((AtomicEntry<?>) t.getEntryAt(0))
 						.getValue();
 
 				String keyType = (String) ((AtomicEntry<?>) t.getEntryAt(1))
 						.getValue();
 
 				Class<?> c = Class.forName("java.lang."
 						+ keyType.substring(0, 1).toUpperCase()
 						+ keyType.substring(1, keyType.length()));
 
 				this.typeMap.put(keyName, c);
 			}
 		} catch (ClassNotFoundException e) {
 			throw new FatalException(e);
 		}
 	}
 }