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

/*
 * PrimitiveDictionary.java
 *
 * Created on August 19, 2008, 9:27 PM
 *
 * 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.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JPanel;

/**
 *
 * @author Brandon
 */
public class PrimitiveDictionary extends Primitive {
    
    public static String pseudocodeTypeName() {
        return "Dictionary";
    }
    
     public String getType() {
         return pseudocodeTypeName();
     }
    
    private String name;
    
    HashMap<PrimitivePointer, PrimitivePointer> dictionary;
    
    /** Creates a new instance of PrimitiveDictionary */
    public PrimitiveDictionary() {
	super();
        
        dictionary = new HashMap<PrimitivePointer, PrimitivePointer>();
    }
    
    
    public JComponent getReadOnlyComponent(){
        
        // wrap everything in a panel
        JPanel wrapper = new JPanel();
        wrapper.setName(getEditComponentWrapperName());
        
        // for each thing in the pq
        for(PrimitivePointer key : dictionary.keySet()) {
	    JPanel w = new JPanel();
            w.setBorder(BorderFactory.createEtchedBorder());
            
            PrimitivePointer value = dictionary.get(key);
	    
	    String keyName = key.getName();
	    String valueName = value.getName();
	    
	    key.setName("key");
	    value.setName("value");
	    
            w.add(key.getReadOnlyComponent());
	    w.add(value.getReadOnlyComponent());
	    
	    key.setName(keyName);
	    value.setName(valueName);
	    
	    wrapper.add(w);
        }
        
        return wrapper;
    }
    public JComponent getEditComponent(){
        
        // wrap everything in a panel
        JPanel wrapper = new JPanel();
        wrapper.setName(getEditComponentWrapperName());
        
        // for each thing in the pq
        for(PrimitivePointer key : dictionary.keySet()) {
	    JPanel w = new JPanel();	    
            PrimitivePointer value = dictionary.get(key);
	    
	    String keyName = key.getName();
	    String valueName = value.getName();
	    
	    key.setName("key");
	    value.setName("value");
	    
            w.add(key.getReadOnlyComponent());
	    w.add(value.getReadOnlyComponent());
	    
	    key.setName(keyName);
	    value.setName(valueName);
	    
	    wrapper.add(w);
        }

	JButton addButton = new JButton();
	addButton.setText("Add Entry");
	//addButton.addActionListener(new AddHandler());

	wrapper.add(addButton);
        
        return wrapper;
    }
    
    public String getEditComponentWrapperName(){
        return "pnl" + name;
    }
    
    public void populateFromEditComponentWrapper(JComponent editComponentWrapper) throws DynamicMVCException{
        // just populate each of the array values
        for(PrimitivePointer key : dictionary.keySet()) {
	    PrimitivePointer value = dictionary.get(key);
	    
            String keyName = key.getEditComponentName();
	    String valueName = value.getEditComponentName();
            
            JComponent keyChild = (JComponent)View.getComponent(editComponentWrapper, keyName);
	    JComponent valueChild = (JComponent)View.getComponent(editComponentWrapper, valueName);
	    
            key.populateFromEditComponentWrapper(keyChild);
	    value.populateFromEditComponentWrapper(valueChild);
        }
    }
    
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    
    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());
	
        PrimitiveDictionary d = (PrimitiveDictionary)pp.dereference();	        
        d.setName(name);
	
	for(PrimitivePointer key : dictionary.keySet()) {
	    PrimitivePointer value = dictionary.get(key);
	    d.put(key.deepCopy(alreadyCopiedAddresses), value.deepCopy(alreadyCopiedAddresses));
	}

        super.deepCopyDefinedProperties(d, alreadyCopiedAddresses);

        return d;
    }
    
    public boolean deepEquals(Primitive p) throws DynamicMVCException {
        if (!(p instanceof PrimitiveDictionary)) {
	    DynamicController.errorMessage = "Expecting Dictionary, but found " + p.getType();
            return false;
        }
        
        PrimitiveDictionary o = (PrimitiveDictionary)p;
        /*
        if (pq.size() != o.getPq().size()) {
	    DynamicController.errorMessage = "Wrong priority queue size.  Expecting '" + pq.size() + "', but found '" + o.getPq().size() + "'.";
            return false;
        }
        
        Iterator<PrimitivePointer> me = pq.iterator();
        Iterator<PrimitivePointer> him = o.getPq().iterator();
        
        for(int i = 0; i < pq.size(); i++) {
            PrimitivePointer myP = me.next();
            PrimitivePointer otherP = him.next();
            
            if (!myP.deepEquals(otherP)) {
                return false;
            }
        }
	 **/
        
        return super.deepEqualsDefinedProperties(p);
    }
    
    public PrimitivePointer execute(String methodName, ArrayList<PrimitivePointer> arguments) throws DynamicMVCException{
        if (methodName.equalsIgnoreCase("elements")) {
            return elements(arguments);            
        } else if (methodName.equalsIgnoreCase("get")) {
	    return get(arguments);
	} else if (methodName.equalsIgnoreCase("isEmpty")) {
	    return isEmpty(arguments);
	} else if (methodName.equalsIgnoreCase("keys")) {
	    return keys(arguments);
	} else if (methodName.equalsIgnoreCase("put")) {
	    return put(arguments);
	} else if (methodName.equalsIgnoreCase("remove")) {
	    return remove(arguments);
	} else if (methodName.equalsIgnoreCase("size")) {
	    return size(arguments);
	} else if (methodName.equalsIgnoreCase("contains")) {
	    return contains(arguments);
	}
	
        throw new DynamicMVCException ("Object: '" + name + "' does not support method '" + methodName + "'.");
    }
    
    public PrimitivePointer remove(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitivePointer i = arguments.get(0);
            return remove(i);
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer remove(PrimitivePointer key) throws DynamicMVCException {
        for(PrimitivePointer k : dictionary.keySet()) {
            if (k.deepEquals(key)) {
                return dictionary.remove(k);
            }
        }
        
        PrimitivePointer n = PrimitiveFactory.create(PrimitiveNull.pseudocodeTypeName(), "null");
	return n;
    }
    
    public PrimitivePointer size(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 0) {
            return size();
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer size() {
        PrimitivePointer p = PrimitiveFactory.create(PrimitiveInteger.pseudocodeTypeName(), "");
        ((PrimitiveInteger)p.dereference()).setValue(dictionary.size());
        return p;
    }
    
    public PrimitivePointer isEmpty(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 0) {
            return isEmpty();
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer isEmpty() {
        PrimitivePointer p = PrimitiveFactory.create(PrimitiveBoolean.pseudocodeTypeName(), "");
        ((PrimitiveBoolean)p.dereference()).setValue(dictionary.isEmpty());
        return p;
    }
    
    public PrimitivePointer put(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 2) {
            // reverse order
            PrimitivePointer value = arguments.get(1);            
            PrimitivePointer key = arguments.get(0);
            put(key, value);
            return null;
        } else if (arguments.size() == 1) {
            PrimitivePointer e = arguments.get(0);
            put(e);
	    return null;
        } else {        
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public void put(PrimitivePointer p) throws DynamicMVCException {
        PrimitiveStructure e = (PrimitiveStructure)p.dereference();
	PrimitivePointer key = e.get("key");
	PrimitivePointer value = e.get("value");
	put(key, value);
    }
    
    public void put (PrimitivePointer key, PrimitivePointer value) throws DynamicMVCException {
        PrimitivePointer k = key.copy();
	PrimitivePointer v = value.copy();
	
        k.setName("key");
        v.setName("value");
        
        PrimitiveBoolean c = (PrimitiveBoolean)contains(key).dereference();
        if (c.getValue()) {
            remove(key);
        }
	
	dictionary.put(key, value);
    }
    
    public PrimitivePointer get(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitivePointer i = arguments.get(0);
            return get(i);
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer get(PrimitivePointer key) throws DynamicMVCException {
        for(PrimitivePointer k : dictionary.keySet()) {
            if (k.deepEquals(key)) {
                return dictionary.get(k);
            }
        }
        
        PrimitivePointer n = PrimitiveFactory.create(PrimitiveNull.pseudocodeTypeName(), "null");
	return n;
    }
    
    public PrimitivePointer keys(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 0) {
            return keys();
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer keys() {
        PrimitivePointer p = PrimitiveFactory.create(PrimitiveList.pseudocodeTypeName(), "");
	PrimitiveList l = (PrimitiveList)p.dereference();
	for(PrimitivePointer key : dictionary.keySet()) {
	    l.add(key);
	}
        return p;
    }
    
    public PrimitivePointer elements(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 0) {
            return keys();
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer elements() {
        PrimitivePointer p = PrimitiveFactory.create(PrimitiveList.pseudocodeTypeName(), "");
	PrimitiveList l = (PrimitiveList)p.dereference();
	for(PrimitivePointer key : dictionary.values()) {
	    l.add(key);
	}
        return p;
    }
    
    public PrimitivePointer contains(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitivePointer i = arguments.get(0);
            return contains(i);
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer contains(PrimitivePointer key) throws DynamicMVCException {
        PrimitivePointer p = PrimitiveFactory.create(PrimitiveBoolean.pseudocodeTypeName(), "");
        PrimitivePointer value = get(key);
        ((PrimitiveBoolean)p.dereference()).setValue(!(value.dereference() instanceof PrimitiveNull));
        return p;
    }
    
    
    public String toString() {
        
        StringBuilder sb = new StringBuilder();
        sb.append(name + ": [ ");
        
        for(PrimitivePointer key : dictionary.keySet()) {
	    PrimitivePointer value = dictionary.get(key);
            sb.append(key.toString());
	    sb.append(" => ");
	    sb.append(value.toString());
            sb.append(" , ");
        }
        
        // remove the last 3 characters " , "
        sb.replace(sb.length() - 3, sb.length(), "");
        
        sb.append(" ]");
        
        return sb.toString();
    }
    
    public PrimitiveString  toPrimitiveString() {
	PrimitiveString s = (PrimitiveString)(PrimitiveFactory.create(PrimitiveString.pseudocodeTypeName(), "s").dereference());
	s.setValue(toString());
	return s;
    }
}