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

/*
 * PrimitivePriorityQueue.java
 *
 * Created on March 8, 2008, 2:05 AM
 *
 * 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.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.PriorityQueue;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JPanel;

/**
 *
 * @author Brandon
 */
public class PrimitivePriorityQueue extends Primitive {
    
    public static String pseudocodeTypeName() {
        return "PriorityQueue";
    }
    
     public String getType() {
         return pseudocodeTypeName();
     }
    
    private String name;
    
    private PriorityQueue<PrimitivePointer> pq;
    
    public PriorityQueue<PrimitivePointer> getPq() {
        return pq;
    }
    
    /** Creates a new instance of PrimitiveStructure */
    public PrimitivePriorityQueue() {
        super();
        
        pq = new PriorityQueue<PrimitivePointer>(5, PrimitivePriorityQueueElementComparator.getInstance());
    }
    
    public JComponent getReadOnlyComponent(){
        
        // wrap everything in a panel
        JPanel wrapper = new JPanel();
        wrapper.setName(getEditComponentWrapperName());
        
        int i = 0;
        
	PriorityQueue<PrimitivePointer> newPQ = new PriorityQueue<PrimitivePointer>(5, PrimitivePriorityQueueElementComparator.getInstance());
	while(!pq.isEmpty()) {
	    PrimitivePointer p = pq.poll();
	    
	    String name = p.getName();
            p.setName(String.valueOf(i));
            wrapper.add(p.getReadOnlyComponent());
            p.setName(name);
	    
            i++;
	    
	    newPQ.offer(p);
	}
	
	this.pq = newPQ;
        
        return wrapper;
    }
    public JComponent getEditComponent(){
        
        // wrap everything in a panel
        JPanel wrapper = new JPanel();
        wrapper.setName(getEditComponentWrapperName());
        
	// and the remove button for this element	    
	JButton removeButton = new JButton();
	removeButton.setText("Pop");
	removeButton.addActionListener(new RemoveHandler());
	wrapper.add(removeButton);
	
        int i = 0;
	PriorityQueue<PrimitivePointer> newPQ = new PriorityQueue<PrimitivePointer>(5, PrimitivePriorityQueueElementComparator.getInstance());
	while(!pq.isEmpty()) {
	    PrimitivePointer p = pq.poll();
	    
	    String name = p.getName();
            p.setName(String.valueOf(i));
            wrapper.add(p.getEditComponent());
            p.setName(name);
	    
            i++;
	    
	    newPQ.offer(p);
	}
	
	this.pq = newPQ;

        dataTypes = new javax.swing.JComboBox();
        dataTypes.setModel(new javax.swing.DefaultComboBoxModel(PrimitiveFactory.getTypeNames().toArray()));

        
        JButton addButton = new JButton();
        addButton.setText("Push");
        addButton.setName(getAddButtonName());
        addButton.addActionListener(new AddHandler());
	
	wrapper.add(dataTypes);
        wrapper.add(addButton);
        
        return wrapper;
    }
    
    javax.swing.JComboBox dataTypes;
    
    public PrimitivePriorityQueue getThis() {
        return this;
    }
    
    
    class RemoveHandler implements ActionListener {
        
        public void actionPerformed(ActionEvent e) {
            getThis().pop();
            View.updateAsk();
        }
    }
    
    class AddHandler implements ActionListener {
        
        public void actionPerformed(ActionEvent e) {
            String itemName = String.valueOf(pq.size());
            String dataType = (String)dataTypes.getSelectedItem();
            
            PrimitivePointer p = PrimitiveFactory.create(dataType, "value");
            PrimitivePointer el = PrimitiveFactory.create(PrimitivePriorityQueueElement.pseudocodeTypeName(), "priority");
                        
            try {
                ((PrimitivePriorityQueueElement)el.dereference()).setPq(getPointer());
            } catch (DynamicMVCException ex) {
                ex.printStackTrace();
            }
            
            el.setName(itemName);
            ((PrimitivePriorityQueueElement)el.dereference()).setValue(p);
            pq.add(el);
	    
            View.updateAsk();
        }
    }
    
    public String getEditComponentWrapperName(){
        return "pnl" + name;
    }
    
    public String getAddButtonName() {
        return "btnAdd";
    }
    
    public void populateFromEditComponentWrapper(JComponent editComponentWrapper) throws DynamicMVCException{
        PriorityQueue<PrimitivePointer> newPQ = new PriorityQueue<PrimitivePointer>(5, PrimitivePriorityQueueElementComparator.getInstance());
	
	// just populate each of the array values
	for(PrimitivePointer p : pq) {
            String name = p.getEditComponentName();            
            JComponent child = (JComponent)View.getComponent(editComponentWrapper, name);            
            p.populateFromEditComponentWrapper(child);
	    
	    newPQ.offer(p);
        }
	
	this.pq = newPQ;
    }
    
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
        
    public Primitive copy() throws DynamicMVCException {
        
        PrimitivePriorityQueue q = new PrimitivePriorityQueue();
        
        q.setName(name);
        
        for(PrimitivePointer p : pq) {
            q.push(p);
        }

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

        return q;
    }
    
    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());
	
        PrimitivePriorityQueue q = (PrimitivePriorityQueue)pp.dereference();	        
        q.setName(name);
        
        for(PrimitivePointer qe : pq) {
            q.push(qe.deepCopy(alreadyCopiedAddresses));
        }

        super.deepCopyDefinedProperties(q, alreadyCopiedAddresses);

        return q;
    }
    
    public boolean deepEquals(Primitive p) throws DynamicMVCException {
        if (!(p instanceof PrimitivePriorityQueue)) {
	    DynamicController.errorMessage = "Expecting Priority Queue, but found " + p.getType();
            return false;
        }
        
        PrimitivePriorityQueue o = (PrimitivePriorityQueue)p;
        
        if (pq.size() != o.getPq().size()) {
	    DynamicController.errorMessage = "Wrong priority queue size.  Expecting '" + pq.size() + "', but found '" + o.getPq().size() + "'.";
            return false;
        }
        
        PrimitivePointer[] me = (PrimitivePointer[]) pq.toArray(new PrimitivePointer[0]);
	PrimitivePointer[] him = (PrimitivePointer[]) o.getPq().toArray(new PrimitivePointer[0]);
        
	Arrays.sort(me, PrimitivePriorityQueueElementComparator.getInstance());
	Arrays.sort(him, PrimitivePriorityQueueElementComparator.getInstance());
	
        for(int i = 0; i < pq.size(); i++) {
            PrimitivePointer myP = me[i];
            PrimitivePointer otherP = him[i];
            
            if (!myP.deepEquals(otherP)) {
                return false;
            }
        }
        
        return super.deepEqualsDefinedProperties(p);
    }
    
    public PrimitivePointer execute(String methodName, ArrayList<PrimitivePointer> arguments) throws DynamicMVCException{
        if (methodName.equalsIgnoreCase("push")) {
            push(arguments);
            return null;
        } else if (methodName.equalsIgnoreCase("pop")) {
            return pop(arguments);
        } else if (methodName.equalsIgnoreCase("remove")) {        
            remove(arguments);
            return null;
        } else if (methodName.equalsIgnoreCase("length")) {
            return length(arguments);
        } else if (methodName.equalsIgnoreCase("contains")) {
	    return contains(arguments);
	} else if (methodName.equalsIgnoreCase("isEmpty")) {
            return isEmpty(arguments);
        }
        throw new DynamicMVCException ("Object: '" + name + "' does not support method '" + methodName + "'.");
    }
    
    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() throws DynamicMVCException {
        PrimitivePointer pb = PrimitiveFactory.create(PrimitiveBoolean.pseudocodeTypeName(), "isEmpty");
        PrimitiveBoolean b = (PrimitiveBoolean)pb.dereference();
        b.setValue(this.pq.isEmpty());
        return pb;
    }
    
    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 index) throws DynamicMVCException {
        Primitive value = index.dereference();
	return contains(value);
    }
    
    public PrimitivePointer contains(Primitive value) throws DynamicMVCException {
        PrimitivePointer retValue = PrimitiveFactory.create(PrimitiveBoolean.pseudocodeTypeName(), "retValue");
	PrimitiveBoolean r = (PrimitiveBoolean)retValue.dereference();
	r.setValue(false);
	
	for(PrimitivePointer pqe : pq.toArray(new PrimitivePointer[0])) {
	    PrimitivePriorityQueueElement element = (PrimitivePriorityQueueElement)pqe.dereference();
	    if(element.getValue().deepEquals(value)) {
		r.setValue(true);
		break;
	    }
	}
	
	return retValue;
    }
    
    public void push(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 2) {
            // reverse order
            PrimitivePointer priority = arguments.get(1);
            
            PrimitivePointer value = arguments.get(0);
            
            if (priority.dereference() instanceof PrimitiveInteger) {
                push(value, priority);
            } else {
                push(value, (PrimitiveString)priority.dereference());
            }
        } else if (arguments.size() == 1) {
            PrimitivePointer e = arguments.get(0);
            push(e);
        } else {        
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public void push(PrimitivePointer e) {
        pq.add(e);
        updateNames();
    }
    
    public void push (PrimitivePointer value, PrimitivePointer priority) {
        PrimitivePointer p = priority.copy();
        p.setName("priority");
        String itemName = String.valueOf(pq.size());
        
        PrimitivePointer pp = PrimitiveFactory.create(PrimitivePriorityQueueElement.pseudocodeTypeName(), itemName);
        ((PrimitivePriorityQueueElement)pp.dereference()).setPriority(p);
        ((PrimitivePriorityQueueElement)pp.dereference()).setValue(value);
        
        pq.add(pp);
        updateNames();
    }
    
    public void push (PrimitivePointer value, PrimitiveString property) throws DynamicMVCException {
        PrimitivePointer priority = value.dereference().get(property.getValue());
        push(value, priority);
    }
    
    public PrimitivePointer pop(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 0) {
            PrimitivePointer p = pop(); 
            return p;
        } else if (arguments.size() == 1) {
            PrimitivePointer retVal = arguments.get(0);
            PrimitivePointer p = pop(retVal);
            return p;
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public PrimitivePointer pop() {
        PrimitivePointer p = ((PrimitivePriorityQueueElement)pq.poll().dereference()).getValue();
        updateNames();
        return p;
    }
    
    public PrimitivePointer pop(PrimitivePointer retVal) {
        PrimitivePriorityQueueElement e = (PrimitivePriorityQueueElement)pq.poll().dereference();
        updateNames();
        ((PrimitiveInteger)retVal.dereference()).setValue(((PrimitiveInteger)e.getPriority().dereference()).getValue());
        return e.getValue();
    }
    
    public void remove(ArrayList<PrimitivePointer> arguments) throws DynamicMVCException {
        if (arguments.size() == 1) {
            PrimitivePointer i = arguments.get(0);
            remove(i);
            updateNames();
        } else {
            throw new DynamicMVCException("Wrong number of arguments.");
        }
    }
    
    public void remove(PrimitivePointer index) throws DynamicMVCException {
        int i = ((PrimitiveInteger)index.dereference()).getValue();
        pq.remove(i);
        updateNames();
    }
    
    public void remove(int index) {
        pq.remove(index);
        updateNames();
    }
    
    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 p = PrimitiveFactory.create(PrimitiveInteger.pseudocodeTypeName(), "");
        ((PrimitiveInteger)p.dereference()).setValue(pq.size());
        return p;
    }
    
    public String toString() {
        
        StringBuilder sb = new StringBuilder();
        sb.append(name + ": [ ");
        
        for(PrimitivePointer p : pq) {
            sb.append(p.toString());
            sb.append(" , ");
        }
        
        // remove the last 3 characters " , "
        sb.replace(sb.length() - 3, sb.length(), "");
        
        sb.append(" ]");
        
        return sb.toString();
    }
    
    public void updateNames() {
        int i = 0;
        for(PrimitivePointer e : pq) {
            e.setName(String.valueOf(i));
            i++;
        }
    }
    
    public PrimitiveString  toPrimitiveString() {
	PrimitiveString s = (PrimitiveString)(PrimitiveFactory.create(PrimitiveString.pseudocodeTypeName(), "s").dereference());
	s.setValue(toString());
	return s;
    }
}