/*
    * Copyright (c) 2005, The K-Wf Grid Consortium
    * Fraunhofer Institute for Computer Architecture and Software Technology
    * See http://www.kwfgrid.eu and http://www.first.fraunhofer.de for more details.
    */
   package net.kwfgrid.gwes.uiproxy;
   
   import java.util.*;
   
  /**
     An abstract buffer implementation to order messages with sequence numbers.
     Subclasses must implement <code>getSequenceNumber(message)</code> to access the sequence number of an incoming message.
     A <code>SequenceBuffer's</code> client must explicitly initialize the buffer by setting the <code>SequenceBuffer.first</code>
     property to the first valid sequence number. The buffer will not return any messages on <code>read()</code> before
     this property has been set.
     This buffer supports the following properties:
     <ul>
     <li>Buffer.size</li>
     <li>SequenceBuffer.first</li>
     </ul>
   */
  public abstract class SequenceBuffer extends AbstractBuffer {
      public static final String FIRST_PROPERTY_KEY = "SequenceBuffer.first";
  
      protected int _first;
      protected boolean _initialized;
      protected BufferException _exception;
      protected LinkedList _content, _precontent;
  
      public SequenceBuffer() {
  	super();
  	_first = -1;
  	_exception = null;
  	_initialized = false;
  	_precontent = new LinkedList();
  	_content = new LinkedList();
  	for (int i=0; i<getSize(); i++) _content.add(null); 
      }
  
      /**
         Generic method to access the sequence number of the specified message.
         Sequence numbers are expected to be positive integers.
       */
      protected abstract int getSequenceNumber(Object message) throws Exception;
      
      protected synchronized void setSize(int size) throws BufferException {
  	if (size>getSize()) {
  	    for (int i=_content.size(); i<size; i++) {
  		_content.add(null);
  	    }
  	} else if (size<getSize()) {
  	    for (int i=0; i<getSize()-size; i++) {
  		Object message = _content.removeLast();
  		if (message!=null) _exception = new BufferOverflowException(this);
  	    }	    
  	}
  	if (_exception!=null) throw _exception;
  	super.setSize(size);
      }
  
      protected synchronized void initialize(int first) throws BufferException {	
  	try {
  	    _first = first;
  	    Iterator messages = _precontent.iterator(); while(messages.hasNext()) {
  		Object message = messages.next();
  		int seq = getSequenceNumber(message);
  		if (seq-_first>=0) {
  		    _content.set(seq-_first, message);
  		}
  	    }
  	    _precontent.clear();
  	    _initialized = true;
  	} catch (Exception x) {
  	    _exception = new BufferException(this, "Exception getting sequence number.", x);
  	    throw _exception;
  	}
      }
  
      public synchronized void setProperty(String key, String value) throws BufferException {
  	if (FIRST_PROPERTY_KEY.equals(key)) {
  	    try {
  		int first = Integer.parseInt(value);
  		initialize(first);
  	    } catch (NumberFormatException x) {
  		_exception = new BufferException(this, "Exception getting sequence number.", x);
  		throw _exception;
  	    }	    
  	} else {
  	    super.setProperty(key, value);
  	}
      }
  
      public synchronized void handle(Object message) {
  	try {
  	    if (shouldHandle(message)) {
  		if (_exception==null) {
  		    if (!_initialized) {
  			if (_precontent.size()>=getSize()) _exception = new BufferOverflowException(this);
  			else _precontent.add(message);
 		    } else {
 			int seq = getSequenceNumber(message);
 			if (seq-_first>=getSize()) _exception = new BufferOverflowException(this);
 			else if (seq-_first<0) return; // discard old doubled messages
 			else _content.set(seq-_first, message);
 		    }
 		}
 	    }
 	} catch (Exception x) {
 	    _exception = new BufferException(this, "Exception getting sequence number.", x);
 	}
     }
 
     /**
        Determine if this buffer should handle the specified message.
        Subclasses must override this method in order to sort out messages of interest.
      */
     protected abstract boolean shouldHandle(Object message) throws Exception;
 
     /**
        Will always return messages in correct order. 
      */
     public synchronized Object[] read() throws BufferException {
 	if (_exception!=null) throw _exception;
 	if (!_initialized) return new Object[0];
 	List result = new LinkedList();
 	while (true) {
 	    if (_content.size()==0) break;
 	    Object message = _content.get(0);
 	    if (message==null) break;
 	    result.add(message);
 	    _content.removeFirst();
 	    _content.addLast(null);
 	    _first++;
 	}
 	return result.toArray();
     }
 }