import java.util.Iterator;
import java.util.Collection;
import java.util.Vector;

/**
 * <p>
 * Set of (static) helper routines to make writing agents easier.
 * </p>
 * @author     Michael Schuresko
 * @version    %I%, %G%
 * @since      1.1
*/
public class AgentMsgHelpers {

    public AgentMsgHelpers() { }

    /**
     * 
     * @param toDup iterator of communication links to duplicate
     * @return vector containing two copies of the iterator to
     * communication links.
     */
    public static Vector<Iterator<CommLink> > 
    duplicateLinks(Iterator<CommLink> toDup) {
    	return nDuplicateLinks(toDup, 2);
//    	Vector<Iterator<CommLink> > result = new Vector< Iterator<CommLink> >(2);
//    	Vector<CommLink> vec1 = new Vector<CommLink> ();
//    	Vector<CommLink> vec2 = new Vector<CommLink> ();
//    	while(toDup.hasNext()) {
//    		CommLink nextLink = toDup.next();
//    		vec1.add(nextLink);
//    		vec2.add(nextLink);
//    	}
//    	result.add(vec1.iterator());
//    	result.add(vec2.iterator());
//    	return result;
    	
    }
    
    /**
     * 
     * @param toDup iterator of communication links to duplicate
     * @param nCopies number of copies to make
     * @return vector containing two copies of the iterator to
     * communication links.
     */
    public static <T> Vector<Iterator<T> > 
    nDuplicateLinks(Iterator<T> toDup, int nCopies) {
    	Vector<Iterator<T> > result = new Vector< Iterator<T> >(nCopies);
    	Vector<T> vec1 = new Vector<T> ();
    	while(toDup.hasNext()) {
    		T nextLink = toDup.next();
    		vec1.add(nextLink);
    	}
    	result.add(vec1.iterator());
    	for(int i = 1; i < nCopies; ++i) {
    		result.add(vec1.iterator());
    	}
    	return result;
    	
    }

    
    /**
     * Accumulates all the readable messages from a list of channels.
     * @param iterChannels iterator for channels to read from
     * @param msgBag initially empty bag to put messages into
     */
    public static <T extends IMsg> Collection<T> accumMsgs(
    		Iterator<CommLink> iterChannels,
					     Collection<T> msgBag) 
    {
	while(iterChannels.hasNext()) {
	    CommLink currLink = iterChannels.next();
	    IMsg msg = currLink.queue().readMsg();
	    msgBag.add((T)msg);
	    
	}
	return msgBag;
    }
    
    public static <T1 extends IMsg, T2 extends IMsg>
    Collection<MsgPair<T1,T2>> 
    zipMsgs(Iterator<T1> l1, Iterator<T2> l2,
    		Collection<MsgPair<T1,T2>> bag) {
    	while(l1.hasNext() && l2.hasNext()) {
    		bag.add(new MsgPair<T1,T2>(l1.next(), l2.next()));
    	}
    	
    	return bag;
    }
    
    /*
     * 
     * @author mds
     *
     * @param <T1>
     * @param <T2>
     */
    public static class 
    MsgPair<T1 extends IMsg, T2 extends IMsg> implements IMsg
    {
    	T1 m_el1;
    	T2 m_el2;
    	
    	public MsgPair() {
    	}
    	
    	public MsgPair(T1 el1, T2 el2) {
    		m_el1 = el1; m_el2 = el2;
    	}
    	
    	public MsgPair<T1, T2> makeCopy() {
    		return new MsgPair(this.m_el1, this.m_el2);
    	}
    	
    	public MsgPair(MsgPair<T1,T2> src) {
    		m_el1 = src.m_el1; m_el2 = src.m_el2;
    	}
    	
    	public T1 getMsg1() { return m_el1; }
    	public T2 getMsg2() { return m_el2; }
    }
    
    public static class MsgFilter<T extends IMsg> implements Iterator<T> 
    {
	Iterator<T> m_baseIter;
	IFuncObj<T, Boolean> m_filter;
	T m_msgFirst;
	boolean m_bExhausted;
	
	public MsgFilter(IFuncObj<T, Boolean> filter,
			 Collection<T> msgBag) {
	    m_filter = filter;
	    m_baseIter = msgBag.iterator();
	    m_msgFirst = null;
	}

	void pumpQueue() 
	{
	    boolean bPumped = false;
	    while(m_baseIter.hasNext() && !bPumped) {
		m_msgFirst = (T)m_baseIter.next();
		Boolean bCurrVal = m_filter.doFunc(m_msgFirst);
		bPumped = bCurrVal.booleanValue();
	    }
	    if(!bPumped) {
		m_bExhausted = true;
	    }
	}

	public boolean hasNext() 
	{
	    try {
		if(m_msgFirst == null) {
		    pumpQueue();
		}
		return !m_bExhausted;
	    } catch(java.lang.ClassCastException e) {
		return false;
	    }	    
	}

	public T next() 
	{
	    try {
		if(m_bExhausted) {
		    return null;
		}
		if(m_msgFirst == null) {
		    pumpQueue();
		}
		T result = m_msgFirst;
		pumpQueue();
		return result;
		
	    } catch(java.lang.ClassCastException e) {
		return null;
	    }	    
	}

	/**
	 * unimplemented
	 */
	public void remove() {
	}
    }

    public static <T extends IMsg> Iterator<T> getFilteredMsgs(IFuncObj<T, Boolean> filter,
				   Collection<T> msgBag) {
	return new MsgFilter<T>(filter, msgBag);
    }

    public static <T extends IMsg> void 
    applyFunc(IFuncObj<T, Boolean> func, Iterator<T> iter) {
    	while(iter.hasNext()) {
    		func.doFunc(iter.next());
    	}
    }
    
    public int getCountMsg(IFuncObj<IMsg, Boolean> filter, Collection<IMsg> msgBag) {
    	Iterator<IMsg> iter = msgBag.iterator();
    	int nResult=0;
    	while(iter.hasNext()) {
    		IMsg currMsg = iter.next();
    		if(filter.doFunc(currMsg).booleanValue() == true) {
    			++nResult;
    		}
    	}
    	return nResult;
    }
    
    /**
     * Message class to hold a position in n dimensions
     * @author mds
     *
     */
    public static class PosMsg implements IMsg
    {
    	double m_arrLfPos[];
    	
    	public PosMsg() {
    		m_arrLfPos = new double[2]; // default to 2d
    	}
    	
    	public PosMsg(double [] arrLfPosArr, int nIdxStart, int nDim) {
    		m_arrLfPos = new double[nDim];
    		for(int i = 0; i < nDim; ++i) {
    			m_arrLfPos[i] = arrLfPosArr[nIdxStart+i];
    		}
    	}
    	
    	public PosMsg(PosMsg src) {
    		m_arrLfPos = new double[src.m_arrLfPos.length];
    		for(int i = 0; i < m_arrLfPos.length; ++i) {
    			m_arrLfPos[i] = src.m_arrLfPos[i];
    		}
    	}
    	
    	public PosMsg makeCopy() {
    		return new PosMsg(this);
    	}
    	
    	public double getDistSqrd(PosMsg posB) {
    		double lfSum = 0.0;
    		int nMax = Math.max(m_arrLfPos.length, posB.m_arrLfPos.length);
    		for(int i = 0; i < nMax; ++i) {
    			double lfTmp = m_arrLfPos[i] - posB.m_arrLfPos[i];
    			lfSum += lfTmp*lfTmp;
    		}
    		return lfSum;
    	}
    	
    	public double getDist(PosMsg posB) {
    		return Math.sqrt(getDistSqrd(posB));
    	}
    	
    	public double getPos(int i) {
    		return m_arrLfPos[i];
    	}
    	
    	public double [] getPosArrCpy() {
    		double [] arrLfOut = new double[m_arrLfPos.length];
    		for(int i = 0; i < m_arrLfPos.length; ++i) {
    			arrLfOut[i] = m_arrLfPos[i];
    		}
    		return arrLfOut;
    	}
    	
    	public void setPosArr(double [] arrLfPosArr, int nIdxStart, int nDim) {
    		m_arrLfPos = new double[nDim];
    		for(int i = 0; i < nDim; ++i) {
    			m_arrLfPos[i] = arrLfPosArr[nIdxStart+i];
    		}
    	}
    }
    
    /**
     * Empty message class.
     * @author mds
     *
     */
    public static class NullMsg implements IMsg
    {
    	public NullMsg makeCopy() {
    		return this; // no need to explicitly copy!!!
    	}
    }
    
    /**
     * Exists solely for testing purposes
     */
    public class MsgIntWrapper implements IMsg
    {
	public int m_nVal;

	public MsgIntWrapper(int n) { m_nVal = n; }
    
    public MsgIntWrapper makeCopy() {
    	return new MsgIntWrapper(m_nVal);
    }
    }

    /**
     * Exists solely for testing purposes
     */
    public class FindMatching implements IFuncObj<IMsg, Boolean>
    {
	int m_nValToMatch;
	
	public FindMatching(int nToMatch) {
	    m_nValToMatch = nToMatch;
	}

	public Boolean doFunc(IMsg in)
	{
	    MsgIntWrapper intMsg = 
		(MsgIntWrapper)in;
	    return new Boolean(intMsg.m_nVal == m_nValToMatch);
	}
    }

    /**
     * Helper for testing
     */
    void printContentsIterTest(Iterator<IMsg> iter) {
	String strOut = "[";
	if(!iter.hasNext()) {
	    strOut = strOut.concat("--empty--");
	}
	while(iter.hasNext()) {
	    IMsg msgNext = iter.next();
	    MsgIntWrapper intMsg = 
		(MsgIntWrapper)msgNext;
	    strOut = strOut.concat(" "+intMsg.m_nVal);
	}
	System.out.println(strOut+" ]");
    }


    
    
    /**
     * Exists solely for testing purposes
     */
    public boolean testFilters() {
	Vector<IMsg> collect = new Vector<IMsg>();
	for(int i = 0; i < 10; ++i) {
	    collect.add(i, new MsgIntWrapper(i));
	}

	IFuncObj<IMsg, Boolean> msgFindAll = 
	    new BoolFuncTrue<IMsg>();

	IFuncObj<IMsg, Boolean> msgFind0 = 
	    new FindMatching(0);

	IFuncObj<IMsg, Boolean> msgFind5 = 
	    new FindMatching(5);

	IFuncObj<IMsg, Boolean> msgFind8 = 
	    new FindMatching(8);

	IFuncObj<IMsg, Boolean> msgFind9 = 
	    new FindMatching(9);

	IFuncObj<IMsg, Boolean> msgFindAllBut25 = 
	    new BoolFuncAggregators.BoolFuncAnd<IMsg>
	    (
	     new BoolFuncAggregators.BoolFuncNegate<IMsg>(new FindMatching(2)),
	     new BoolFuncAggregators.BoolFuncNegate<IMsg>(new FindMatching(5))
	     );
	
	Iterator<IMsg> iter0 = getFilteredMsgs(msgFind0, collect);
	Iterator<IMsg> iter5 = getFilteredMsgs(msgFind5, collect);
	Iterator<IMsg> iter8 = getFilteredMsgs(msgFind8, collect);
	Iterator<IMsg> iter9 = getFilteredMsgs(msgFind9, collect);

	Iterator<IMsg> iterAll = getFilteredMsgs(msgFindAll, collect);

	Iterator<IMsg> iterNot25 = getFilteredMsgs(msgFindAllBut25, collect);

	boolean bResult = iter0.hasNext() &&
	    iter5.hasNext() &&
	    iter8.hasNext() &&
	    iter9.hasNext() &&
	    iterNot25.hasNext();

	System.out.println("Testing iter0");
	printContentsIterTest(iter0);

	System.out.println("Testing iter5");
	printContentsIterTest(iter5);

	System.out.println("Testing iter8");
	printContentsIterTest(iter8);

	System.out.println("Testing iter9");
	printContentsIterTest(iter9);

	System.out.println("Testing iterNot25");
	printContentsIterTest(iterNot25);

	System.out.println("Testing iterAll");
	printContentsIterTest(iterAll);

	bResult = bResult &&
	    !iter0.hasNext() &&
	    !iter5.hasNext() &&
	    !iter8.hasNext() &&
	    !iter9.hasNext() &&
	    !iterNot25.hasNext();

	return bResult;
    }
    
    public static class appendIter <T> implements Iterator<T> {
    	
    	Iterator<T> m_A, m_B;
    	
    	public appendIter(Iterator<T> A, Iterator<T> B) {
    		m_A = A; m_B = B;
    	}
    	
    	public boolean hasNext() {
    		if((m_A != null && m_A.hasNext()) || 
    				(m_B != null && m_B.hasNext())) {
    			return true;
    		}
    		return false;
    	}
    	
    	public T next() {
    		if(m_A != null && m_A.hasNext()) {
    			return m_A.next();
    		}
    		return m_B.next();
    	}
    	
    	/**
    	 * No clue what this method does -- leaving blank for now.
    	 */
    	public void remove() {
    		// I have no idea what to do here
    	}
    }


    public static class consIter <T> implements Iterator<T> {
    	
    	T m_A; boolean m_bAAvail;
    	Iterator<T> m_B;
    	
    	public consIter(T A, Iterator<T> B) {
    		m_A = A; m_B = B;
    		m_bAAvail = true;
    	}
    	
    	public boolean hasNext() {
    		if(m_bAAvail || 
    				(m_B != null && m_B.hasNext())) {
    			return true;
    		}
    		return false;
    	}
    	
    	public T next() {
    		if(m_bAAvail) {
    			m_bAAvail = false;
    			T tRes = m_A; m_A = null;
    			return tRes;
    		}
    		return m_B.next();
    	}
    	
    	/**
    	 * No clue what this method does -- leaving blank for now.
    	 */
    	public void remove() {
    		// I have no idea what to do here
    	}
    }
}