/*

 * Copyright 2008-2009 Sun Microsystems, Inc.  All Rights Reserved.

 * 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

 * published by the Free Software Foundation.  Sun designates this

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

 * by Sun in the LICENSE file that accompanied this code.

 *

 * 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 Sf, tifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.dyn;

import java.dyn.JavaMethodHandle;

import java.dyn.MethodHandle;

import java.dyn.MethodType;

import java.dyn.NoAccessException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

/**

 * "Flyby adapters" which apply arbitrary conversions to arguments

 * on the way to a ultimate target.

 * For simplicity, these are all generically typed.

 * @author jrose

 */

class FilterGeneric {

    // type for the outgoing call (will be generic)

    private final MethodType targetType;

    // position of (first) argument to participate in filtering

    private final short argumentPosition;

    // number of arguments to participate in filtering

    private final short argumentCount;

    // how the result interacts with the filtered arguments: Prepend, Append, Replace, Discard

    private final char replaceMode;

    // prototype adapter (clone and customize for each new target & conversion!)

    private final Adapter adapter;

    // entry point for adapter (Adapter mh, a...) => ...

    private final MethodHandle entryPoint;

    // more of them (loosely cached)

    private FilterGeneric variations;

    /** Compute and cache information common to all unboxing adapters

     *  that can call out to targets of the erasure-family of the given erased type.

     */

    // TO DO: Make this private.

    FilterGeneric(MethodType targetType, short argumentPosition, short argumentCount, char replaceMode) {

        if (argumentCount == 0) {

            if (replaceMode == 'P' || replaceMode == 'A')  replaceMode = 'R';

            if (replaceMode == 'I')  argumentPosition = 0;

        }

        this.targetType = targetType;

        this.argumentPosition = argumentPosition;

        this.argumentCount = argumentCount;

        this.replaceMode = replaceMode;

        validate(targetType, argumentPosition, argumentCount, replaceMode);

        Adapter ad = findAdapter(targetType, argumentPosition, argumentCount, replaceMode, filterType());

        if (ad == null)

            ad = buildAdapterFromBytecodes(targetType, argumentPosition, argumentCount, replaceMode, filterType());

        this.adapter = ad;

        this.entryPoint = ad.prototypeEntryPoint();

    }

    Adapter makeInstance(MethodHandle filter, MethodHandle target) {

        return adapter.makeInstance(entryPoint, filter, target);

    }

    /** Build an adapter of the given generic type, which invokes typedTarget

     *  on the incoming arguments, after unboxing as necessary.

     *  The return value is boxed if necessary.

     * @param genericType  the required type of the result

     * @param typedTarget the target

     * @return an adapter method handle

     */

    public static MethodHandle make(MethodHandle target, int pos, MethodHandle filter) {

        return FilterGeneric.of(target.type(), (short)pos, (short)1, 'R').makeInstance(filter, target);

    }

    /** Return the adapter information for this type's erasure. */

    static FilterGeneric of(MethodType type, short ap, short ac, char mode) {

        if (type.generic() != type)

            throw new IllegalArgumentException("must be generic: "+type);

        validate(type, ap, ac, mode);

        MethodTypeImpl form = MethodTypeImpl.of(type);

        FilterGeneric filterGen = form.filterGeneric;

        if (filterGen == null)

            form.filterGeneric = filterGen = new FilterGeneric(type, (short)0, (short)1, 'R');

        return find(filterGen, ap, ac, mode);

    }

    static FilterGeneric find(FilterGeneric gen, short ap, short ac, char mode) {

        for (;;) {

            if (gen.argumentPosition == ap &&

                gen.argumentCount == ac &&

                gen.replaceMode == mode) {

                return gen;

            }

            FilterGeneric gen2 = gen.variations;

            if (gen2 == null)  break;

            gen = gen2;

        }

        FilterGeneric gen2 = new FilterGeneric(gen.targetType, ap, ac, mode);

        gen.variations = gen2;  // OK if this smashes another cached chain

        return gen2;

    }

    private static void validate(MethodType type, short ap, short ac, char mode) {

        int endpos = ap + ac;

        switch (mode) {

            case 'P': case 'A': case 'R': case 'D':

                if (ap >= 0 && ac >= 0 &&

                        endpos >= 0 && endpos <= type.parameterCount())

                    return;

            default:

                throw new InternalError("configuration "+patternName(ap, ac, mode));

        }

    }

    public String toString() {

        return "FilterGeneric/"+patternName()+targetType;

    }

    String patternName() {

        return patternName(argumentPosition, argumentCount, replaceMode);

    }

    static String patternName(short ap, short ac, char mode) {

        return ""+mode+ap+(ac>1?"_"+ac:"");

    }

    Class<?> filterType() {

        return Object.class;  // result of filter operation; an uninteresting type

    }

    static MethodType targetType(MethodType entryType, short ap, short ac, char mode,

                                 Class<?> arg) {

        MethodType type = entryType;

        int pos = ap;

        switch (mode) {

            case 'A':

                pos += ac;

            case 'P':

                type = type.insertParameterType(pos, arg);

                break;

            case 'I':

                for (int i = 1; i < ac; i++)

                    type = type.dropParameterType(pos);

                assert(type.parameterType(pos) == arg);

                break;

            case 'D':

                break;

        }

        return type;

    }

    static MethodType entryType(MethodType targetType, short ap, short ac, char mode,

                                Class<?> arg) {

        MethodType type = targetType;

        int pos = ap;

        switch (mode) {

            case 'A':

                pos += ac;

            case 'P':

                type = type.dropParameterType(pos);

                break;

            case 'I':

                for (int i = 1; i < ac; i++)

                    type = type.insertParameterType(pos, arg);

                assert(type.parameterType(pos) == arg);

                break;

            case 'D':

                break;

        }

        return type;

    }

    /* Create an adapter that handles spreading calls for the given type. */

    static Adapter findAdapter(MethodType targetType, short ap, short ac, char mode, Class<?> arg) {

        MethodType entryType = entryType(targetType, ap, ac, mode, arg);

        int argc = targetType.parameterCount();

        String pname = patternName(ap, ac, mode);

        String cname0 = "F"+argc;

        String cname1 = "F"+argc+mode;

        String cname2 = "F"+argc+pname;

        String[] cnames = { cname0, cname1, cname1+"X", cname2 };

        String iname = "invoke_"+pname;

        // e.g., F5R; invoke_R3

        for (String cname : cnames) {

            Class<? extends Adapter> acls = Adapter.findSubClass(cname);

            if (acls == null)  continue;

            // see if it has the required invoke method

            MethodHandle entryPoint = null;

            try {

                entryPoint = MethodHandleImpl.IMPL_LOOKUP.findSpecial(acls, iname, entryType, acls);

            } catch (NoAccessException ex) {

            }

            if (entryPoint == null)  continue;

            Constructor<? extends Adapter> ctor = null;

            try {

                ctor = acls.getDeclaredConstructor(MethodHandle.class);

            } catch (NoSuchMethodException ex) {

            } catch (SecurityException ex) {

            }

            if (ctor == null)  continue;

            try {

                // Produce an instance configured as a prototype.

                return ctor.newInstance(entryPoint);

            } catch (IllegalArgumentException ex) {

            } catch (InvocationTargetException ex) {

            } catch (InstantiationException ex) {

            } catch (IllegalAccessException ex) {

            }

        }

        return null;

    }

    static Adapter buildAdapterFromBytecodes(MethodType targetType, short ap, short ac, char mode, Class<?> arg) {

        throw new UnsupportedOperationException("NYI");

    }

    /**

     * This adapter takes some untyped arguments, and returns an untyped result.

     * Internally, it applies the invoker to the target, which causes the

     * objects to be unboxed; the result is a raw type in L/I/J/F/D.

     * This result is passed to convert, which is responsible for

     * converting the raw result into a boxed object.

     * The invoker is kept separate from the target because it can be

     * generated once per type erasure family, and reused across adapters.

     */

    static abstract class Adapter extends JavaMethodHandle {

        protected final MethodHandle filter;

        protected final MethodHandle target;

        protected boolean isPrototype() { return target == null; }

        protected Adapter(MethodHandle entryPoint) {

            this(entryPoint, entryPoint, null);

            assert(isPrototype());

        }

        protected MethodHandle prototypeEntryPoint() {

            if (!isPrototype())  throw new InternalError();

            return filter;

        }

        protected Adapter(MethodHandle entryPoint,

                          MethodHandle filter, MethodHandle target) {

            super(entryPoint);

            this.filter = filter;

            this.target = target;

        }

        /** Make a copy of self, with new fields. */

        protected abstract Adapter makeInstance(MethodHandle entryPoint,

                MethodHandle filter, MethodHandle target);

        // { return new ThisType(entryPoint, filter, target); }

        static private final String CLASS_PREFIX; // "sun.dyn.FilterGeneric$"

        static {

            String aname = Adapter.class.getName();

            String sname = Adapter.class.getSimpleName();

            if (!aname.endsWith(sname))  throw new InternalError();

            CLASS_PREFIX = aname.substring(0, aname.length() - sname.length());

        }

        /** Find a sibing class of Adapter. */

        static Class<? extends Adapter> findSubClass(String name) {

            String cname = Adapter.CLASS_PREFIX + name;

            try {

                return Class.forName(cname).asSubclass(Adapter.class);

            } catch (ClassNotFoundException ex) {

                return null;

            } catch (ClassCastException ex) {

                return null;

            }

        }

    }

    //* generated classes follow this pattern:

    static class F1RX extends Adapter {

        protected F1RX(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype

        protected F1RX(MethodHandle e, MethodHandle f, MethodHandle t)

                        { super(e, f, t); }

        protected F1RX makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)

                        { return new F1RX(e, f, t); }

        protected Object filter(Object a0) { return filter.<Object>invoke(a0); }

        protected Object target(Object a0) { return target.<Object>invoke(a0); }

        protected Object invoke_R0(Object a0) { return target(filter(a0)); }

    }

    static class F2RX extends Adapter {

        protected F2RX(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype

        protected F2RX(MethodHandle e, MethodHandle f, MethodHandle t)

                        { super(e, f, t); }

        protected F2RX makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)

                        { return new F2RX(e, f, t); }

        protected Object filter(Object a0) { return filter.<Object>invoke(a0); }

        protected Object target(Object a0, Object a1) { return target.<Object>invoke(a0, a1); }

        protected Object invoke_R0(Object a0, Object a1) { return target(filter(a0), a1); }

        protected Object invoke_R1(Object a0, Object a1) { return target(a0, filter(a1)); }

    }

    static class F3RX extends Adapter {

        protected F3RX(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype

        protected F3RX(MethodHandle e, MethodHandle f, MethodHandle t)

                        { super(e, f, t); }

        protected F3RX makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)

                        { return new F3RX(e, f, t); }

        protected Object filter(Object a0) { return filter.<Object>invoke(a0); }

        protected Object target(Object a0, Object a1, Object a2) { return target.<Object>invoke(a0, a1, a2); }

        protected Object invoke_R0(Object a0, Object a1, Object a2) { return target(filter(a0), a1, a2); }

        protected Object invoke_R1(Object a0, Object a1, Object a2) { return target(a0, filter(a1), a2); }

        protected Object invoke_R2(Object a0, Object a1, Object a2) { return target(a0, a1, filter(a2)); }

    }

    static class F4RX extends Adapter {

        protected F4RX(MethodHandle entryPoint) { super(entryPoint); }  // to build prototype

        protected F4RX(MethodHandle e, MethodHandle f, MethodHandle t)

                        { super(e, f, t); }

        protected F4RX makeInstance(MethodHandle e, MethodHandle f, MethodHandle t)

                        { return new F4RX(e, f, t); }

        protected Object filter(Object a0) { return filter.<Object>invoke(a0); }

        protected Object target(Object a0, Object a1, Object a2, Object a3) { return target.<Object>invoke(a0, a1, a2, a3); }

        protected Object invoke_R0(Object a0, Object a1, Object a2, Object a3) { return target(filter(a0), a1, a2, a3); }

        protected Object invoke_R1(Object a0, Object a1, Object a2, Object a3) { return target(a0, filter(a1), a2, a3); }

        protected Object invoke_R2(Object a0, Object a1, Object a2, Object a3) { return target(a0, a1, filter(a2), a3); }

        protected Object invoke_R3(Object a0, Object a1, Object a2, Object a3) { return target(a0, a1, a2, filter(a3)); }

    }

    // */

}