import java.util.Random;

/**
 * <p>
 * Creates a random flock of robots in an n-dimensional box
 * </p>
 * @author     Michael Schuresko
 * @version    %I%, %G%
 * @since      1.0
*/
public class RandomInit implements IInitializer
{

    int m_nNumAgents, m_nDim;
    double [] m_arrLfMin;
    double [] m_arrLfMax;

    ILogicVarBundle m_logicVarsToClone;
    IControlFunc m_controlFuncToClone;

    Random m_randomGen;

    /**
     * constructor specifying number of agents and
     * dimensionality in which they live.
     * @param nAgents number of agents
     * @param nDim dimensionality in which they live
     */
    public RandomInit(int nAgents, int nDim)
    {
	m_randomGen = new Random();
	m_nNumAgents = nAgents;
	m_nDim = nDim;
	m_arrLfMin = new double[nDim];
	m_arrLfMax = new double[nDim];
	for(int i = 0; i < nDim; ++i) {
	    m_arrLfMin[i] = -0.5;
	    m_arrLfMax[i] = 0.5;
	}
	m_logicVarsToClone = new NullLogicVarBundle();
	m_controlFuncToClone = new ControlFuncDoNothing(nDim);

    }

    /**
     * constructor specifying number of agents, the
     * dimensionality in which they live, and the size
     * of the containing box along each dimension.
     * @param nAgents number of agents
     * @param arrLfSizes length, height, width, etc of box
     * in which agents live-arrLfSizes.length is dimensionality.
     */
    public RandomInit(int nAgents, double [] arrLfSizes)
    {
	m_randomGen = new Random();
	m_nNumAgents = nAgents;
	m_nDim = arrLfSizes.length;
	m_arrLfMin = new double[m_nDim];
	m_arrLfMax = new double[m_nDim];
	for(int i = 0; i < m_nDim; ++i) {
	    m_arrLfMin[i] = -0.5*arrLfSizes[i];
	    m_arrLfMax[i] = 0.5*arrLfSizes[i];
	}
	m_logicVarsToClone = new NullLogicVarBundle();
	m_controlFuncToClone = new ControlFuncDoNothing(m_nDim);
    }

    public void setDefaultIniVars(ILogicVarBundle copyMe)
    {
	m_logicVarsToClone = copyMe.makeCopy();
    }

    public void setDefaultIniControlFunc(IControlFunc copyMe)
    {
	m_controlFuncToClone = copyMe.makeCopy();
    }

    public void resetState() {}
    
    /**
     * Initial continuous state vector
     */
    public double [] getInitContState()
    {
	double [] arrLfOut = new double[m_nNumAgents*m_nDim];
	for(int i = 0; i < m_nNumAgents; ++i) 
	{
	    int nOff = i*m_nDim;
	    for(int j = 0; j < m_nDim; ++j) 
		{
		    arrLfOut[nOff+j] = m_arrLfMin[j] +
			m_randomGen.nextDouble()*
			(m_arrLfMax[j]-m_arrLfMin[j]);
		}
	}
	return arrLfOut;
    }

    public IEnvironment getEnv()
    {
	return new NdTrivialEnv(m_arrLfMin, m_arrLfMax);
    }
    


    public int getNumAgents() { return m_nNumAgents; }

    /**
     * convenient to have this...
     */
    public StateBundle [] getInitDiscreteState()
    {
	StateBundle [] arrStates = new StateBundle[m_nNumAgents];
	for(int i = 0; i < m_nNumAgents; ++i)
	    {
		ILogicVarBundle currBundle = 
		    m_logicVarsToClone.makeCopy();
		currBundle.setId(i);
		currBundle.init();
		arrStates[i] = new StateBundle(currBundle,
					       m_controlFuncToClone.makeCopy()
					       );
	    }
	return arrStates;
    }

    public boolean isAgentCompatible(IAgent agent)
    {
	return (agent != null);
    }
}