/*
 * 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 org.ocamljava.runtime.kernel.NativeApply;
import org.ocamljava.runtime.values.BlockValue;
import org.ocamljava.runtime.values.Value;

/**
 * The {@code OCamlLazy} class is the wrapper class for OCaml values of
 * type {@code 'a lazy_t}.
 *
 * @author <a href="mailto:xclerc@ocamljava.org">Xavier Clerc</a>
 * @version 2.0
 * @since 2.0
 */
public final class OCamlLazy<T extends OCamlValue> extends OCamlValue {

    /** Wrapper for nested value. */
    private final Wrapper<T> wrapper;

    /**
     * Constructs a new instance wrapping the passed value.
     * @param w wrapper for nested value - should not be {@code null}
     * @param v value to wrap - should not be {@code null}
     */
    private OCamlLazy(final Wrapper<T> w, final Value v) {
        super(v);
        assert w != null : "null w";
        this.wrapper = w;
    } // end constructor(Wrapper<T>, Value)

    /**
     * {@inheritDoc}
     */
    @Override
    public Wrapper<? extends OCamlLazy<T>> getWrapper() {
        return OCamlLazy.wrapper(this.wrapper);
    } // end method 'getWrapper()'

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

    /**
     * Returns the wrapped value.
     * @return the wrapped value if already forced, or {@code null} otherwise
     */
    public T get() {
        if (this.value.isLong()) {
            return this.wrapper.wrap(this.value);
        } else {
            switch (this.value.getTag()) { // XXX quid lazy imbriques ?
            case BlockValue.LAZY_TAG: return null;
            case BlockValue.FORWARD_TAG: return this.wrapper.wrap(this.value.get0());
            default: return this.wrapper.wrap(this.value);
            } // end switch
        } // end if/else
    } // end method 'get()'

    /**
     * Returns the wrapped value, by forcing it if necessary.
     * @return the wrapped value
     */
    public T force() {
        if (this.value.isLong()) {
            return this.wrapper.wrap(this.value);
        } else {
            switch (this.value.getTag()) { // XXX quid lazy imbriques ?
            case BlockValue.LAZY_TAG:
                try {
                    // XXX what is the state of a lazy value when (first) evaluation has raised an exception?
                    final Value res = NativeApply.apply(this.value.get0(), Value.UNIT);
                    this.value.setTag(BlockValue.FORWARD_TAG);
                    this.value.set0(res);
                    return this.wrapper.wrap(res);
                } catch (final Throwable t) {
                    assert false : "exception during lazy evaluation";
                    return null; // XXX
                } // end try/catch
            case BlockValue.FORWARD_TAG: return this.wrapper.wrap(this.value.get0());
            default: return this.wrapper.wrap(this.value);
            } // end switch
        } // end if/else
    } // end method 'force()'

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

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

    /**
     * {@inheritDoc}
     */
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append("OCamlLazy(");
        final T v = get();
        if (v == null) {
            sb.append("...");
        } else {
            sb.append(this.wrapper.wrap(v.value()).toString());
        } // end if/else
        sb.append(")");
        return sb.toString();
    } // end method 'toString()'

    /**
     * Constructs a new {@code 'a lazy_t} value, and wraps it.
     * @param v value to wrap
     * @return a new {@code OCamlLazy} instance wrapping the passed value
     */
    @SuppressWarnings("unchecked")
    public static <T extends OCamlValue> OCamlLazy<T> create(final T v) {
        return new OCamlLazy<T>((Wrapper<T>) v.getWrapper(),
                                Value.createBlock(BlockValue.FORWARD_TAG, v.value()));
    } // end method 'create(T)'

    /**
     * Constructs a new {@code 'a lazy_t} value, and wraps it.
     * @param w wrapper for nested value - should not be {@code null}
     * @param c closure computing the value
     * @return a new {@code OCamlLazy} instance wrapping the passed value
     */
    public static <T extends OCamlValue> OCamlLazy<T> create(final Wrapper<T> w,
                                                             final OCamlFunction<OCamlUnit, T> c) {
        final Value clos = c.getClosure(OCamlUnit.WRAPPER);
        return new OCamlLazy<T>(w, Value.createBlock(BlockValue.LAZY_TAG, clos));
    } // end method 'create(Wrapper<T>, OCamlFunction<OCamlUnit, T>)'

    /**
     * Wraps the passed value.
     * @param w wrapper for nested value - should not be {@code null}
     * @param v value to wrap - should not be {@code null}
     * @return a new {@code OCamlLazy} instance wrapping the passed value
     */
    public static <T extends OCamlValue> OCamlLazy<T> wrap(final Wrapper<T> w,
                                                           final Value v) {
        assert v != null : "null v";
        return new OCamlLazy<T>(w, v);
    } // end method 'wrap(Wrapper<T>, Value)'

    /**
     * Returns a wrapper for {@code OCamlLazy} values.
     * @param w wrapper for nested value - should not be {@code null}
     * @return a wrapper for {@code OCamlLazy} values
     */
    @SuppressWarnings("unchecked")
    public static <T extends OCamlValue> Wrapper<? extends OCamlLazy<T>> wrapper(final Wrapper<T> w) {
        return new ComposedWrapper<OCamlLazy<T>>(w) {
            /**
             * {@inheritDoc}
             */
            @Override
                public OCamlLazy<T> wrap(final Value v) {
                return new OCamlLazy<T>(w, v);
            } // end method 'wrap(Value)'
        }; // end anonymous inner-class
    } // end method 'wrapper()'

} // end class 'OCamlLazy'