/*
 *                 Sun Public License Notice
 * 
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 * 
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2004 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans.modules.java.ui.nodes.editors;

import java.beans.*;
import java.util.*;

import javax.swing.*;
import javax.jmi.reflect.JmiException;

import org.openide.*;
import org.openide.util.NbBundle;
import org.openide.util.Utilities;
import org.openide.explorer.propertysheet.ExPropertyEditor;
import org.openide.explorer.propertysheet.PropertyEnv;
import org.openide.explorer.propertysheet.editors.EnhancedCustomPropertyEditor;
import org.netbeans.jmi.javamodel.Parameter;
import org.netbeans.jmi.javamodel.JavaModelPackage;
import org.netbeans.jmi.javamodel.MultipartId;
import org.netbeans.modules.java.ui.nodes.elements.ElementNode;
import org.netbeans.modules.java.ui.nodes.elements.ElementFormat;
import org.netbeans.modules.javacore.internalapi.JavaMetamodel;

/** Property editor for array of org.netbeans.jmi.javamodel.Parameter classes
*
* @author Petr Hamernik, Jan Pokorsky
*/
public class MethodParameterArrayEditor extends PropertyEditorSupport implements ExPropertyEditor {

    /** Custom property editor Component. */
    MethodParameterArrayPanel panel;

    /** Flag for prevention of cycle in firing
    * of the properties changes.
    */
    boolean ignoreEditor = false;

    /** Flag for prevention of cycle in firing
    * of the properties changes.
    */
    boolean ignorePanel = false;
    
    private PropertyEnv env;
    
    private JavaModelPackage model;

    /**
    * @return The property value as a human editable string.
    * 
   Returns null if the value can't be expressed as an editable string.
    * 
   If a non-null value is returned, then the PropertyEditor should
    *       be prepared to parse that string back in setAsText().
    */
    public String getAsText() {
        Parameter[] params = (Parameter[]) getValue();
        String text = ""; // NOI18N
        if (params != null) {
            try {
                JavaMetamodel.getDefaultRepository().beginTrans(false);
                try {
                    text = params2String(params, ", ", false); // NOI18N
                } finally {
                    JavaMetamodel.getDefaultRepository().endTrans();
                }
            } catch (JmiException ex) {
                ErrorManager.getDefault().notify(ex);
            }
        }
        return text;
    }
    
    public static String params2String(Parameter[] params, String delimiter, boolean listJustTypes) {
        StringBuffer buf = new StringBuffer(30);
        for (int i = 0; i < params.length; i++) {
            if (i > 0)
                buf.append(delimiter); // NOI18N
            buf.append(param2String(params[i], listJustTypes));
        }
        return buf.toString();
    }
    
    private static String param2String(Parameter p, boolean listJustTypes) {
        StringBuffer sb = new StringBuffer(30);
        if (!listJustTypes && p.isFinal()) {
            sb.append("final"); // NOI18N
            sb.append(' ');
        }
        sb.append(ElementFormat.elementName(p.getType()));
        if (p.isVarArg()) {
            sb.append("..."); // NOI18N
        }

        if (!listJustTypes) {
            sb.append(' ');
            sb.append(p.getName());
        }
        return sb.toString();
    }

    /** Set the property value by parsing a given String.  May raise
    * java.lang.IllegalArgumentException if either the String is
    * badly formatted or if this kind of property can't be expressed
    * as text.
    * @param text  The string to be parsed.
    */
    public void setAsText(String text) throws IllegalArgumentException {
        throw new IllegalArgumentException("Use refactoring action instead"); // NOI18N
//        StringTokenizer tok = new StringTokenizer(text, ",", false); // NOI18N
//        ArrayList list = new ArrayList();
//        while (tok.hasMoreTokens()) {
//            String token = tok.nextToken();
//            MethodParameter par;
//            
//            try {
//                par = MethodParameter.parse(token);
//            } catch (IllegalArgumentException ex) {
//                String msg = java.text.MessageFormat.format(
//                        getString("MSG_IllegalMethodParameter"), // NOI18N
//                        new Object[] { token });
//                ErrorManager.getDefault().annotate(ex,
//			    ErrorManager.USER, null, msg, null, null);
//                throw ex;
//            }
//            for (Iterator it = list.iterator(); it.hasNext(); ) {
//                if (par.getName().equals(((MethodParameter)it.next()).getName())) {
//                    String msg = java.text.MessageFormat.format(
//                            getString("MSG_DuplicateName2"), // NOI18N
//                            new Object[] { par.getName() });
//                    IllegalArgumentException ex= new IllegalArgumentException("Ambiguous name"); // NOI18N
//                    ErrorManager.getDefault().annotate(ex,
//			    ErrorManager.USER, null,  msg, null, null);
//                    throw ex;
//                }
//            }
//            list.add(par);
//        }
//        MethodParameter[] params = new MethodParameter[list.size()];
//        list.toArray(params);
//        setValue(params);
    }

    /** Sets the value */
    public void setValue(Object o) {
        ignoreEditor = true;
        boolean saveIgnorePanel = ignorePanel;
        
        ignorePanel = false;
        super.setValue(o);
        if ((panel != null) & !saveIgnorePanel) {
            panel.setMethodParameters((Parameter[])o);
        }
        ignoreEditor = false;
    }

    /** @return true */
    public boolean supportsCustomEditor () {
        return true;
    }

    /** Create new panel for this property editor.
    * @return the visual component for editing the property
    */
    public java.awt.Component getCustomEditor () {
        if (panel == null) {
            panel = new MethodParameterArrayPanel(model);
            panel.setMnemonics(env);
            panel.setMethodParameters((Parameter[]) getValue());

            panel.addPropertyChangeListener(new PropertyChangeListener() {
                                                public void propertyChange(PropertyChangeEvent evt) {
                                                    if (!ignoreEditor && MethodParameterArrayPanel.PROP_METHOD_PARAMETERS.equals(evt.getPropertyName())) {
                                                        ignorePanel = true;
                                                        setValue(evt.getNewValue());
                                                        ignorePanel = false;
                                                    }
                                                }
                                            });

        }
        return panel;
    }

    /**
     * This method is called by the IDE to pass
     * the environment to the property editor.
     */
    public void attachEnv(PropertyEnv env) {
        this.env = env;
        model = ElementNode.getModel(env.getFeatureDescriptor());
    }
    
    /** Implementation of the abstract ObjectArrayPanel2 class.
    * It is used for editing of arrays of Identifier objects.
    */
    static class MethodParameterArrayPanel extends ObjectArrayPanel2
    implements EnhancedCustomPropertyEditor {
        /** Name of the 'methodParameters' property */
        public static final String PROP_METHOD_PARAMETERS = "methodParameters"; // NOI18N

        /** Previous value */
        Parameter[] prevValue;
        
        final JavaModelPackage javaModel;

        /** Constructor */
        public MethodParameterArrayPanel(JavaModelPackage javaModel) {
            this.javaModel = javaModel;
            prevValue = new Parameter[0];

            this.getListComponent().setCellRenderer(new DefaultListCellRenderer() {
                public java.awt.Component getListCellRendererComponent(JList list,
                        Object value, int index, boolean isSelected, boolean cellHasFocus) {
                    java.awt.Component comp = super.getListCellRendererComponent(list,
                                              value, index, isSelected, cellHasFocus);
                    if (comp == this) {
                        try {
                            JavaMetamodel.getDefaultRepository().beginTrans(false);
                            try {
                                setText(param2String((Parameter) value, false));
                            } finally {
                                JavaMetamodel.getDefaultRepository().endTrans();
                            }
                        } catch (JmiException ex) {
                            ErrorManager.getDefault().notify(ex);
                        }
                    }
                    return comp;
                }
            });
        }

        /** @return the current value
        */
        public Parameter[] getMethodParameters() {
            Parameter[] ret = new Parameter[model.size()];
            model.copyInto(ret);
            return ret;
        }

        /** Set new value
        */
        public void setMethodParameters(Parameter[] data) {
            model = new DefaultListModel();
            if (data != null) {
                for (int i = 0; i < data.length; i++)
                    model.addElement(data[i]);
            }
            this.getListComponent().setModel(model);
            modelChanged();
        }

        /** Fire the 'methodParameters' property change. */
        protected void modelChanged() {
            super.modelChanged();
            Parameter[] newValue = getMethodParameters();
            firePropertyChange(PROP_METHOD_PARAMETERS, prevValue, newValue);
            prevValue = newValue;
        }

        /** Ask user for new value.
        * @return new value or null when 
        *    operation was canceled.
        */
        protected Object insertNewValue() {
            return openInputDialog(null);
        }

        /** Ask user for edit value.
        * @param oldValue The previous value to be edited
        * @return new value or null when 
        *    operation was canceled.
        */
        protected Object editValue(Object oldValue) {
            return openInputDialog((Parameter) oldValue);
        }

        /** Show dialog and allow user to enter new method parameter.
        * @param origValue current parameter
        * @return New valid name or null if user cancel the operation.
        */
        protected Parameter openInputDialog(Parameter origValue) {
            MethodParameterPanel panel = new MethodParameterPanel();

            NotifyDescriptor desriptor = new NotifyDescriptor(
                                             panel,
                                             getString("LAB_EnterParameter"), // NOI18Nv
                                             NotifyDescriptor.OK_CANCEL_OPTION,
                                             NotifyDescriptor.PLAIN_MESSAGE, null, null);

            if (origValue != null) {
                String origTypeName = origValue.getType().getName();
                if (origValue.isVarArg()) {
                    origTypeName += "..."; // NOI18N
                }
                panel.nameTextField.setText(origValue.getName());
                panel.typeCombo.setSelectedItem(origTypeName);
                panel.finalCheckBox.setSelected(origValue.isFinal());
            }

            for (;;) {
                Object ret = DialogDisplayer.getDefault().notify(desriptor);
                if (ret == NotifyDescriptor.OK_OPTION) {
                    String errMsg = null;
                    String name = panel.nameTextField.getText().trim();
                    if (!Utilities.isJavaIdentifier(name))
                        errMsg = "MSG_NotValidID"; // NOI18N
                    else {
                        try {
                            JavaMetamodel.getDefaultRepository().beginTrans(false);
                            try {
                                boolean isFinal = panel.finalCheckBox.isSelected();
                                Enumeration methodEnum = model.elements();
                                
                                while(methodEnum.hasMoreElements()) {
                                    Parameter oldPar = (Parameter)methodEnum.nextElement();
                                                              
                                    if (origValue!=null && oldPar.equals(origValue))
                                        continue;
                                    if (name.equals(oldPar.getName())) {
                                        errMsg = "MSG_DuplicateName"; // NOI18N
                                        break;
                                    }
                                }
                                if (errMsg == null) {
                                    String typeName = panel.typeCombo.getSelectedItem().toString().trim();
                                    boolean isVarArg = typeName.endsWith("..."); // NOI18N
                                    typeName = isVarArg? typeName.substring(0, typeName.length() - 3): typeName;
                                    
//                                    Type type = javaModel.getType().resolve(typeName);
                                    // XXX Something like org.openide.src.Type.parse is needed to validate new type
//                                  errMsg = "MSG_NotValidType"; // NOI18N
                                    MultipartId typeID = javaModel.getMultipartId().createMultipartId(typeName, null, null);
                                    Parameter p = javaModel.getParameter().createParameter();
                                    p.setName(name);
                                    p.setFinal(isFinal);
//                                    p.setType(type);
                                    p.setTypeName(typeID);
                                    p.setVarArg(isVarArg);
                                    return p;
                                }
                            } finally {
                                JavaMetamodel.getDefaultRepository().endTrans();
                            }
                        } catch (JmiException ex) {
                            ErrorManager.getDefault().notify(ex);
                            return null;
                        }
                    }
                    DialogDisplayer.getDefault().notify(new NotifyDescriptor.Message(getString(errMsg)));
                } else {
                    return null;
                }
            }
        }
        
        public Object getPropertyValue() throws IllegalStateException {
            return getMethodParameters();
        }
        
    }
    
    private static String getString(String key) {
        return NbBundle.getMessage(MethodParameterArrayEditor.class, key);
    }

}