package genegui;

import java.awt.Color;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Vector;
import main.Model;
import main.NodeTemplate;

/** ModelState.java
 Maintains a ModelState to be used for specifying intial states and stoppers.
 <p>
 @author WJS
 */
public class ModelState {
	
	/** The unique ModelStateNodePalette attached to this ModelState */
	private ModelStateNodePalette                ActiveModelStateNodePalette;
	/** The active ModelStateView window */
	private ModelStateView                       ActiveModelStateView;
	/** An array of CellState for each cell in the ModelState */
	private CellState[]                          CellStateArray;
	/** A vector of ModelStateChangeListeners */
	private Vector                               ModelStateChangeListeners = new Vector();
	/** Each element in the array is an  ArrayList of NodeStateChangeListeners */
	private ArrayList[]                          NodeListeners;
	/** An array of of NodeTemplates */
	private NodeTemplate[]                       NodeTemplates;
	/** A pointer to the Model that this ModelState is for */
	private Model                                TheModel;
	/** Pointer to the ModelStateEditor that is bound to this ModelState */
	private ModelStateEditor                     TheModelStateEditor;
	/** A time value for the ModelState */
	private float                                Time = 0.0f;
	/** The unique ModelStateToolBox attached to this ModelState */
	private ModelStateToolBox                    ToolBox;
	/** A list of all known ModelStateViews attached to this palette */
	private Vector                               ViewList = new Vector();
	
	/** Simple constructor does little to be proud of. Used primarily by the
	cloneState operation.
	@author WJS
	 */
	public ModelState() {
		
	}
	
	/** Constructor initializes the ModelState based upon a passed Model.
	@param Model model - Model object that the ModelState is to be built for.
	 @author WJS
	 */
	public ModelState(Model model) {
		
		TheModel = model;
		
		// Build CellStateArray and NodeListenerArray based upon Model values
		CellStateArray = new CellState[TheModel.numCells];
		for (int i=0;i<CellStateArray.length;i++) {
			CellStateArray[i] = new CellState(TheModel.net.numNodes);
		}
		
		// Build NodeDescriptors
	  NodeTemplates = new NodeTemplate[TheModel.net.getNumNodes()];
		NodeListeners = new ArrayList[TheModel.net.getNumNodes()];
		for (int i=0;i<NodeTemplates.length;i++) {
			NodeTemplates[i] = TheModel.net.getNode(i);
			NodeListeners[i] = new ArrayList();
		}
		
		updateModel(model,0.0f);
		
	}
	
	/** Called to add a new ModelStateChangeListener.
	 @param ModelStateChangeListener - The new ModelStateChangeListener to be added.
	 @author WJS
	 */
	public void addModelStateChangeListener(ModelStateChangeListener listener) {
		
		ModelStateChangeListeners.add(listener);
		
	}
	
	/** Called to add a new ModelStateView to the local list.
	 @param ModelStateView view - The new ModelStateViewer to be added.
	 @author WJS
	 */
	public void addModelStateView(ModelStateView view) {
		
		ViewList.add(view);
		
	}
	
	/** Adds a NodeStateChangeListener to the ModelState.
	 @param NodeStateChangeListener listener - The NodeStateChangeListener.
	 @param int index - The index of the node the listener is to be attachted to.
	 @author WJS
	 */
	public void addStateChangeListener(NodeStateChangeListener listener, int index) {
		
		// Protect against adding null listeners because they can't be removed.
		if (listener!=null)
		  NodeListeners[index].add(listener);
		
	}
	
	/** Makes a duplicate of this model state.
	Note: this does not copy all the values. It just copies those that are important
	for representing the model state itself. Things like listeners are note copied.
	@author WJS
	 */
	public ModelState cloneState() {
		
		ModelState newState = new ModelState();
		
		// Clone CellStates
		CellState[] cells = new CellState[CellStateArray.length];
		for (int i=0;i<cells.length;i++)
			cells[i] = CellStateArray[i].cloneState();
		newState.setCellStateArray(cells);
		
		// Copy other values
		newState.setModel(TheModel);
		newState.setTime(Time);
		newState.setNodeTemplates(NodeTemplates);
		
		return(newState);
		
	}
	
	/** Copies all the values for one cell to another
	 @param int toCell - The index of the cell the values are to be copied to.
	 @param int fromCell - the index of the cell the values are to be copired from.
	 @author WJS
	 */
	public void copyCellValues(int toCell, int fromCell) {
		
		setCellState(toCell,getCellState(fromCell));
		
	}
	
	/** Gets the currently active (selected) ModelStateView.
	 @return ModelStateView - The currently selected ModelStateView.
	 @author WJS
	 */
	public ModelStateView getActiveModelStateView() {
		
		return(ActiveModelStateView);
		
	}
	
	/** Returns the CellState for the cell with the given index.
	 @param int cellIndex - The index of the cell.
	 @return CellState - The CellState for the cell.
	 @author WJS
	 */
	public CellState getCellState(int cellIndex) {
		
		return(CellStateArray[cellIndex]);
		
	}
	
	/** Returns the CellStateArray - Used by serialization
	 @return CellState[] - The CellStateArray.
	 @author WJS
	 */
	public CellState[] getCellStateArray() {
		
		return(CellStateArray);
		
	}
	
	/** Returns the Model that this is a ModelState for.
	 @return Model - The Model that this is a ModelState for.
	 @author WJS
	 */
	public Model getModel() {
		
		return(TheModel);
		
	}
	
	/** Returns the color for this type of node. The node color is the color a cell
	 will have if the node is the only node being viewed and it's maximum value (100%).
	 @param int  index - The index of the node.
	 @return Color - The color of the node when at its maximum value.
	 @author WJS
	 */
	public Color getNodeColor(int index) {
		
		return(NodeTemplates[index].getColor());
		
	}
	
	/** Returns the array of NodeTemplates.
	 @return NodeTemplate[]
	 @author WJS
	 */
	public NodeTemplate[] getNodeTemplates() {
		
		return(NodeTemplates);
		
	}
	
	/** Returns the number of cells in the model.
	 @return int - The number of cells in the model.
	 @author WJS
	 */
	public int getNumberOfCells() {
		
		return(CellStateArray.length);
		
	}
	
	/** Returns the number of different types of nodes in the model.
	 @return int - The number of different types of nodes in the model.
	 @author WJS
	 */
	public int getNumberOfNodes() {
		
		return(NodeTemplates.length);
		
	}
  
	/** Returns the ModelState time
	 @return float - The ModelState time
	 @author WJS
	 */
	public float getTime() {
		
		return(Time);
		
	}
	
	/** Returns the one and only ModelStateToolBox attached to this ModelState
	 @return ModelStateToolBox - The one and only ModelStateToolBox.
	 @author WJS
	 */
	public ModelStateToolBox getToolBox() {
		
		return(ToolBox);
		
	}
	
	/** Removes all  ModelStateViews, disposing of them and clearing the local
	 list. Usually used for close operations.
	 @author WJS
	 */
	public void removeAllModelStateViews() {
		
		Enumeration en = ViewList.elements();
		while (en.hasMoreElements())
			TheModelStateEditor.closeModelStateView(((ModelStateView)en.nextElement()));
		
		ViewList = new Vector();
		
	}
	
	/** Called to remove a ModelStateChangeListener.
	 @param ModelStateChangeListener - The new ModelStateChangeListener to be removed.
	 @author WJS
	 */
	public void removeModelStateChangeListener(ModelStateChangeListener listener) {
		
		ModelStateChangeListeners.remove(listener);
		
	}
	
	/** Called to remove a ModelStateView from the local list.
	 @author WJS
	 */
	public void removeModelStateView(ModelStateView view) {
		
		// First move focus to "next" ModelStateView
		if (ActiveModelStateView==view) {
			int i = ViewList.indexOf(view);
			if ((i+1)<ViewList.size())
				setActiveModelStateView((ModelStateView)ViewList.get(i+1));
			else if ((i-1)>0)
				setActiveModelStateView((ModelStateView)ViewList.get(i-1));
			else
				setActiveModelStateView(null);
		}
		ViewList.remove(view);
		TheModelStateEditor.closeModelStateView(view);
		
	}
	
	/** Removes a NodeStateChangeListener from the ModelState.
	 @param NodeStateChangeListener listener - The NodeStateChangeListener.
	 @param int index - The index of the node the listener is to be attachted to.
	 @author WJS
	 */
	public void removeStateChangeListener(NodeStateChangeListener listener, int index) {
		
		NodeListeners[index].remove(listener);
		
	}
	
	/** Resets the values of all nodes for all cells to 0.
	 @author WJS
	 */
	public void reset() {
		
		// Reset all the cells to 0
		for (int i=0;i<CellStateArray.length;i++)
			CellStateArray[i].reset();
		
		// Now go through and notify all ModelViews
		Enumeration en = ViewList.elements();
		while (en.hasMoreElements())
				((ModelStateView)en.nextElement()).reset();
		
		// Reset the one and only node palette
		ActiveModelStateNodePalette.reset();
		
	}
	
	/** Sets the one and only ModelStateNodePalette attached to thsi ModelState.
	 @param ModelStateNodePalette palette - The one and only ModelStateNodePalette to be
	 attached to this ModelState.
	 @author WJS
	 */
	public void setActiveModelStateNodePalette(ModelStateNodePalette palette) {
		
		ActiveModelStateNodePalette = palette;
		
	}
	
	/** Sets the ModelStateView that is currently active (selected). Releases the
	 old ModelViewState and updates the ModelStateNodePalette.
	 @param ModelStateView modelStateView - The new active ModelStateView.
	 @author WJS
	 */
	public void setActiveModelStateView(ModelStateView modelStateView) {
		
		// Abort redundant settings
		if (ActiveModelStateView==modelStateView) return;
		
		// De-select old ActiveModelView
		if (ActiveModelStateView!=null)
			ActiveModelStateView.setSelected(false);
		
		ActiveModelStateView = modelStateView;
		
		// Select new one if it's not null
		if (ActiveModelStateView!=null) {
			ActiveModelStateView.setSelected(true);
			if (ActiveModelStateNodePalette!=null) {
				ActiveModelStateNodePalette.setSelectedNodes(ActiveModelStateView.getSelectedNodes());
				setSelectedCells(ActiveModelStateView.getSelectedCells());
			}
		}
		
	}
	
	/** Sets the CellState for the given cell to that of a new CellState. The new
	 CellStates values are copied into the CellState of the selecetd cell.
	 @param int cellIndex - The index of the cell to receive the new CellState.
	 @param CellState state - The new CellState.
	 @author WJS
	 */
	public void setCellState(int cellIndex, CellState state) {
		
		CellStateArray[cellIndex].setCellState(state);
		
	}
	
	/** Replaces the entire CellStateArray with a new one.
	@param CellStateArray[] cellStateArray - The new array of cellStates.
	@author WJS
	 */
	public void setCellStateArray(CellState[] cellStateArray) {
		
		CellStateArray = cellStateArray;
		
	}
	
	/** Sets the model.
	@param Model theModel
	@author WJS
	 */
	public void setModel(Model theModel) {
		
		TheModel = theModel;
		
	}
	
	/** Sets a ModelStateEditor to be used with this ModelState if there is one
	 @param ModelStateEditor
	 @author WJS
	 */
	public void setModelStateEditor(ModelStateEditor modelStateEditor) {
		
		TheModelStateEditor = modelStateEditor;
		
	}
	
	/** Sets the node template array.
	@param NodeTemplate[] templates
	@author WJS
	 */
	public void setNodeTemplates(NodeTemplate[] templates) {
		
		NodeTemplates = templates;
		
	}
	
	/** Accepts a list of cells that are selected in a ModelStateView and updates
	 the ActiveModelStateNodePalette. This presents a small problem when more than
	 one cell is selected and the selected cells have different values for one
	 or more nodes. In this case the ModelStateNodePalette will display a blank.
	 @param boolean[] seletedCells - The array of selected cells. True = selected.
	 @author WJS
	 */
	public void setSelectedCells(boolean[] selectedCells) {
		
		float[] tempNodeValues = new float[NodeTemplates.length];
		for (int i=0;i<tempNodeValues.length;i++) tempNodeValues[i] = -2;
		
		// Go through list of selected cells and get thier node values. If one
		// cell is selcted, no problem. If more than one cell is selected, there
		// may be different node values. If so flag value with a -1. The NodePalette
		// will dispay this as an ambigous value.
		// Note -2=uninitialized value, -1=ambigouse value
		for (int i=0;i<selectedCells.length;i++) {
			if (selectedCells[i]) {
				for (int j=0;j<tempNodeValues.length;j++) {
					if (tempNodeValues[j]==-2) tempNodeValues[j]=CellStateArray[i].getNodeValue(j);
					else if ((tempNodeValues[j]!=-1)&&(tempNodeValues[j]!=CellStateArray[i].getNodeValue(j)))
						tempNodeValues[j] = -1;
				}
			}
		}
		
	  ActiveModelStateNodePalette.setValues(tempNodeValues);
		
	}

	/** Sets the time.
	@param float time
	@author WJS
	 */
	public void setTime(float time) {
		
		Time = time;
		
	}
	
	/** Sets the one and only ModelStateToolBox attached to this ModelState.
	 @param ModelStateToolBox toolBox - The one and only ModelStateToolBox.
	 @author WJS
	 */
	public void setToolBox(ModelStateToolBox toolBox) {
		
		ToolBox = toolBox;
		
	}
	
	/** Udates the values for a cell and notifies all node listeners
	 that a change has occurred so the cell may be repainted were needed.
	 @author WJS
	 */
	public void updateCell(int cellIndex) {
		
		// Now go through and notify all the listeners for this type of node.
		for (int i=0;i<NodeListeners.length;i++) {
			ArrayList listeners = NodeListeners[i];
			for (int j=0;j<listeners.size();j++) {
				((NodeStateChangeListener)listeners.get(j)).updateCell(cellIndex);
			}
		}
		
	}
	
	/** Called to completely update the values of the ModelState based upon
	 a passed Model. This may be used for initializing the values when a new
	 ModelStateEditor is invoked. It is also used after every integration step
	 when a CellViewer is attached.
	 @param Model model - the Model that the node values are to be drawn from.
	 @param float time - the time counter for this model state.
	 @author WJS
	 */
	public void updateModel(Model model,float time) {
		
		Time = time;
		
		// Update the values
		for (int i=0;i<CellStateArray.length;i++)
			CellStateArray[i].setNodeValueArray(model.cells[i].getValues());
		
		// Notify all the listeners
		Enumeration en = ModelStateChangeListeners.elements();
		while (en.hasMoreElements())
				((ModelStateChangeListener)en.nextElement()).updateAll();
		
	}
	
	/** Updates all the value for a node for all the selected cells in the
	 currently active ModelStateView.
	 @param int index - The index of the nodes to be updated.
	 @param float value - The new value for the node.
	 @author WJS
	 */
	public void updateNodeValue(int index, float value) {
		
		// If no ModelViews exist, then there will not be an active one
		// so bail.
		if (ActiveModelStateView==null) return;
		
		// Get the list of all the cells that are selected from the active
		// ModelStateView.
		boolean[] selectedCells = ActiveModelStateView.getSelectedCells();
		
		// Update values of for only those cells that are selected in the
		// active ModelStateView.
		for (int i=0;i<selectedCells.length;i++)
			if (selectedCells[i])
				CellStateArray[i].setNodeValue(index, value);
		
		// Now go through and notify all the listeners for this type of node.
		for (int i=0;i<NodeListeners.length;i++) {
			ArrayList listeners = NodeListeners[i];
			for (int j=0;j<listeners.size();j++) {
				((NodeStateChangeListener)listeners.get(j)).updateCells(selectedCells);
			}
		}
	}
	
	/** Updates the value in a node for a state
	 @param int cellIndex - The index of the cell.
	 @param int nodeIndex - The index of the node.
	 @param float value - The new value for the node.
	 @param ModelStateChangeListener - Sourcce listener.
	 @author WJS
	 */
	public void updateNodeValue(int cellIndex,  int nodeIndex, float value, ModelStateChangeListener source) {
		
		// Set the new value
		CellStateArray[cellIndex].setNodeValue(nodeIndex,value);
		
		Enumeration en = ModelStateChangeListeners.elements();
		ModelStateChangeListener listener;
		while (en.hasMoreElements()) {
			listener = (ModelStateChangeListener)en.nextElement();
			if (listener!=source) listener.updateNode(cellIndex, nodeIndex, value);
		}
		
	}
	
}