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

/*
 * PrimitiveList.java
 *
 * Created on March 4, 2008, 8:02 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package dynamicmvc;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.HashMap;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JPanel;

/**
 *
 * @author Brandon
 */
public class PrimitiveList extends Primitive {
    
    public static String pseudocodeTypeName() {
        return "List";
    }
    
     public String getType() {
         return pseudocodeTypeName();
     }
    
    private String name;
    
    private ArrayList<PrimitivePointer> list;
    
    public ArrayList<PrimitivePointer> getList() {
        return list;
    }
    
    /** Creates a new instance of PrimitiveStructure */
    public PrimitiveList() {
        super();
        
        list = new ArrayList<PrimitivePointer>();
    }
    
    public JComponent getReadOnlyComponent(){
        
        // wrap everything in a panel
        JPanel wrapper = new JPanel();
        wrapper.setName(getEditComponentWrapperName());
        
        // for each thing in the list
        int i = 0;
        for(PrimitivePointer p : list) {
            String name = p.getName();
            p.setName(String.valueOf(i));
            wrapper.add(p.getReadOnlyComponent());
            p.setName(name);
            i++;
        }
        
        return wrapper;
    }
    public JComponent getEditComponent(){
        
        // wrap everything in a panel
        JPanel wrapper = new JPanel();
        wrapper.setName(getEditComponentWrapperName());
        
        // for each thing in the list
        int i = 0;
        for(PrimitivePointer p : list) {
            String name = p.getName();
            p.setName(String.valueOf(i));
            wrapper.add(p.getEditComponent());
            p.setName(name);
            i++;
        }
        
        // also, add a button to allow new inputs
        dataTypes = new javax.swing.JComboBox();
        dataTypes.setModel(new javax.swing.DefaultComboBoxModel(PrimitiveFactory.getTypeNames().toArray()));
        
        JButton addButton = new JButton();
        addButton.setText("Add");
        addButton.setName(getAddButtonName());
        addButton.addActionListener(new AddHandler());
        
        wrapper.add(dataTypes);
        wrapper.add(addButton);
        
        return wrapper;
    }
    
    javax.swing.JComboBox dataTypes;
    
    class AddHandler implements ActionListener {
        
        public void actionPerformed(ActionEvent e) {
            // assume the actionCommand tells what type of item to add
            String dataType = (String)dataTypes.getSelectedItem();
            PrimitivePointer p = PrimitiveFactory.create(dataType, "");
            add(p);
            View.updateAsk();
        }
    }
    
    public String getEditComponentWrapperName(){
        return "pnl" + name;
    }
    
    public String getAddButtonName() {
        return "btnAdd";
    }
    
    public void populateFromEditComponentWrapper(JComponent editComponentWrapper) throws DynamicMVCException {
        // just populate each of the array values
        for(PrimitivePointer p : list) {
            String name = p.getEditComponentName();
            
            JComponent child = (JComponent)View.getComponent(editComponentWrapper, name);
            
            p.populateFromEditComponentWrapper(child);
        }
    }
    
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    
    public Primitive copy() throws DynamicMVCException {
        
        PrimitiveList l = new PrimitiveList();
        
        l.name = name;
        
        for(PrimitivePointer p : list) {
            l.add(p.copy());
        }

        for(PrimitivePointer p : getDefinedProperties().values()) {
            l.set(p.dereference().getName(), p.copy());
        }

        return l;
    }
    
    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);
	PrimitiveList l = (PrimitiveList)pp.dereference();
        l.name = name;
	
	alreadyCopiedAddresses.put(p.getAddress(), pp.getAddress());
        
        for(PrimitivePointer lp : list) {
            l.add(lp.deepCopy(alreadyCopiedAddresses));
        }
        
        super.deepCopyDefinedProperties(l, alreadyCopiedAddresses);
        
        return l;
    }
    
    public boolean deepEquals(Primitive p) throws DynamicMVCException {
        if (!(p instanceof PrimitiveList)) {
	    DynamicController.errorMessage = "Expecting List, but found " + p.getType();
            return false;
        }
        
        PrimitiveList l = (PrimitiveList)p;
        
        if (list.size() != l.getList().size()) {
	    DynamicController.errorMessage = "Wrong list size.  Expecting '" + list.size() + "', but found '" + l.getList().size() + "'.";
            return false;
        }
        
        for(int i = 0; i < list.size(); i++) {
            PrimitivePointer myP = list.get(i);
            PrimitivePointer otherP = l.get(i);
            
            if (!myP.deepEquals(otherP)) {
                return false;
            }
        }
        
        return super.deepEqualsDefinedProperties(p);
    }
    
    public PrimitivePointer execute(String methodName, ArrayList<PrimitivePointer> arguments) throws DynamicMVCException{
        if (methodName.equals("add")) {
            add(arguments);
            return null;
        } else if (methodName.equals("get")) {
            return get(arguments);
        } else if (methodName.equals("remove")) {
            remove(arguments);
            return null;
        } else if (methodName.equals("length")) {
            return length(arguments);
        }else if (methodName.equals("contains")) {
            return contains(arguments);
        }else if (methodName.equals("doesNotContain")) {
            return doesNotContain(arguments);
        } else if (methodName.equals("set")) {
	    return set(arguments);
	}
        throw new DynamicMVCException ("Object: '" + name + "' does not support method '" + methodName + "'.");
    }
    
    public PrimitivePointer set(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 2) {
            return set(arguments.get(0), arguments.get(1));
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer set(PrimitivePointer index, PrimitivePointer value) throws DynamicMVCException {
	
	if(!index.dereference().getType().equals(PrimitiveInteger.pseudocodeTypeName())) {
	    throw new DynamicMVCException("Invalid argument: " + index.toString());
	}
	PrimitiveInteger i = (PrimitiveInteger)index.dereference();
	return set(i, value);
    }
    
    public PrimitivePointer set(PrimitiveInteger index, PrimitivePointer value) {
	
	int i = index.getValue();
	
	while(list.size() <= i) {
	    list.add(PrimitiveFactory.create(PrimitiveNull.pseudocodeTypeName(), "null"));
	}
	
	list.set(i, value);
	
	return PrimitiveFactory.create(PrimitiveNull.pseudocodeTypeName(), "return");
    }
    
    public PrimitivePointer doesNotContain(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            return doesNotContain(arguments.get(0));
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer contains(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            return contains(arguments.get(0));
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer contains(PrimitivePointer p) {
        PrimitivePointer result = PrimitiveFactory.create(PrimitiveBoolean.pseudocodeTypeName(), "");
        PrimitiveBoolean pb = (PrimitiveBoolean)result.dereference();
	
	for(PrimitivePointer pp : list) {
	    if (pp.valueEquals(p)) {
		pb.setValue(true);
		return result;
	    }
	}
	
	pb.setValue(false);
	return result;
    }  
    
    public PrimitivePointer doesNotContain(PrimitivePointer p) {
        PrimitivePointer result = PrimitiveFactory.create(PrimitiveBoolean.pseudocodeTypeName(), "");
        PrimitiveBoolean pb = (PrimitiveBoolean)result.dereference();
	
	for(PrimitivePointer pp : list) {
	    if (pp.valueEquals(p)) {
		pb.setValue(false);
		return result;
	    }
	}
	
	pb.setValue(true);
	return result;
    }            
    
    public void add(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitivePointer p = arguments.get(0);
            add(p);
        } else {        
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public void add(PrimitivePointer p) {
        // assign the name to be <listName><Index>
        //p.setName(name + list.size());
        // create a new pointer, and set its name
        PrimitivePointer pp = p.copy();
        pp.setName(String.valueOf(list.size()));
        list.add(pp);
    }
    
    public PrimitivePointer get(String name) throws DynamicMVCException {
        if (name.equalsIgnoreCase("length")) {
            PrimitivePointer p = PrimitiveFactory.create(PrimitiveInteger.pseudocodeTypeName(), "length");
            ((PrimitiveInteger)p.dereference()).setValue(list.size());
            return p;
        } else {
            return super.get(name);
        }    
    }
    
    public PrimitivePointer get(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitiveInteger i = (PrimitiveInteger)arguments.get(0).dereference();
            return get(i);
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer get(PrimitiveInteger index) {
        return list.get(index.getValue());
    }
    
    public PrimitivePointer get(int index) {
        return list.get(index);
    }
    
    public void remove(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            // this could either be the index or the actual thing to remove
            if(!remove(arguments.get(0))) {
                PrimitiveInteger i = (PrimitiveInteger)arguments.get(0).dereference();
                remove(i);
            }
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public boolean remove(PrimitivePointer item) throws DynamicMVCException {
        for(int i = 0; i < list.size(); i++) {
            if(list.get(i).deepEquals(item)) {
                list.remove(i);
                return true;
            }
        }
        
        return false;
    }
    
    public void remove(PrimitiveInteger index) throws DynamicMVCException {
        int i = index.getValue();
        list.remove(i);
    }
    
    public void remove(int index) {
        list.remove(index);
    }
    
    public PrimitivePointer length(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 0) {
            return length();
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer length() {
        PrimitivePointer l = PrimitiveFactory.create(PrimitiveInteger.pseudocodeTypeName(), "");
        ((PrimitiveInteger)l.dereference()).setValue(list.size());
        return l;
    }
    
    public String toString() {
        
        StringBuilder sb = new StringBuilder();
        sb.append(name + ": [ ");
        
        for(PrimitivePointer p : list) {
            sb.append(p.toString());
            sb.append(" , ");
        }
        
        // remove the last 3 characters " , "
        if (list.size() > 0) {
            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;
    }
}