/*
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/>.
*/

/*
 * PrimitiveBoolean.java
 *
 * Created on March 11, 2008, 1:14 AM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package dynamicmvc;

import java.util.ArrayList;
import java.util.HashMap;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JPanel;

/**
 *
 * @author Brandon
 */
public class PrimitiveBoolean extends Primitive {
    
    public static String pseudocodeTypeName() {
        return "Boolean";
    }
    
     public String getType() {
         return pseudocodeTypeName();
     }
    
// <editor-fold defaultstate="collapsed" desc=" Private Members ">
    private boolean value;
    private String name;
    // </editor-fold>    
    
// <editor-fold desc=" Constructors ">
    
    public boolean isNullable() {
        return !value;
    }
    
    public Primitive copy() {
        PrimitiveBoolean i = new PrimitiveBoolean(name, value);
        return i;
    }
    
    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());
	
        PrimitiveBoolean i = (PrimitiveBoolean)pp.dereference();
	i.setName(name);
	i.setValue(value);
	
        deepCopyDefinedProperties(i, alreadyCopiedAddresses);
        return i;        
    }
    
    public boolean deepEquals(Primitive p) throws DynamicMVCException {
        if (!(p instanceof PrimitiveBoolean)) {
	    DynamicController.errorMessage = "Expecting Boolean, but found " + p.getType();
            return false;
        }
        
        PrimitiveBoolean b = (PrimitiveBoolean)p;
        if (value != b.getValue()) {
	    DynamicController.errorMessage = "Wrong boolean value.  Expecting '" + value + "', but found '" + b.getValue() + "'.";
            return false;
        }
        
        return super.deepEqualsDefinedProperties(p);
    }
    
    public void set(Primitive other) throws DynamicMVCException {
        // if other is an integer, copy its values
        if (other instanceof PrimitiveBoolean) {
            PrimitiveBoolean o = (PrimitiveBoolean)other;
            //setName(o.getName());
            setValue(o.getValue());
        } else {
            // otherwise, throw an DynamicMVCException
            throw new DynamicMVCException("Invalid assignment.");
        }
    }
    
    /** Creates a new instance of PrimitiveBoolean */
    public PrimitiveBoolean(String name, boolean value) {
        super();
        setName(name);
        setValue(value);
    }
    
    public PrimitiveBoolean(boolean value) {
        super();
        setName("");
        setValue(value);
    }
    
    public PrimitiveBoolean() {
        super();
        setName("");
        setValue(false);
    }
    
    // </editor-fold>

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

    public void setValue(boolean value) {
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    // </editor-fold>
    
// <editor-fold defaultstate="collapsed" desc=" Render Methods ">
    public void populateFromEditComponentWrapper(JComponent editComponentWrapper) {
        
        setValue(Boolean.valueOf((String)dataTypes.getSelectedItem()));
    }
    
    public String getEditComponentWrapperName() {
        return "pnl" + name;
    }
    
    javax.swing.JComboBox dataTypes;
    
    public JComponent getEditComponent() {
        // wrap everything in a panel
        JPanel wrapper = new JPanel();
        wrapper.setName(getEditComponentWrapperName());
        
        dataTypes = new javax.swing.JComboBox();
        dataTypes.setModel(new javax.swing.DefaultComboBoxModel(new String[] {"true", "false"}));
                  
        wrapper.add(dataTypes);
        
        return wrapper;
    }
    
    public JComponent getReadOnlyComponent() {
        // wrap everything in a panel
        JPanel wrapper = new JPanel();
        
        // create a label to display the number
        JLabel val = new JLabel();
        val.setText(String.valueOf(value));
        
        wrapper.add(val);
        
        return wrapper;
    }
    
    // </editor-fold>
    
    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("assign")) {
            assign(arguments);
            return null;
        } else {
            throw new DynamicMVCException("Invalid method name:'" + methodName + "' on object '" + name + "'.");
        }        
    }
    
    public boolean equals(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitiveBoolean i = (PrimitiveBoolean)arguments.get(0).dereference();
            return valueEquals(i);
        }
        
        throw new DynamicMVCException("Wrong number of arguments.");
    }
    
    public boolean valueEquals(Primitive p) {
	if (p instanceof PrimitiveBoolean) {
	    return valueEquals((PrimitiveBoolean)p);
	}
	
	return false;
    }
    
    public boolean valueEquals(PrimitiveBoolean i) {
	if(i.hasDefinedProperties(this.getDefinedProperties())) {
	    return (value == i.getValue());
	} else {
	    return false;
	}
    }
    
    public boolean equals(Boolean b) {
        return (value == b.booleanValue());
    }
    
    public boolean equals(boolean b) {
        return value == b;
    }
    
    public void assign(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitiveBoolean i = (PrimitiveBoolean)arguments.get(0).dereference();
            assign(i);
        }
        
        throw new DynamicMVCException("Wrong number of arguments.");
    }
    
    public void assign(PrimitiveBoolean i) {
        String otherName = i.getName();
        boolean otherValue = i.getValue();
        
        setName(otherName);
        setValue(otherValue);
    }
    
    public String toString() {
        return getName() + ": " + getValue();
    }
    
    public int compareTo(Primitive p) throws DynamicMVCException {
        if (p instanceof PrimitiveBoolean) {
            Boolean val = new Boolean(value);
            Boolean otherVal = new Boolean(((PrimitiveBoolean)p).getValue());
            return val.compareTo(otherVal);
        } else {
            throw new DynamicMVCException("Invalid comparison.");
        }        
    }
    
    public PrimitiveString  toPrimitiveString() {
	PrimitiveString s = (PrimitiveString)(PrimitiveFactory.create(PrimitiveString.pseudocodeTypeName(), "s").dereference());
	s.setValue(String.valueOf(value));
	return s;
    }
}