/*
 * This file is part of OCaml-Java runtime.
 * Copyright (C) 2007-2013 Xavier Clerc.
 *
 * OCaml-Java runtime is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * OCaml-Java runtime 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package org.ocamljava.runtime.wrappers;

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;

import org.ocamljava.runtime.values.Value;

/**
 * The {@code OCamlFunction} class represent an OCaml function taking one
 * parameter.
 *
 * @author <a href="mailto:xclerc@ocamljava.org">Xavier Clerc</a>
 * @version 2.0
 * @since 2.0
 */
public abstract class OCamlFunction<T0 extends OCamlValue,
                                    TR extends OCamlValue> extends OCamlValue {

    /** Wrapper for first parameter. */
    protected final Wrapper<T0> wrapper0;

    /** Wrapper for return value. */
    protected final Wrapper<TR> wrapperr;

    /** Method handle for function actually called from the OCaml runtime. */
    private static final MethodHandle METHOD_HANDLE;

    static { // XXX factorize in OCamlWrappers
        MethodHandle mh;
        try {
            final MethodHandles.Lookup lookup = MethodHandles.lookup();
            final MethodType mt = MethodType.methodType(Value.class, Value.class);
            mh = lookup.findVirtual(OCamlFunctionCaller.class, "called", mt);
        } catch (final NoSuchMethodException | IllegalAccessException e) {
            assert false : "OCamlFunction: unable to get method handle";
            mh = null;
        } // end try/catch
        METHOD_HANDLE = mh;
    } // end static block

    /**
     * Constructs a new instance. <br/>
     * To be used by Java implementations.
     * @param w0 wrapper for first parameter - should not be {@code null}
     * @param wr wrapper for result - should not be {@code null}
     */
    public OCamlFunction(final Wrapper<T0> w0,
                         final Wrapper<TR> wr) {
        super(Value.UNIT);
        assert w0 != null : "null w0";
        assert wr != null : "null wr";
        this.wrapper0 = w0;
        this.wrapperr = wr;
    } // end constructor(Wrapper<T0>, Wrapper<TR>)

    /**
     * Constructs a new instance. <br/>
     * To be used by Java implementations.
     */
    @SuppressWarnings("unchecked")
    public OCamlFunction() {
        this((Wrapper<T0>) OCamlValue.WRAPPER,
             (Wrapper<TR>) OCamlValue.WRAPPER);
    } // end empty constructor

    /**
     * Constructs a new instance from a value. <br/>
     * To be used by OCaml implementations.
     * @param w0 wrapper for first parameter - should not be {@code null}
     * @param wr wrapper for result - should not be {@code null}
     */
    OCamlFunction(final Value v,
                  final Wrapper<T0> w0,
                  final Wrapper<TR> wr) {
        super(v);
        assert w0 != null : "null w0";
        assert wr != null : "null wr";
        this.wrapper0 = w0;
        this.wrapperr = wr;
    } // end constructor(Value, Wrapper<T0>, Wrapper<TR>)

    /**
     * {@inheritDoc}
     */
    @Override
    public final Wrapper<? extends OCamlFunction<T0, TR>> getWrapper() {
        return OCamlFunction.wrapper(this.wrapper0, this.wrapperr);
    } // end method 'getWrapper()'

    /**
     * {@inheritDoc}
     */
    @Override
    public Wrapper<? extends OCamlValue> getWrapper(final int idx) {
        switch (idx) {
        case 0: return this.wrapper0;
        case 1: return this.wrapperr;
        default: return OCamlUnit.WRAPPER;
        } // end switch
    } // end method 'getWrapper(int)'

    /**
     * Returns the closure to be executed from the OCaml runtime.
     * @param w0 wrapper for first parameter - should not be {@code null}
     * @return the closure to be executed on the OCaml side
     */
    public Value getClosure(final Wrapper<T0> w0) {
        assert w0 != null : "null w0";
        final OCamlFunctionCaller<T0, TR> ofc = new OCamlFunctionCaller<>(w0, this);
        return Value.createClosure(OCamlFunction.METHOD_HANDLE.bindTo(ofc));
    } // end method 'getClosure(Wrapper<T0>)'

    /**
     * The actual implementation of the function
     * @param p0 first parameter - should not be {@code null}
     * @throws OCamlException if function fails
     */
    public abstract TR execute(final T0 p0) throws OCamlException;

    /**
     * {@inheritDoc}
     */
    @Override
    public final int hashCode() {
        return super.hashCode();
    } // end method 'hashCode()'

    /**
     * {@inheritDoc}
     */
    @Override
    public final boolean equals(final Object obj) {
        if (obj instanceof OCamlFunction) {
            final OCamlFunction<?, ?> that = (OCamlFunction) obj;
            return this == that;
        } else {
            return false;
        } // end if/else
    } // end method 'equals(Object)'

    /**
     * {@inheritDoc}
     */
    @Override
    public final String toString() {
        return "OCamlFunction(...)";
    } // end method 'toString()'

    /**
     * Wraps the passed value.
     * @param w0 wrapper for first parameter - should not be {@code null}
     * @param wr wrapper for result - should not be {@code null}
     * @param v value to wrap - should not be {@code null}
     * @return a new {@code OCamlFunction} instance wrapping the passed value
     */
    public static <T0 extends OCamlValue,
                   TR extends OCamlValue>
        OCamlFunction<T0, TR> wrap(final Wrapper<T0> w0,
                                   final Wrapper<TR> wr,
                                   final Value v) {
        assert w0 != null : "null w0";
        assert wr != null : "null wr";
        assert v != null : "null v";
        return new OCamlFunctionImpl<T0, TR>(w0, wr, v);
    } // end method 'wrap(Wrapper<T0>, Wrapper<TR>, Value)'

    /**
     * Returns a wrapper for {@code OCamlFunction} values.
     * @param w0 wrapper for first parameter - should not be {@code null}
     * @param wr wrapper for result - should not be {@code null}
     * @return a wrapper for {@code OCamlFunction} values
     */
    @SuppressWarnings("unchecked")
    public static <T0 extends OCamlValue,
                   TR extends OCamlValue>
        Wrapper<? extends OCamlFunction<T0, TR>> wrapper(final Wrapper<T0> w0,
                                                         final Wrapper<TR> wr) {
        assert w0 != null : "null w0";
        assert wr != null : "null wr";
        return new ComposedWrapper<OCamlFunction<T0, TR>>(w0, wr) {
            /**
             * {@inheritDoc}
             */
            @Override
                public OCamlFunction<T0, TR> wrap(final Value v) {
                return new OCamlFunctionImpl<T0, TR>(w0, wr, v);
            } // end method 'wrap(Value)'
        }; // end anonymous inner-class
    } // end method 'wrapper(Wrapper<T0>, Wrapper<TR>)'

} // end class 'OCamlFunction'