/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * particular file as subject to the "Classpath" exception as provided

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

package com.sun.tools.example.debug.expr;

import com.sun.jdi.*;

import java.util.*;

abstract class LValue {

    // The JDI Value object for this LValue.  Once we have this Value,

    // we have to remember it since after we return the LValue object

    // to the ExpressionParser, it might decide that it needs

    // the 'toString' value for the LValue in which case it will

    // call getMassagedValue to get this toString value.  At that

    // point, we don't want to call JDI a 2nd time to get the Value

    // for the LValue.  This is especially wrong when the LValue

    // represents a member function.  We would end up calling it

    // a 2nd time.

    //

    // Unfortunately, there are several levels of calls to

    // get/set values in this file.  To minimize confusion,

    // jdiValue is set/tested at the lowest level - right

    // next to the actual calls to JDI methods to get/set the

    // value in the debuggee.

    protected Value jdiValue;

    abstract Value getValue() throws InvocationException,

                                     IncompatibleThreadStateException,

                                     InvalidTypeException,

                                     ClassNotLoadedException,

                                     ParseException;

    abstract void setValue0(Value value)

                   throws ParseException, InvalidTypeException,

                          ClassNotLoadedException;

    abstract void invokeWith(List<Value> arguments) throws ParseException;

    void setValue(Value value) throws ParseException {

        try {

            setValue0(value);

        } catch (InvalidTypeException exc) {

            throw new ParseException(

                "Attempt to set value of incorrect type" +

                exc);

        } catch (ClassNotLoadedException exc) {

            throw new ParseException(

                "Attempt to set value before " + exc.className() + " was loaded" +

                exc);

        }

    }

    void setValue(LValue lval) throws ParseException {

        setValue(lval.interiorGetValue());

    }

    LValue memberLValue(ExpressionParser.GetFrame frameGetter,

                        String fieldName) throws ParseException {

        try {

            return memberLValue(fieldName, frameGetter.get().thread());

        } catch (IncompatibleThreadStateException exc) {

            throw new ParseException("Thread not suspended");

        }

    }

    LValue memberLValue(String fieldName, ThreadReference thread) throws ParseException {

        Value val = interiorGetValue();

        if ((val instanceof ArrayReference) &&

            "length".equals(fieldName)){

            return new LValueArrayLength((ArrayReference)val);

        }

        return new LValueInstanceMember(val, fieldName, thread);

    }

    // Return the Value for this LValue that would be used to concatenate

    // to a String.  IE, if it is an Object, call toString in the debuggee.

    Value getMassagedValue(ExpressionParser.GetFrame frameGetter) throws ParseException {

        Value vv = interiorGetValue();

        // If vv is an ObjectReference, then we have to

        // do the implicit call to toString().

        if (vv instanceof ObjectReference &&

            !(vv instanceof StringReference) &&

            !(vv instanceof ArrayReference)) {

            StackFrame frame;

            try {

                frame = frameGetter.get();

            } catch (IncompatibleThreadStateException exc) {

                throw new ParseException("Thread not suspended");

            }

            ThreadReference thread = frame.thread();

            LValue toStringMember = memberLValue("toString", thread);

            toStringMember.invokeWith(new ArrayList<Value>());

            return toStringMember.interiorGetValue();

        }

        return vv;

    }

    Value interiorGetValue() throws ParseException {

        Value value;

        try {

            value = getValue();

        } catch (InvocationException e) {

            throw new ParseException("Unable to complete expression. Exception " +

                                     e.exception() + " thrown");

        } catch (IncompatibleThreadStateException itse) {

            throw new ParseException("Unable to complete expression. Thread " +

                                     "not suspended for method invoke");

        } catch (InvalidTypeException ite) {

            throw new ParseException("Unable to complete expression. Method " +

                                     "argument type mismatch");

        } catch (ClassNotLoadedException tnle) {

            throw new ParseException("Unable to complete expression. Method " +

                                     "argument type " + tnle.className() +

                                     " not yet loaded");

        }

        return value;

    }

    LValue arrayElementLValue(LValue lval) throws ParseException {

        Value indexValue = lval.interiorGetValue();

        int index;

        if ( (indexValue instanceof IntegerValue) ||

             (indexValue instanceof ShortValue) ||

             (indexValue instanceof ByteValue) ||

             (indexValue instanceof CharValue) ) {

            index = ((PrimitiveValue)indexValue).intValue();

        } else {

            throw new ParseException("Array index must be a integer type");

        }

        return new LValueArrayElement(interiorGetValue(), index);

    }

    public String toString() {

        try {

            return interiorGetValue().toString();

        } catch (ParseException e) {

            return "<Parse Exception>";

        }

    }

    static final int STATIC = 0;

    static final int INSTANCE = 1;

    static Field fieldByName(ReferenceType refType, String name, int kind) {

        /*

         * TO DO: Note that this currently fails to find superclass

         * or implemented interface fields. This is due to a temporary

         * limititation of RefType.fieldByName. Once that method is

         * fixed, superclass fields will be found.

         */

        Field field = refType.fieldByName(name);

        if (field != null) {

            boolean isStatic = field.isStatic();

            if (((kind == STATIC) && !isStatic) ||

                ((kind == INSTANCE) && isStatic)) {

                field = null;

            }

        }

/***

        System.err.println("fieldByName: " + refType.name() + " " +

                                             name + " " +

                                             kind + " " +

                                             (field != null));

***/

        return field;

    }

    static List<Method> methodsByName(ReferenceType refType,

                                      String name, int kind) {

        List<Method> list = refType.methodsByName(name);

        Iterator<Method> iter = list.iterator();

        while (iter.hasNext()) {

            Method method = iter.next();

            boolean isStatic = method.isStatic();

            if (((kind == STATIC) && !isStatic) ||

                ((kind == INSTANCE) && isStatic)) {

                iter.remove();

            }

        }

        return list;

    }

    static List<String> primitiveTypeNames = new ArrayList<String>();

    static {

        primitiveTypeNames.add("boolean");

        primitiveTypeNames.add("byte");

        primitiveTypeNames.add("char");

        primitiveTypeNames.add("short");

        primitiveTypeNames.add("int");

        primitiveTypeNames.add("long");

        primitiveTypeNames.add("float");

        primitiveTypeNames.add("double");

    }

    static final int SAME = 0;

    static final int ASSIGNABLE = 1;

    static final int DIFFERENT = 2;

    /*

     * Return SAME, DIFFERENT or ASSIGNABLE.

     * SAME means each arg type is the same as type of the corr. arg.

     * ASSIGNABLE means that not all the pairs are the same, but

     * for those that aren't, at least the argType is assignable

     * from the type of the argument value.

     * DIFFERENT means that in at least one pair, the

     * argType is not assignable from the type of the argument value.

     * IE, one is an Apple and the other is an Orange.

     */

    static int argumentsMatch(List<Type> argTypes, List<Value> arguments) {

        if (argTypes.size() != arguments.size()) {

            return DIFFERENT;

        }

        Iterator<Type> typeIter = argTypes.iterator();

        Iterator<Value> valIter = arguments.iterator();

        int result = SAME;

        // If any pair aren't the same, change the

        // result to ASSIGNABLE.  If any pair aren't

        // assignable, return DIFFERENT

        while (typeIter.hasNext()) {

            Type argType = typeIter.next();

            Value value = valIter.next();

            if (value == null) {

                // Null values can be passed to any non-primitive argument

                if (primitiveTypeNames.contains(argType.name())) {

                    return DIFFERENT;

                }

                // Else, we will assume that a null value

                // exactly matches an object type.

            }

            if (!value.type().equals(argType)) {

                if (isAssignableTo(value.type(), argType)) {

                    result = ASSIGNABLE;

                } else {

                    return DIFFERENT;

                }

            }

        }

        return result;

    }

    // These is...AssignableTo methods are based on similar code in the JDI

    // implementations of ClassType, ArrayType, and InterfaceType

    static boolean isComponentAssignable(Type fromType, Type toType) {

        if (fromType instanceof PrimitiveType) {

            // Assignment of primitive arrays requires identical

            // component types.

            return fromType.equals(toType);

        }

        if (toType instanceof PrimitiveType) {

            return false;

        }

        // Assignment of object arrays requires availability

        // of widening conversion of component types

        return isAssignableTo(fromType, toType);

    }

    static boolean isArrayAssignableTo(ArrayType fromType, Type toType) {

        if (toType instanceof ArrayType) {

            try {

                Type toComponentType = ((ArrayType)toType).componentType();

                return isComponentAssignable(fromType.componentType(), toComponentType);

            } catch (ClassNotLoadedException e) {

                // One or both component types has not yet been

                // loaded => can't assign

                return false;

            }

        }

        if (toType instanceof InterfaceType) {

            // Only valid InterfaceType assignee is Cloneable

            return toType.name().equals("java.lang.Cloneable");

        }

        // Only valid ClassType assignee is Object

        return toType.name().equals("java.lang.Object");

    }

    static boolean isAssignableTo(Type fromType, Type toType) {

        if (fromType.equals(toType)) {

            return true;

        }

        // If one is boolean, so must be the other.

        if (fromType instanceof BooleanType) {

            if (toType instanceof BooleanType) {

                return true;

            }

            return false;

        }

        if (toType instanceof BooleanType) {

            return false;

        }

        // Other primitive types are intermixable only with each other.

        if (fromType instanceof PrimitiveType) {

            if (toType instanceof PrimitiveType) {

                return true;

            }

            return false;

        }

        if (toType instanceof PrimitiveType) {

            return false;

        }

        // neither one is primitive.

        if (fromType instanceof ArrayType) {

            return isArrayAssignableTo((ArrayType)fromType, toType);

        }

        List<InterfaceType> interfaces;

        if (fromType instanceof ClassType) {

            ClassType superclazz = ((ClassType)fromType).superclass();

            if ((superclazz != null) && isAssignableTo(superclazz, toType)) {

                return true;

            }

            interfaces = ((ClassType)fromType).interfaces();

        } else {

            // fromType must be an InterfaceType

            interfaces = ((InterfaceType)fromType).superinterfaces();

        }

        for (InterfaceType interfaze : interfaces) {

            if (isAssignableTo(interfaze, toType)) {

                return true;

            }

        }

        return false;

    }

    static Method resolveOverload(List<Method> overloads,

                                  List<Value> arguments)

                                       throws ParseException {

        // If there is only one method to call, we'll just choose

        // that without looking at the args.  If they aren't right

        // the invoke will return a better error message than we

        // could generate here.

        if (overloads.size() == 1) {

            return overloads.get(0);

        }

        // Resolving overloads is beyond the scope of this exercise.

        // So, we will look for a method that matches exactly the

        // types of the arguments.  If we can't find one, then

        // if there is exactly one method whose param types are assignable

        // from the arg types, we will use that.  Otherwise,

        // it is an error.  We won't guess which of multiple possible

        // methods to call. And, since casts aren't implemented,

        // the user can't use them to pick a particular overload to call.

        // IE, the user is out of luck in this case.

        Method retVal = null;

        int assignableCount = 0;

        for (Method mm : overloads) {

            List<Type> argTypes;

            try {

                argTypes = mm.argumentTypes();

            } catch (ClassNotLoadedException ee) {

                // This probably won't happen for the

                // method that we are really supposed to

                // call.

                continue;

            }

            int compare = argumentsMatch(argTypes, arguments);

            if (compare == SAME) {

                return mm;

            }

            if (compare == DIFFERENT) {

                continue;

            }

            // Else, it is assignable.  Remember it.

            retVal = mm;

            assignableCount++;

        }

        // At this point, we didn't find an exact match,

        // but we found one for which the args are assignable.

        //

        if (retVal != null) {

            if (assignableCount == 1) {

                return retVal;

            }

            throw new ParseException("Arguments match multiple methods");

        }

        throw new ParseException("Arguments match no method");

    }

    private static class LValueLocal extends LValue {

        final StackFrame frame;

        final LocalVariable var;

        LValueLocal(StackFrame frame, LocalVariable var) {

            this.frame = frame;

            this.var = var;

        }

        Value getValue() {

            if (jdiValue == null) {

                jdiValue = frame.getValue(var);

            }

            return jdiValue;

        }

        void setValue0(Value val) throws InvalidTypeException,

                                         ClassNotLoadedException {

            frame.setValue(var, val);

            jdiValue = val;

        }

        void invokeWith(List<Value> arguments) throws ParseException {

            throw new ParseException(var.name() + " is not a method");

        }

    }

    private static class LValueInstanceMember extends LValue {

        final ObjectReference obj;

        final ThreadReference thread;

        final Field matchingField;

        final List<Method> overloads;

        Method matchingMethod = null;

        List<Value> methodArguments = null;

        LValueInstanceMember(Value value,

                            String memberName,

                            ThreadReference thread) throws ParseException {

            if (!(value instanceof ObjectReference)) {

                throw new ParseException(

                       "Cannot access field of primitive type: " + value);

            }

            this.obj = (ObjectReference)value;

            this.thread = thread;

            ReferenceType refType = obj.referenceType();

            /*

             * Can't tell yet whether this LValue will be accessed as a

             * field or method, so we keep track of all the possibilities

             */

            matchingField = LValue.fieldByName(refType, memberName,

                                               LValue.INSTANCE);

            overloads = LValue.methodsByName(refType, memberName,

                                              LValue.INSTANCE);

            if ((matchingField == null) && overloads.size() == 0) {

                throw new ParseException("No instance field or method with the name "

                               + memberName + " in " + refType.name());

            }

        }

        Value getValue() throws InvocationException, InvalidTypeException,

                                ClassNotLoadedException, IncompatibleThreadStateException,

                                ParseException {

            if (jdiValue != null) {

                return jdiValue;

            }

            if (matchingMethod == null) {

                if (matchingField == null) {

                    throw new ParseException("No such field in " + obj.referenceType().name());

                }

                return jdiValue = obj.getValue(matchingField);

            } else {

                return jdiValue = obj.invokeMethod(thread, matchingMethod, methodArguments, 0);

            }

        }

        void setValue0(Value val) throws ParseException,

                                         InvalidTypeException,

                                        ClassNotLoadedException {

            if (matchingMethod != null) {

                throw new ParseException("Cannot assign to a method invocation");

            }

            obj.setValue(matchingField, val);

            jdiValue = val;

        }

        void invokeWith(List<Value> arguments) throws ParseException {

            if (matchingMethod != null) {

                throw new ParseException("Invalid consecutive invocations");

            }

            methodArguments = arguments;

            matchingMethod = LValue.resolveOverload(overloads, arguments);

        }

    }

    private static class LValueStaticMember extends LValue {

        final ReferenceType refType;

        final ThreadReference thread;

        final Field matchingField;

        final List<Method> overloads;

        Method matchingMethod = null;

        List<Value> methodArguments = null;

        LValueStaticMember(ReferenceType refType,

                          String memberName,

                          ThreadReference thread) throws ParseException {

            this.refType = refType;

            this.thread = thread;

            /*

             * Can't tell yet whether this LValue will be accessed as a

             * field or method, so we keep track of all the possibilities

             */

            matchingField = LValue.fieldByName(refType, memberName,

                                               LValue.STATIC);