/*
PseudoCode Interpreted Language (PCIL):  Part of the algoviz@vt collection of algorithm visualizations.
Copyright (C) 2008  Brandon Malone, Frank Hadlock

This file is part of the PseudoCode Interpreted Language.

PseudoCode Interpreted Language is free software: you can redistribute
it and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the License,
or (at your option) any later version.

PseudoCode Interpreted Language is distributed in the hope that it will
be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
Public License for more details.

You should have received a copy of the GNU General Public License along with
PseudoCode Interpreted Language.  If not, see
<http://www.gnu.org/licenses/>.
*/

/*
 * PrimitiveVertex.java
 *
 * Created on March 6, 2008, 6:35 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package dynamicmvc;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.geom.Ellipse2D;
import java.util.ArrayList;
import java.util.HashMap;
import javax.swing.JComponent;
import javax.swing.JPanel;

/**
 *
 * @author Brandon
 */
public class PrimitiveVertex extends Primitive {
     public static String pseudocodeTypeName() {
        return "Vertex";
    }
     
     public String getType() {
         return pseudocodeTypeName();
     }
     
     private static int radius = 10;
    
// <editor-fold defaultstate="collapsed" desc=" Private Members ">
    private PrimitivePointer value;
    private String name;
    private PrimitivePointer color;
    
    private Color c;
    
    private PrimitivePointer x;
    private PrimitivePointer y;
    
    private PrimitivePointer edges;
    // </editor-fold>    
    
// <editor-fold desc=" Constructors ">
    
    public Primitive copy() throws DynamicMVCException {
        PrimitiveVertex v = new PrimitiveVertex(name, getValue(), getColor(), getX(), getY(), getEdges());
        v.setDefinedProperties(getDefinedPropertiesCopy());
        return v;
    }
    public Primitive deepCopy(HashMap<Integer, Integer> alreadyCopiedAddresses) throws DynamicMVCException {
	
	PrimitivePointer p = getPointer();
	if (alreadyCopiedAddresses.containsKey(Integer.valueOf(p.getAddress()))) {
	    return PrimitiveFactory.getFromMemory(alreadyCopiedAddresses.get(p.getAddress()));
	}
	
	PrimitivePointer pp = PrimitiveFactory.create(pseudocodeTypeName(), name);	
	alreadyCopiedAddresses.put(p.getAddress(), pp.getAddress());
	
        PrimitiveVertex v = (PrimitiveVertex)pp.dereference();
	v.setName(name);
	v.setValue(value.deepCopy(alreadyCopiedAddresses));
	v.setC(c);
	v.setColor(color.deepCopy(alreadyCopiedAddresses));
	v.setX(x.deepCopy(alreadyCopiedAddresses));
	v.setY(y.deepCopy(alreadyCopiedAddresses));
	v.setEdges(edges.deepCopy(alreadyCopiedAddresses));
	
	super.deepCopyDefinedProperties(v, alreadyCopiedAddresses);
        return v;
    }
    
    public boolean deepEquals(Primitive p) throws DynamicMVCException {
        if (!(p instanceof PrimitiveVertex)) {
	    DynamicController.errorMessage = "Expecting Vertex, but found " + p.getType();
            return false;
        }
        
        PrimitiveVertex v = (PrimitiveVertex)p;
        
        if(!value.deepEquals(v.getValue())) {
            return false;
        }
        
        // LIMITATIONS OF TESTING
        /*
        if (!color.deepEquals(v.getColor())) {
            return false;
        }
        
        if (!x.deepEquals(v.getX())) {
            return false;
        }
        
        if(!y.deepEquals(v.getY())) {
            return false;
        }
        if (!edges.deepEquals(v.getEdges())) {
            return false;
        }
         */
        
        return super.deepEqualsDefinedProperties(p);
    }
    
    public void set(Primitive other) throws DynamicMVCException {
        
        throw new DynamicMVCException("Vertex set.");
        //this.reset(other);
        // if other is an integer, copy its values
        /*if (other instanceof PrimitiveVertex) {
            assign((PrimitiveVertex)other);
        } else {
            // otherwise, throw an DynamicMVCException
            throw new DynamicMVCException("Invalid assignment.");
        }*/
    }
    
    public PrimitiveVertex(String name, PrimitivePointer value, PrimitivePointer color, PrimitivePointer x, PrimitivePointer y, PrimitivePointer edges) throws DynamicMVCException {
        setName(name);
        setValue(value);
        setColor(color);
        setX(x);
        setY(y);
        setEdges(edges);
        getEdges().setName("edges");
        
        getValue().setName("Value");
    }    
    
    public PrimitiveVertex(String name, PrimitivePointer x, PrimitivePointer y) {
        PrimitivePointer color = PrimitiveFactory.create(PrimitiveString.pseudocodeTypeName(), "color");
        PrimitivePointer edges = PrimitiveFactory.create(PrimitiveList.pseudocodeTypeName(), "edges");
        PrimitivePointer value = PrimitiveFactory.create(PrimitiveString.pseudocodeTypeName(), "value");
        ((PrimitiveString)value.dereference()).setValue(name);
        
        setName(name);
        setValue(value);
        setColor(color);
        setX(x);
        setY(y);
        setEdges(edges);
        getEdges().setName("edges");
    }
    
    public PrimitiveVertex() {        
        super();
        
        PrimitivePointer name = PrimitiveFactory.create(PrimitiveString.pseudocodeTypeName(), "name");
        PrimitivePointer value = PrimitiveFactory.create(PrimitiveString.pseudocodeTypeName(), "value");
        PrimitivePointer color = PrimitiveFactory.create(PrimitiveString.pseudocodeTypeName(), "color");
        PrimitivePointer x = PrimitiveFactory.create(PrimitiveInteger.pseudocodeTypeName(), "x");
        PrimitivePointer y = PrimitiveFactory.create(PrimitiveInteger.pseudocodeTypeName(), "y");
        PrimitivePointer edges = PrimitiveFactory.create(PrimitiveList.pseudocodeTypeName(), "edges");
        
        setName(((PrimitiveString)name.dereference()).getValue());
        setValue(value);
        setColor(color);
        setX(x);
        setY(y);      
        setEdges(edges);
    }
    // </editor-fold>

// <editor-fold defaultstate="collapsed" desc=" Getters and Setters ">
    public PrimitivePointer getValue() {
        return value;
    }

    public void setValue(PrimitivePointer value) {
        this.value = value;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public Color getC() {
        return c;
    }
    
    public void setC(Color c) {
        this.c = c;
    }

    public PrimitivePointer getColor() {
        return color;
    }

    public void setColor(PrimitivePointer color) {
        this.color = color;
    }
    // </editor-fold>
    
// <editor-fold defaultstate="collapsed" desc=" Render Methods ">
    public void populateFromEditComponentWrapper(JComponent editComponentWrapper) throws DynamicMVCException {
        
        String valueName = value.getEditComponentName();
        JComponent valueChild = (JComponent)View.getComponent(editComponentWrapper, valueName);
        value.populateFromEditComponentWrapper(valueChild);
        
        // need to populate properties
        JComponent propertiesComponent = (JComponent)View.getComponent(editComponentWrapper, this.getPropertiesComponentName());
        super.populateDefinedProperties(propertiesComponent);
    }
    
    public String getEditComponentWrapperName() {
        return "pnl" + getName();
    }
    
    public String getEditComponentValue() {
        return "txt" + getName() + "value";
    }
    
    public JComponent getEditComponent() {
        // wrap everything in a panel
        JPanel wrapper = new JPanel();
        wrapper.setName(getEditComponentWrapperName());
        
        // create a label to display the number
        wrapper.add(value.getEditComponent());
        
        super.addEditDefinedProperties(wrapper);
                
        return wrapper;
    }
    
    public JComponent getReadOnlyComponent() {
        // wrap everything in a panel
        JPanel wrapper = new JPanel();
        
        // create a label to display the number
        wrapper.add(value.getReadOnlyComponent());
        
        addDefinedProperties(wrapper);
        
        return wrapper;
    }
    
    // </editor-fold>
    
    public PrimitivePointer get(String name) throws DynamicMVCException {
        if (name.equalsIgnoreCase("value")) {
            return value;
        } else if (name.equalsIgnoreCase("color")) {
            return color;
        } else if (name.equalsIgnoreCase("x")) {
            return x;
        } else if (name.equalsIgnoreCase("y")) {
            return y;
        } else if (name.equalsIgnoreCase("color")) {
            return color;
        } else if (name.equalsIgnoreCase("neighbors")) {
            return getNeighbors();
        } else if (name.equalsIgnoreCase("edges")) {
            return getEdges();
        }
        
        PrimitivePointer p = super.get(name);
        if (p == null) {
            PrimitivePointer var = PrimitiveFactory.create(PrimitiveString.pseudocodeTypeName(), name);
            super.set(name, var);
            
            p = super.get(name);
        }
        return p;
        
        //throw new DynamicMVCException(this.getName() + " does not contain a property named:'" + name + "'.");
    }
    
    public PrimitivePointer getNeighbors() throws DynamicMVCException {
        PrimitivePointer np = PrimitiveFactory.create(PrimitiveList.pseudocodeTypeName(), "neighbors");
        PrimitiveList neighbors = (PrimitiveList)np.dereference();
        
        for(PrimitivePointer p : ((PrimitiveList)edges.dereference()).getList()) {
            PrimitiveEdge e = (PrimitiveEdge)p.dereference();
            neighbors.add(e.findOtherVertex(this));
        }
        
        return np;
    }
    
    public Object execute(String methodName, ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        
        // is this a method of mine?
        if (methodName.equalsIgnoreCase("equals")) {
            return equals(arguments);
        } else if (methodName.equalsIgnoreCase("notEqual")) {
            return !equals(arguments);
        } else if (methodName.equalsIgnoreCase("addEdge")) {
            addEdge(arguments);
            return null;
        } else if (methodName.equalsIgnoreCase("distance")) {
            return distance(arguments);
        } else {
            throw new DynamicMVCException("Invalid method name:'" + methodName + "' on object '" + getName() + "'.");
        }        
    }
    
    public PrimitivePointer distance(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitivePointer v = arguments.get(0);
            return distance(v);
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer distance(PrimitivePointer v) {
        PrimitiveInteger myX = ((PrimitiveInteger)getX().dereference());
        PrimitiveInteger myY = ((PrimitiveInteger)getY().dereference());
        
        PrimitivePointer otherX = ((PrimitiveVertex)v.dereference()).getX();
        PrimitivePointer otherY = ((PrimitiveVertex)v.dereference()).getY();
        
        PrimitivePointer dx = myX.subtract(otherX);
        PrimitivePointer dy = myY.subtract(otherY);
        
        PrimitiveInteger iDX = (PrimitiveInteger)dx.dereference();
        PrimitiveInteger iDY = (PrimitiveInteger)dy.dereference();
        
        PrimitivePointer underRadical = ((PrimitiveInteger)iDX.multiply(dx).dereference()).add(iDY.multiply(dy));
        int result = (int)Math.sqrt(((PrimitiveInteger)underRadical.dereference()).getValue());
        
        PrimitivePointer res = PrimitiveFactory.create(PrimitiveInteger.pseudocodeTypeName(), "");
        ((PrimitiveInteger)res.dereference()).setValue(result);
        
        return res;
    }
    
    public int compareTo(Object o) throws DynamicMVCException {
        if (o instanceof PrimitiveVertex) {
            PrimitiveVertex i = (PrimitiveVertex)o;
            return compareTo(i);
        }
        
        throw new DynamicMVCException("Invalid comparison");
    }
    
    public boolean equals(ArrayList<Primitive> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitiveVertex i = (PrimitiveVertex)arguments.get(0);
            return equals(i);
        }
        
        throw new DynamicMVCException("Wrong number of arguments.");
    }
    
    public boolean equals(PrimitiveVertex i) throws DynamicMVCException {
        return (compareTo(i) == 0);
    }
    
    public int compareTo(ArrayList<Primitive> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitiveVertex i = (PrimitiveVertex)arguments.get(0);
            return compareTo(i);
        }
        
        throw new DynamicMVCException("Wrong number of arguments.");
    }
    
    public int compareTo(PrimitiveVertex i) throws DynamicMVCException {

        PrimitiveString otherValue = (PrimitiveString)i.getValue().dereference();

        return ((PrimitiveString)getValue().dereference()).compareTo(otherValue);
    }
    
    public int compareTo(Primitive p) throws DynamicMVCException {
        if (p instanceof PrimitiveVertex) {
            return compareTo((PrimitiveVertex)p);
        } else {
            throw new DynamicMVCException("Invalid type.");
        }
    }
            
    public void addEdge(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitivePointer e = arguments.get(0);
            addEdge(e);
        }
        
        throw new DynamicMVCException("Wrong number of arguments.");
    }
    
    public void addEdge(PrimitivePointer e) {
        ((PrimitiveList)getEdges().dereference()).add(e);
    }
    
    public String toString() {
        return getName() + ": " + getValue() + ": " + getColor();
    }
    
    public boolean contains(int x, int y) {
        int thisX = ((PrimitiveInteger)getX().dereference()).getValue();
        int thisY = ((PrimitiveInteger)getY().dereference()).getValue();
        Ellipse2D.Double oval = new java.awt.geom.Ellipse2D.Double(thisX - getRadius(),thisY - getRadius(), (int)(2 * getRadius()), (int)(2 * getRadius()));

        return oval.contains(x, y);
    }
    
    public void draw(Graphics g, PrimitiveVertex v) {
        paintOval(g, v);
        paintText(g);
    }
    
    private void paintOval(Graphics g, PrimitiveVertex v) {
        int thisX = ((PrimitiveInteger)getX().dereference()).getValue();
        int thisY = ((PrimitiveInteger)getY().dereference()).getValue();
        
        g.setColor(c);
        
	if (this == v) {
	   g.setColor(Color.green);
	}
	
        g.fillOval(thisX - getRadius(),thisY - getRadius(), (int)(2 * getRadius()), (int)(2 * getRadius()));
                
    }
    
    private void paintText(Graphics g) {
        int thisX = ((PrimitiveInteger)getX().dereference()).getValue();
        int thisY = ((PrimitiveInteger)getY().dereference()).getValue();
        
        g.setColor(java.awt.Color.WHITE);
        
        g.drawString(getName(), thisX, thisY + getRadius()/2);
    }

    public static int getRadius() {
        return radius;
    }

    public static void setRadius(int aRadius) {
        radius = aRadius;
    }

    public PrimitivePointer getX() {
        return x;
    }

    public void setX(PrimitivePointer x) {
        this.x = x;
    }

    public PrimitivePointer getY() {
        return y;
    }

    public void setY(PrimitivePointer y) {
        this.y = y;
    }

    public PrimitivePointer getEdges() {
        return edges;
    }

    public void setEdges(PrimitivePointer edges) {
        this.edges = edges;
    }
    
    public PrimitiveString  toPrimitiveString() {
	PrimitiveString s = (PrimitiveString)(PrimitiveFactory.create(PrimitiveString.pseudocodeTypeName(), "s").dereference());
	s.setValue(toString());
	return s;
    }
}