package org.xvsm.coordinators;
   
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.List;
   import java.util.Random;
   
   import org.apache.log4j.Logger;
   import org.xvsm.core.Entry;
  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.TransactionLockException;
  import org.xvsm.selectors.Selector;
  import org.xvsm.selectors.VectorSelector;
  import org.xvsm.transactions.Transaction;
  
  /***
   * 
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public class VectorCoordinator extends IExplicitCoordinator {
  
  	private static Logger logger = Logger.getLogger(VectorCoordinator.class);
  	/***
  	 * The SerialVersionUID of this Class.
  	 */
  	private static final long serialVersionUID = -2474815951120951066L;
  
  	/***
  	 * Entries managed by this coordinator. They are stored in fifo order in
  	 * this list.
  	 */
  	private List<Entry> entries = new ArrayList<Entry>();
  
  	/***
  	 * The maximum size of the container where this VectorCoordinator belongs
  	 * to.
  	 */
  	private int maxSize;
  
  	/***
  	 * Default Constructor.
  	 */
  	public VectorCoordinator() {
  
  	}
  
  	/***
  	 * {@inheritDoc}
  	 */
  	@Override
  	public void commit(Transaction tx) throws TransactionLockException {
  
  		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 {
  		super.commitLocks(tx);
  	}
  
  	/***
  	 * {@inheritDoc}
  	 */
  	@Override
  	public void delete(Transaction tx, Entry e) throws TransactionLockException {
  		super.aquireLock(true, tx);
  		// super.deleteLockEntry(e, tx);
  		// TODO Auto-generated method stub
  
  	}
  
  	/***
  	 * {@inheritDoc}
  	 */
  	@Override
 	public List<Entry> read(Transaction tx, Selector selector,
 			List<Entry> centries) throws TransactionLockException,
 			CountNotMetException {
 		super.aquireLock(false, tx);
 		int index = ((VectorSelector) selector).getIndex();
 		if (index == VectorSelector.APPEND) {
 			index = 0;
 		}
 		int count = selector.getCount();
 
 		List<Entry> result = new ArrayList<Entry>();
 
 		if (centries == null) { // Operate on all entries
 
 			if (this.entries.size() < index + count) {
 				throw new CountNotMetException(
 						"Not enough matching entries in the container");
 			}
 
 			for (int i = index; i < this.entries.size(); i++) {
 				if (!this.entries.get(i).hasDeleteLock(tx)) {
 					// super.readLockEntry(this.entries.get(i), tx);
 					result.add(this.entries.get(i));
 					if (result.size() == count) {
 						break;
 					}
 				}
 			}
 
 			if (count != Selector.CNT_ALL && result.size() != count) {
 				throw new CountNotMetException(
 						"Not enough matching entries in the container");
 			}
 			if (logger.isDebugEnabled()) {
 				logger.debug("Read returns: " + result);
 				logger.debug("Entries: " + this.entries);
 			}
 			return result;
 		} else { // Operate on given entries
 			if (centries.size() < count) {
 				throw new CountNotMetException(
 						"Not enough matching entries in the container");
 			}
 
 			List<Integer> posEntries = new ArrayList<Integer>();
 			for (Entry e : centries) {
 				// OPTIMIZE
 				if (!e.hasDeleteLock(tx)) {
 					// Entry should never have a
 					// deleteLock. The Coordinator that
 					// was executed before should never
 					// have an entry with a deleteLock
 					// in its output.
 					int ind = this.entries.indexOf(e);
 					if (ind >= index) {
 						posEntries.add(ind);
 					}
 				}
 			}
 
 			if (!posEntries.contains(index)) {
 				throw new CountNotMetException(
 						"Not enough matching entries in the container");
 			}
 			Collections.sort(posEntries);
 
 			for (int i = 0; i < count; i++) {
 				if (posEntries.get(i) == null) {
 					throw new CountNotMetException(
 							"Not enough matching entries in the container");
 				}
 				if (posEntries.get(i) != (index + i)) {
 					throw new CountNotMetException(
 							"Not enough matching entries in the container");
 				}
 				// super.readLockEntry(this.entries.get(posEntries.get(i)), tx);
 				result.add(this.entries.get(posEntries.get(i)));
 			}
 
 			return result;
 		}
 
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	@Override
 	public void rollback(Transaction tx) throws TransactionLockException {
 		// the commented code does not work because we would jump over some
 		// entries ...
 		// for (int i = 0; i < this.entries.size(); i++) {
 		// Entry e = this.entries.get(i);
 		// if (e.hasWriteLock(tx)) {
 		// this.entries.remove(i);
 		// }
 		// }
 		// OPTIMIZE avoid the copy ... the code above does not work.
 		for (Entry e : new ArrayList<Entry>(this.entries)) {
 			if (e.hasWriteLock(tx)) {
 				this.entries.remove(e);
 			}
 		}
 		super.rollbackLocks(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 {
 		super.aquireLock(true, tx);
 		int index;
 		if (s == null) {
 			index = VectorSelector.APPEND;
 		} else {
 			index = ((VectorSelector) s).getIndex();
 		}
 
 		int shiftIndex = index;
 		Entry shifted = null;
 		if (this.entries.size() == this.maxSize) {
 			if (index == VectorSelector.APPEND) {
 				Random r = new Random();
 				shiftIndex = r.nextInt(this.entries.size());
 			}
 
 			shifted = this.entries.remove(shiftIndex);
 			// super.deleteLockEntry(shifted, tx);
 		}
 
 		// super.writeLockEntry(e, tx);
 		if (shiftIndex == VectorSelector.APPEND) {
 			this.entries.add(e);
 		} else {
 			this.entries.add(shiftIndex, e);
 		}
 
 		return shifted;
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	@Override
 	public void write(Entry e, Transaction tx, Selector s)
 			throws ContainerFullException, TransactionLockException {
 		super.aquireLock(true, tx);
 		int index;
 
 		if (s == null) {
 			index = VectorSelector.APPEND;
 		} else {
 			index = ((VectorSelector) s).getIndex();
 		}
 
 		// is there place left?
 		if (this.maxSize != IContainer.INFINITE_SIZE
 				&& this.entries.size() >= this.maxSize) {
 			throw new ContainerFullException();
 		}
 
 		// super.writeLockEntry(e, tx);
 		if (index == VectorSelector.APPEND) {
 			this.entries.add(e);
 		} else {
 			this.entries.add(index, e);
 		}
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public Class<? extends Selector> getDefaultSelector() {
 		return VectorSelector.class;
 	}
 
 }