package genegui;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.util.*;
import javax.swing.*;

import main.*;

/** ModelStateView.java
 Constructs a JWindow for viewing all the cells in a model. The user may select
 which nodes are being displayed in the window and set the values of the
 nodes. It is implemented in such a way as to function independently of cell
 shapes and positions. It is accompanied by a toolbox and a node palette.
 <p>
 Originally designed to be used for building initial states and for general purpose
 stoppers.
 <p>
 @author WJS
 */
public class ModelStateView extends JPanel implements NodeStateChangeListener, GuiInterface {
	
	/** Stroke used for outlining cells */
	private static final Stroke        NormalStroke = new BasicStroke(2);
	/** Color used for outlining cells */
	private static final Color         OutlineColor = Color.white;
  /** Stroke used for outlining selected cells */
	private static final Stroke        SelectedStroke = new BasicStroke(4);
	
	/** Current paint color of cells allows for more rapid repaint operations */
	private Color[]                    CellColorArray;
	/** Cells which are selected */
	private boolean[]                  CellSelectionArray;
	/** Stores the cell shapes including scale and translation - speeds up painting */
	private Polygon[]                  CellShapeArray;
	/** Stores the base cell shapes and locations */
	private Polygon[]                  CellShapeArrayBase;
	/** Area at the top for displaying control buttons and drag bar. Also shows
	 which ModelStateView is selected */
	private JPanel                     ControlArea;
	/** Drag offset used for drag operations. Distance from mouse pointer and UL of window */
	private Point                      DragOffset;
	/** The last cell that was selected. Used for copying cell properties. */
	private int                        LastSelectedCell = 0;
	/** The nodes that are visible for this viewer */
	private boolean[]                  NodeSelectionArray;
	/** Copy of this */
	private ModelStateView             SaveThis = this;
	/** The scale at which to draw the cell shape objects */
	private double                     Scale = 5.0;
	/** The MainGui object that this belongs to */
	private MainGui                    TheMainGui;
	/** The ModelState that this viewer is attached to */
	private ModelState                 TheModelState;
	/** A pointer to the parent ModelStateEditor */
	private ModelStateEditor           TheModelStateEditor;
	/** The pannel used to display the cells themselves */
	private ModelStateViewPane         TheModelStateViewPane;
	/** Translation for drawing of cells */
	private Point                      Translation = new Point(5,5);
	
	/** Primary constructor builds the visual appearance of the viewer and
	 establishes mouse listeners.
	 */
	public ModelStateView(ModelState theModelState, ModelStateEditor theModelStateEditor, MainGui theMainGui) {
		
		super();
		
		TheModelState = theModelState;
		TheModelStateEditor = theModelStateEditor;
		TheMainGui = theMainGui;
		NodeSelectionArray = new boolean[TheModelState.getNumberOfNodes()];
		
		setLayout(new BorderLayout());
		setBorder(BorderFactory.createMatteBorder(2,2,3,3,Color.darkGray));
		
		// Create a control area for the top of the display
		ControlArea = new JPanel();
		ControlArea.setLayout(new BoxLayout(ControlArea,BoxLayout.X_AXIS));
		ControlArea.setBackground(Color.lightGray);
		// Create a filler panel to push things to the right of the control area
		JPanel filler = new JPanel();
		filler.setOpaque(false);
		ControlArea.add(filler);
		// Get the metal close icon and create a close button (Default fails on OSX).
		Icon closeIcon = javax.swing.plaf.metal.MetalIconFactory.getInternalFrameCloseIcon(16);
		JButton closeButton = new JButton(closeIcon);
		Dimension d = new Dimension(closeIcon.getIconWidth()+4,closeIcon.getIconHeight()+4);
		closeButton.setMaximumSize(d);
		closeButton.setMinimumSize(d);
		closeButton.setPreferredSize(d);
		closeButton.addActionListener(new ActionListener() {
					public void actionPerformed(ActionEvent ae) {
						TheModelState.removeModelStateView(SaveThis);
						TheMainGui.removeGUIListener(SaveThis);
					}
				});
		ControlArea.add(closeButton);
		
		// Create mouse and mouse motion listeners for allowing the window to be
		// dragged.
		addMouseListener(new MouseAdapter() {
					public void mousePressed(MouseEvent me) {
						DragOffset = me.getPoint();
						TheModelState.setActiveModelStateView(SaveThis);
					  TheModelStateEditor.moveModelStateViewToFront(SaveThis);
					}
					public void mouseReleased(MouseEvent me) {
					}
				});
		addMouseMotionListener(new MouseMotionAdapter() {
					public void mouseDragged(MouseEvent me) {
						Point p = getLocation();
						setLocation(p.x+me.getX()-DragOffset.x,p.y+me.getY()-DragOffset.y);
					}
				});
		
		add(ControlArea,BorderLayout.NORTH);
		
		TheModelStateViewPane = new ModelStateViewPane();
		add(TheModelStateViewPane,BorderLayout.CENTER);
		
		// Build the Cell Arrays based upon the Model information
		CellColorArray = new Color[TheModelState.getNumberOfCells()];
		CellSelectionArray = new boolean[TheModelState.getNumberOfCells()];
		CellShapeArray = new Polygon[TheModelState.getNumberOfCells()];
		CellShapeArrayBase = new Polygon[TheModelState.getNumberOfCells()];
		for (int i=0;i<CellShapeArray.length;i++) {
			CellShapeArrayBase[i] = TheModelState.getModel().cells[i].getCellShape();
			CellColorArray[i] = getBackground();
			CellSelectionArray[i] = false;
		}
		
		setScaleAndTranslation(Scale,Translation);
		
				
		// Determine the best size for the viewer by going through all the shapes
		// and finding the max points. Allow head room for controlArea and some
		// room at the sides for deselect-clicking.
		double maxX = 0;
		double maxY = 0;
		for (int i=0;i<CellShapeArray.length;i++) {
			Rectangle2D rect = CellShapeArray[i].getBounds2D();
			if ((rect.getX()+rect.getWidth())>maxX) maxX = rect.getX()+rect.getWidth();
			if ((rect.getY()+rect.getHeight())>maxY) maxY = rect.getY()+rect.getHeight();
		}
		setSize((int)maxX+10,(int)maxY+closeIcon.getIconHeight()+14);
		
		setVisible(true);
		
	}
	
	/** Deselects all cells.
	 @author WJS
	 */
	public void deselectAllCells() {
		
		for (int i=0;i<CellSelectionArray.length;i++)
			selectCell(i, false);
		
	}
	
	/** Find the cell which contains point p. This is implemented in a slower
	 but more general way to allow for different/multiple cells shapes and cell
	 positions. It search through the list of cell shapes and uses the contains
	 method to identify the cell.
	 @param Point p - A point in the ModelStateViewPane.
	 @return int - The index of the cell or -1 if the point is not in a cell.
	 @author WJS
	 */
	private int findCellAt(Point p) {
		
		for (int i=0;i<CellShapeArray.length;i++) {
			if (CellShapeArray[i].contains(p)) return(i);
		}
		
		return(-1);
		
	}
	
	/** Sets a single cell as being selected. This will set the cell to have
	 the selected outline type and update the values of the attached NodePalette
	 to match the values of the cell.
	 @param int index - The index of the cell.
	 @param  boolean select - If true the cell is selected.
	 @author WJS
	 */
	public void selectCell(int index, boolean select) {
		
		if ((index<0)||(index>CellSelectionArray.length)) return;
		CellSelectionArray[index] = select;
		TheModelState.setSelectedCells(CellSelectionArray);
		LastSelectedCell = index;
		
	}
	
	/** Sets scale and translation for CellShapeArray used in painting operations.
	@param double scale - The magnification factor for the cell.
	@param Point translation - the Translation for the cell shape - not subjected to scale factor.
	@author WJS
	 */
	public void setScaleAndTranslation(double scale, Point translation) {
		
		Scale = scale;
		Translation = translation;
		
		Polygon p;
		Polygon q;
		for (int i=0;i<CellShapeArrayBase.length;i++) {
			p = CellShapeArrayBase[i];
			q = new Polygon();
			for (int n=0;n<p.npoints;n++) {
				q.addPoint((int)(p.xpoints[n]*Scale+Translation.x),(int)(p.ypoints[n]*Scale+Translation.y));
			}
			CellShapeArray[i] = q;
		}
		
	}
	
	/** Returns an array of all the cells that are selected.
	 @return boolean[] - Array of all selected cells. True = selected.
	 @author WJS
	 */
	public boolean[] getSelectedCells() {
		
		return(CellSelectionArray);
		
	}
	
	/** Returns an array of the selected (visible) nodes.
	 @return boolean[] - An array of all the nodes that are selected. True = selected (visible).
	 @author WJS
	 */
	public boolean[] getSelectedNodes() {
		
		return(NodeSelectionArray);
		
	}
	
	/** Resets the ModelStateView by switching off all cell-selections, turning
	 off all visible nodes.
	 @author WJS
	 */
	public void reset() {
		
		for (int i=0;i<CellSelectionArray.length;i++)
			CellSelectionArray[i] = false;
		for (int i=0;i<NodeSelectionArray.length;i++)
			NodeSelectionArray[i] = false;
		updateAllCells();
		
	}
	
	/** Sets a node as being selected (viewed) by this viewer.
	 @param int nodeIndex - The index of the node that is being made visible/invisible.
	 @param boolean selected - The node is made visible if true.
	 @author WJS
	 */
	public void setNodeSelected(int nodeIndex, boolean selected) {
		
		NodeSelectionArray[nodeIndex] = selected;
		updateAllCells();
		
	}
	
	/** Sets this ModelStateView as being selected. Causes the control area at
	 the top of the display to be highlighted or de-highlighted.
	 @param boolean selected - Selected if true.
	 @author WJS
	 */
	public void setSelected(boolean selected) {
		
		if (selected)
		  ControlArea.setBackground(Color.gray);
		else
			ControlArea.setBackground(Color.lightGray);
		
	}
	
	/** Updates the colors of all cells whether they are selected or not. This
	 is used when nodes are being set to visible or invisible.
	 @author WJS
	 */
	public void updateAllCells() {
		
		for (int i=0;i<CellShapeArray.length;i++)
			updateCellColor(i);
		//TODO speed up by repainting only changed cells?
//				TheModelStateViewPane.paintCell(i);
		
		// Repaint whole thing until above speed-up is made
		TheModelStateViewPane.repaint();
		
	}
	
	/** Updates the color for cell at index. The ModelState is referrenced to
	 compute the current color. The color is based upon the node values and the
	 node value colors and which nodes are ste to visible for this viewer. Node
	 colors are added together so if any of the RGB values excede 255, they are
	 capped at 255.
	 @param int index - Index of cell to be updated.
	 @author WJS
	 */
	private void updateCellColor(int index) {
		
		int r = 0;
		int g = 0;
		int b = 0;
		boolean colored = false;
		for (int i=0;i<NodeSelectionArray.length;i++) {
			if (NodeSelectionArray[i]) {
				float v = TheModelState.getCellState(index).getNodeValue(i);
				Color color = TheModelState.getNodeColor(i);
				r += color.getRed()*v/100;
				g += color.getGreen()*v/100;
				b += color.getBlue()*v/100;
				colored = true;
			}
		}
		
		// Cap colors at 255 if they went over. If the cell wasn't colored, set
		// it to the background of the pane to give it a psuedo-transparency effect
		// rather than just having it black. Black implies that node values are
		// being viewed, but they are all 0.
		if (colored) {
			if (r>255) r = 255;
			if (g>255) g = 255;
			if (b>255) b = 255;
			CellColorArray[index] = new Color(r,g,b);
		} else {
			CellColorArray[index] = getBackground();
		}
		
	}
	
	/** Repaints a single cell.
	 @param int cellIndex - The index of the cell to be repainted.
	 @author WJS
	 */
	public void updateCell(int cellIndex) {
		
		updateCellColor(cellIndex);
		//TODO speed up by repainting only changed cells?
//				TheModelStateViewPane.paintCell(i);
		
		// Repaint whole thing until above speed-up is made
		TheModelStateViewPane.repaint();
		
	}
	
	/** Updates the colors for all the selected cells.
	 @param boolean[] selectedCells - Array of cells that are selected.
	 @author WJS
	 */
	public void updateCells(boolean[] selectedCells) {
		
		for (int i=0;i<selectedCells.length;i++)
			if (selectedCells[i]) {
				updateCellColor(i);
				//TODO speed up by repainting only changed cells?
//				TheModelStateViewPane.paintCell(i);
			}
		
		// Repaint whole thing until above speed-up is made
		TheModelStateViewPane.repaint();
		
	}

	/******************** GUItoNet Interface implementation *********************/
	
	
	/** Called when a change is made to the passed AffectorTemplate
	 @param int operation
	 @param AffectorTemplate affectorTemplate
	 @param GuiInterface source - Originator of this interface change.
	 @author WJS
	 */
	public void affectorTemplateChanged(int operation, AffectorTemplate affectorTemplate, GuiInterface source) {
		
	}

	/** Method for invoking general network IO operations.
	 @param int operation - The network IO operation code.
	 @param File file - The file if needed, else don't care.
	 @author WJS
	 */
	public boolean networkIO(int operation, File file) {
		
		boolean result = true;
		
		return(result);
		
	}
	
	/** Called when a change is made to the passed NodeTemplate
	 @param int operation
	 @param NodeTemplate nodeTemplate
	 @param GuiInterface source - Originator of this interface change.
	 @author WJS
	 */
	public void nodeTemplateChanged(int operation, NodeTemplate nodeTemplate, GuiInterface source) {
		
		switch (operation) {
			case GuiInterface.ADDED:
				// TODO
				break;
			case GuiInterface.CHANGED:
				for (int i=0;i<NodeSelectionArray.length;i++) {
					if (NodeSelectionArray[i]&&(nodeTemplate.getNodeNum()==i)) {
						updateAllCells();
						break;
					}
				}
				repaint();
				break;
			case GuiInterface.REMOVED:
				// TODO
				break;
				
		}
		
	}

	/** Called when a change is made to a parameter or the whole parameter set
	 @param int operation
	 @param int parameterNumber
	 @param GuiInterface source - Originator of this interface change.
	 @author WJS
	 */
	public void parameterSetChanged(int operation, int parameterNumber, GuiInterface source) {
		
	}
	
	/** Method for controling model/iterator runs.
	 @param int operation - Run control code.
	 @author WJS
	 */
	public void runControl(int operation) {
		
		
	}

	/** Method for reporting status of the model/iterator runs
	 @param int operation - Run status code.
	 @author WJS
	 */
	public void runStatus(int operation) {
		
	}
	
	/** ModelStateViewPane - internal class
	 JPanel used for painting the cells and for implementing mouse listeners.
	 @author WJS
	 */
	private class ModelStateViewPane extends JPanel {
		
		public ModelStateViewPane() {
			
			super();
			setBackground(Color.lightGray);
			
			addMouseListener(new MouseAdapter() {
						
						public void mouseClicked(MouseEvent me) {
							
							int i;
							
							switch(TheModelState.getToolBox().getMode()) {
								case ModelStateToolBox.MODE_SELECT:
									i = findCellAt(me.getPoint());
									if (!me.isControlDown()) deselectAllCells();
									selectCell(i,true);
									TheModelState.setActiveModelStateView(SaveThis);
									break;
								case ModelStateToolBox.MODE_APPLY:
									i = findCellAt(me.getPoint());
									TheModelState.copyCellValues(i,LastSelectedCell);
									updateCellColor(i);
									deselectAllCells();
									selectCell(i,true);
									TheModelState.updateCell(i);
									TheModelState.setActiveModelStateView(SaveThis);
									break;
							}
							repaint();
							
						}
						
					});
			
		}
		
		/** Over-ride/extend paint for this JPanel. Paints all cell shapes
		 with their proper color and outline.
		 @author WJS
		 */
		public void paint(Graphics g0) {
			
			super.paint(g0);
			
			Graphics2D g = (Graphics2D)g0;
		  g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
			g.setStroke(NormalStroke);
			
			// Scan through the array of cells and paint them
			for (int i=0;i<CellShapeArray.length;i++) {
				// Fill cell
				g.setColor(CellColorArray[i]);
				g.fill(CellShapeArray[i]);
				// Paint outline
				g.setColor(OutlineColor);
				if (CellSelectionArray[i])
					g.setStroke(SelectedStroke);
				g.draw(CellShapeArray[i]);
				g.setStroke(NormalStroke);
			}
			
		}
		
	}
	
}