import java.util.Iterator;
import java.util.Vector;
import Jama.Matrix;

public class BcastStorage implements IPosBcast {

	int m_nNumAgents;
	int m_nDim;
	
	int m_nAgentId;
	
	boolean m_arrPosValid[];
	boolean m_arrInfoSent[];
	double m_arrLfLastTime[];
	double m_arrLfPosArr[];
	
	
	int m_nNumValid;
	
	
	public BcastStorage() {
		m_nNumAgents = 1;
		m_nDim = 2;
		initialize();
	}
	
	public BcastStorage(int nAgents) {
		m_nNumAgents = nAgents;
		m_nDim = 2;
		initialize();
	}
	
	public BcastStorage(BcastStorage src) {
		copyMe(src);
	}
	
	public int getDim() { return m_nDim; }
	
	void copyMe(BcastStorage src) {
		m_nNumAgents = src.m_nNumAgents;
		m_nDim = src.m_nDim;
		m_arrPosValid = new boolean[m_nNumAgents];
		m_arrLfLastTime = new double[m_nNumAgents];
		m_arrLfPosArr = new double[m_nDim*m_nNumAgents];
		m_arrInfoSent = new boolean[m_nNumAgents];
		m_nNumValid = src.m_nNumValid;
		
		m_nAgentId = src.m_nAgentId;
		
		for(int i = 0; i < m_nNumAgents; ++i) {
			m_arrPosValid[i] = src.m_arrPosValid[i];
			m_arrLfLastTime[i] = src.m_arrLfLastTime[i];
			m_arrInfoSent[i] = src.m_arrInfoSent[i];
			for(int j = i*m_nDim; j < (i+1)*m_nDim; ++j) {
				m_arrLfPosArr[j] = src.m_arrLfPosArr[j];
			}
		}
	}
	
	void initialize() {
		
		m_arrPosValid = new boolean[m_nNumAgents];
		m_arrLfLastTime = new double[m_nNumAgents];
		m_arrLfPosArr = new double[m_nDim*m_nNumAgents];
		m_arrInfoSent = new boolean[m_nNumAgents];
		m_nNumValid = 0;
	}
	
	/**
	 * Does nothing, for the time being.
	 */
	public void init() {
		// do nothing for the time being
	}
	
	public void reset(int nAgents, int nDim) {
		m_nDim = nDim; m_nNumAgents = nAgents;
		initialize();
	}
	
	public boolean haveInfo(int nAgent) {
		return m_arrPosValid[nAgent];
	}
	
	public double getLastTime(int nAgent) {
		return m_arrLfLastTime[nAgent];
	}

	public double[] getPos(int nAgent) {
		double [] arrLfOut = new double[m_nDim];
		for(int i = 0; i < m_nDim; ++i) {
			arrLfOut[i] = m_arrLfPosArr[m_nDim*nAgent+i];
		}
		return arrLfOut;
	}
	
	public void forceUpdate(int nId, double [] arrLfPos, double lfTime) {
		for(int i = 0; i < m_nDim; ++i) {
			if(nId != 0 && arrLfPos[i] == 0.0) {
				System.out.println("Something funny");
			}
			m_arrLfPosArr[m_nDim*nId+i] = arrLfPos[i];
		}
		m_arrLfLastTime[nId] = lfTime;
		m_arrInfoSent[nId] = false;
		if(m_arrPosValid[nId] == false) {
			m_nNumValid = m_nNumValid+1;
		}
		m_arrPosValid[nId] = true;
	}
	
	/**
	 * Returns true if the information on each agent is valid, false otherwise
	 * @return true if we have info for every agent 
	 */
	public boolean haveAllInfo() {
		return (m_nNumValid >= m_nNumAgents);
	}
	
	/**
	 * Gets number of agents in swarm
	 * @return number of agents
	 */
	public int getNumAgents() {
		return m_nNumAgents;
	}
	
	public IPosBcast.IPosBcastMsg getMsg() {
		if(m_arrInfoSent[m_nAgentId] == true || m_arrPosValid[m_nAgentId] == false) {
			return null;
		}
		int nId = (int)Math.floor(m_nNumAgents*Math.random());
		while(m_arrInfoSent[nId] != false || m_arrPosValid[nId] != true) {
			nId = (int)Math.floor(m_nNumAgents*Math.random());
		}
		m_arrInfoSent[nId] = true;
		return new BcastStorageMsgCompound(this, nId, m_nAgentId);
	}

	public static class BcastStorageMsg implements IPosBcast.IPosBcastMsg {
		
		double m_lfTime;
		double [] m_arrLfPos;
		int m_nDim;
		int m_nIdToSend;
		
		public BcastStorageMsg() {
			m_nDim = 2;
			initialize();
		}
		
		public BcastStorageMsg(BcastStorage storage, int nIdToSend) {
			m_nDim = storage.m_nDim;
			m_nIdToSend = nIdToSend;
			initialize();
			m_lfTime = storage.getLastTime(nIdToSend);
			m_arrLfPos = storage.getPos(nIdToSend);
			if(m_arrLfPos[0] == 0.0 && nIdToSend != 0) {
				System.out.println("Odd");
			}
		}
		
		public BcastStorageMsg(BcastStorageMsg storageMsg) {
			m_nDim = storageMsg.m_nDim;
			m_nIdToSend = storageMsg.m_nIdToSend;
			m_lfTime = storageMsg.m_lfTime;
			m_arrLfPos = new double[storageMsg.m_arrLfPos.length];
			for(int i = 0; i < m_arrLfPos.length; ++i) {
				m_arrLfPos[i] = storageMsg.m_arrLfPos[i];
			}
		}

		public BcastStorageMsg makeCopy() {
			return new BcastStorageMsg(this);
		}
		
		void initialize() {
			m_arrLfPos = new double[m_nDim];
		}
		
		public int getNumEntries() { return 1; }
		
		public double getTime(int nEntry) {
			return m_lfTime;
		}
		
		public double [] getPos(int nEntry) {
			double [] arrLfOut = new double[2];
			arrLfOut[0] = m_arrLfPos[0];
			arrLfOut[1] = m_arrLfPos[1];
			return arrLfOut;
		}
		
		public Boolean getBoolVar(Object refObject) {
			return null;
		}

		public int getId(int nEntry) {
			return m_nIdToSend;
		}

		public Integer getIntVar(Object refObject) {
			// TODO Auto-generated method stub
			return null;
		}
		
		/**
	     * Removes any values indexed by refObject
	     * @param refObject remove values associated with this.
	     */
	    public void removeVar(Object refObject) 
	    {
	    	return;
	    }

		public boolean insertBoolVar(Object refObject, boolean bValue) {
			// TODO Auto-generated method stub
			return false;
		}

		public boolean insertIntVar(Object refObject, int nValue) {
			// TODO Auto-generated method stub
			return false;
		}

	}
	
public static class BcastStorageMsgCompound implements IPosBcast.IPosBcastMsg {
		
		Vector<BcastStorageMsg> m_vecMsg;
		int m_nDim;
		
		public BcastStorageMsgCompound() {
			m_nDim = 2;
		}

		public BcastStorageMsgCompound(BcastStorageMsgCompound src) {
			m_nDim = src.m_nDim;
			m_vecMsg = new Vector<BcastStorageMsg>(src.m_vecMsg.size());
			Iterator<BcastStorageMsg> iter = src.m_vecMsg.iterator();
			while(iter.hasNext()) {
				m_vecMsg.add(iter.next().makeCopy());
			}
		}
		
		public BcastStorageMsgCompound(BcastStorage storage, int nIdToSend, int nMyId) {
			m_nDim = storage.m_nDim;
			BcastStorageMsg msg1 = new BcastStorageMsg(storage, nIdToSend);
			BcastStorageMsg msg2 = new BcastStorageMsg(storage, nMyId);
			m_vecMsg = new Vector<BcastStorageMsg>(2);
			m_vecMsg.add(msg1);
			m_vecMsg.add(msg2);
		}
		
		public BcastStorageMsgCompound makeCopy() {
			return new BcastStorageMsgCompound(this);
		}
		
		public int getNumEntries() { return m_vecMsg.size(); }
		
		public double getTime(int nEntry) {
			return m_vecMsg.get(nEntry).getTime(0);
		}
		
		public double [] getPos(int nEntry) {
			return m_vecMsg.get(nEntry).getPos(0);
		}
		
		public Boolean getBoolVar(Object refObject) {
			return null;
		}

		public int getId(int nEntry) {
			return m_vecMsg.get(nEntry).getId(0);
		}

		public Integer getIntVar(Object refObject) {
			// TODO Auto-generated method stub
			return null;
		}

		public boolean insertBoolVar(Object refObject, boolean bValue) {
			// TODO Auto-generated method stub
			return false;
		}

		public boolean insertIntVar(Object refObject, int nValue) {
			// TODO Auto-generated method stub
			return false;
		}

	}
	
	public ILogicVarBundle makeCopy() {
		return new BcastStorage(this);
	}

	public void setId(int nId) {
		m_nAgentId = nId;

	}
	
	/**
     * gets an Integer (wrapping an int) referred to by an object.
     * returns null if refObject is of invalid type
     * or indexes an invalid logic var.
     *
     * <i>Note: The original specification only allowed boolean
     * variables in this place.  Obviously some applications may
     * want to use collections of boolean variables to represent
     * integers over a finite fixed range, or rationals with
     * finite fixed precision over a finite fixed range.
     * This function is merely provided as a shortcut towards this end.</i>
     */
    public Integer getIntVar(Object refObject) { return null; }

    /**
     * inserts an integer value (see getIntvar).  Returns fals
     * if this insert was not permitted
     * @see ILogicVarBundle#getIntVar
     */
    public boolean insertIntVar(Object refObject, int nValue) { return false; }

    /**
     * Removes any values indexed by refObject
     * @param refObject remove values associated with this.
     */
    public void removeVar(Object refObject) {
    	return;
    }
    
    /**
     * gets a Boolean (wrapping a boolean) referred to by an object.
     * returns null if refObject is of invalid type 
     * or indexes an invalid logic var.
     */
    public Boolean getBoolVar(Object refObject) { return null; }

    /**
     * inserts an boolean value (see getBoolVar).  Returns fals
     * if this insert was not permitted
     * @see ILogicVarBundle#getBoolVar
     */
    public boolean insertBoolVar(Object refObject, boolean bValue) { return false; }


    /**
     * Gets unique Id of this agent
     */
    public int getId() { return m_nAgentId; }

    

}