package org.xvsm.coordinators;
   
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.List;
   
   import org.apache.log4j.Logger;
   import org.xvsm.core.Entry;
   import org.xvsm.interfaces.IImplicitCoordinator;
  import org.xvsm.interfaces.container.IContainer;
  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.FifoSelector;
  import org.xvsm.selectors.Selector;
  import org.xvsm.transactions.Transaction;
  
  /***
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public class FifoCoordinator extends IImplicitCoordinator {
  
  	/***
  	 * The Logger for this Class.
  	 */
  	private static Logger logger = Logger.getLogger(FifoCoordinator.class);
  
  	/***
  	 * The SerialVersionUID of this class.
  	 */
  	private static final long serialVersionUID = -795071041584329339L;
  
  	/***
  	 * Entries managed by this coordinator. They are stored in fifo order in
  	 * this list.
  	 */
  	protected List<Entry> entries = new ArrayList<Entry>();
  
  	/***
  	 * The maximum size of the container where this FifoCoordinator belongs to.
  	 */
  	private int size;
  
  	/***
  	 * {@inheritDoc}.
  	 */
  	@Override
  	public void commit(Transaction tx) throws TransactionLockException {
  		if (logger.isDebugEnabled()) {
  			logger
  					.debug("commit() transaction: " + tx + " modified "
  							+ tx.getModifiedEntries(this.getCref()).size()
  							+ " entries");
  			for (Entry e : tx.getModifiedEntries(this.getCref())) {
  				logger.debug("commit() entry: " + e + " hasDeleteLock? "
  						+ e.hasDeleteLock(tx));
  			}
  		}
  		for (Entry e : tx.getModifiedEntries(this.getCref())) {
  			if (e.hasDeleteLock(tx)) {
  				if (logger.isDebugEnabled()) {
  					logger.debug("commit() remove entry: " + e);
  				}
  				// remove the entries which are masked as removed under this tx.
  				// OPTIMIZE remove(Object) Runtime
  				this.entries.remove(e);
  			}
  		}
  		super.commitLocks(tx);
  	}
  
  	/***
  	 * {@inheritDoc}
  	 * 
  	 * @throws TransactionLockException
  	 */
  	@Override
  	public void commitSubTransaction(Transaction tx)
  			throws TransactionLockException {
  		if (logger.isDebugEnabled()) {
  			logger.debug("commitSubTransaction() " + tx);
  		}
  		super.commitLocks(tx);
  		// logger.debug("Entries: " + this.entries);
  	}
  
  	/***
  	 * {@inheritDoc}.
  	 */
  	@Override
  	public void delete(Transaction tx, Entry e) throws TransactionLockException {
  		// super.deleteLockEntry(e, tx);
  
  	}
  
  	/***
  	 * {@inheritDoc}.
 	 */
 	@Override
 	public List<Entry> read(Transaction tx, Selector selector,
 			List<Entry> centries) throws TransactionLockException,
 			CountNotMetException {
 		this.aquireLock(false, tx);
 
 		if (centries == null) { // Operate on all entries
 			if (this.entries.size() < selector.getCount()) {
 				// this.readLocks.remove(tx.getId());
 				throw new CountNotMetException(
 						"Not enough matching entries in the fifo container. needed:"
 								+ selector.getCount() + " available "
 								+ this.entries.size());
 
 			}
 
 			// Filter those entries with deleteLocks
 			List<Entry> ourEntries = new ArrayList<Entry>();
 			for (Entry e : this.entries) {
 				if (e.canBeRead(tx)) {
 					// mark the entry as read
 					// super.readLockEntry(e, tx);
 
 					ourEntries.add(e);
 				}
 				if (selector.getCount() != Selector.CNT_ALL) {
 					if (ourEntries.size() == selector.getCount()) {
 						// We have all entries that we need
 						break;
 					}
 				}
 			}
 
 			if (ourEntries.size() < selector.getCount()) {
 				throw new CountNotMetException(
 						"Not enough matching entries in the container. Needed "
 								+ selector.getCount() + " but only have "
 								+ ourEntries.size());
 			}
 			if (logger.isDebugEnabled()) {
 				logger.debug("Read returns: " + ourEntries);
 			}
 			return ourEntries;
 
 		} else { // Operate on given entries only
 			if (centries.size() < selector.getCount()) {
 				throw new CountNotMetException(
 						"Not enough matching entries in the fifo container");
 			}
 
 			List<Integer> posEntries = new ArrayList<Integer>();
 			for (Entry e : centries) {
 				if (e.canBeRead(tx)) {
 					// Entry should never have a
 					// deleteLock. The Coordinator that
 					// was executed before should never
 					// have an entry with a deleteLock
 					// in its output.
 					posEntries.add(this.entries.indexOf(e));
 				}
 			}
 			Collections.sort(posEntries);
 			List<Entry> result = new ArrayList<Entry>();
 			int count = 0;
 			for (Integer pos : posEntries) {
 				result.add(this.entries.get(pos));
 				count++;
 				if (count == selector.getCount()) {
 					// Count of matching entries achieved.
 					break;
 				}
 
 			}
 			return result;
 		}
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public void rollback(Transaction tx) throws TransactionLockException {
 
 		// OPTIMIZE the code above does not work and this one is not fast.
 		for (Entry e : new ArrayList<Entry>(this.entries)) {
 			// remove the entries which have been written under tx.
 			if (e != null && e.removeOnRollback(tx)) {
 				if (tx.getFather() != null) {
 					// nothing to do
 				} else {
 					this.entries.remove(e);
 				}
 			}
 		}
 		super.rollbackLocks(tx);
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public void setMaxContainerSize(int maxSize) {
 		this.size = maxSize;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public Entry shift(Entry e, Transaction tx, Selector s)
 			throws TransactionLockException {
 
 		this.aquireLock(true, tx);
 
 		Entry shifted = null;
 
 		if (this.size != IContainer.INFINITE_SIZE
 				&& this.entries.size() >= this.size) {
 			// search for an entry to remove
 			for (int i = 0; i < this.entries.size(); i++) {
 				// shift the oldest entry
 				shifted = this.entries.get(i);
 
 				// TODO: has the entry been created by another transaction?
 				Transaction dlock = shifted.getDeleteLock();
 				if (dlock != null) {
 					if (dlock.equals(tx)) {
 						// entries which have a delete lock from the same tx
 						// have to be skipped.
 						continue;
 					} else {
 						// the entry has been removed by another tx.
 						throw new TransactionLockException(dlock);
 					}
 				}
 				// remove the oldest entry which has not been marked by another
 				// tx.
 				// super.deleteLockEntry(this.entries.get(i), tx);
 				this.entries.remove(i);
 				break;
 			}
 		}
 
 		try {
 			this.write(e, tx, s);
 		} catch (ContainerFullException e1) {
 			// can not happen
 			throw new FatalException();
 		}
 
 		return shifted;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public void write(Entry e, Transaction tx, Selector s)
 			throws ContainerFullException, TransactionLockException {
 		this.aquireLock(true, tx);
 		// super.writeLockEntry(e, tx);
 		this.entries.add(e);
 		if (logger.isDebugEnabled()) {
 			logger.debug(this.entries);
 		}
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public Class<? extends Selector> getDefaultSelector() {
 		return FifoSelector.class;
 	}
 
 }