package fj;

import fj.control.parallel.Promise;
import fj.data.*;

/**
 * Created by MarkPerry on 22/01/2015.
 */
public abstract class F2W<A, B, C> implements F2<A, B, C> {

    /**
     * Partial application.
     *
     * @param a The <code>A</code> to which to apply this function.
     * @return The function partially applied to the given argument.
     */
    public final F1W<B, C> f(final A a) {
        return F1W.lift(F2Functions.f(this, a));
    }

    /**
     * Curries this wrapped function to a wrapped function of arity-1 that returns another wrapped function.
     *
     * @return a wrapped function of arity-1 that returns another wrapped function.
     */
    public final F1W<A, F<B, C>> curry() {
        return F1W.lift(F2Functions.curry(this));
    }

    /**
     * Flips the arguments of this function.
     *
     * @return A new function with the arguments of this function flipped.
     */
    public final F2W<B, A, C> flip() {
        return lift(F2Functions.flip(this));
    }

    /**
     * Uncurries this function to a function on tuples.
     *
     * @return A new function that calls this function with the elements of a given tuple.
     */
    public final F1W<P2<A, B>, C> tuple() {
        return F1W.lift(F2Functions.tuple(this));
    }

    /**
     * Promotes this function to a function on Arrays.
     *
     * @return This function promoted to transform Arrays.
     */
    public final F2W<Array<A>, Array<B>, Array<C>> arrayM() {
        return lift(F2Functions.arrayM(this));
    }

    /**
     * Promotes this function to a function on Promises.
     *
     * @return This function promoted to transform Promises.
     */
    public final F2W<Promise<A>, Promise<B>, Promise<C>> promiseM() {
        return lift(F2Functions.promiseM(this));
    }

    /**
     * Promotes this function to a function on Iterables.
     *
     * @return This function promoted to transform Iterables.
     */
    public final F2W<Iterable<A>, Iterable<B>, IterableW<C>> iterableM() {
        return lift(F2Functions.iterableM(this));
    }

    /**
     * Promotes this function to a function on Lists.
     *
     * @return This function promoted to transform Lists.
     */
    public final F2W<List<A>, List<B>, List<C>> listM() {
        return lift(F2Functions.listM(this));
    }

    /**
     * Promotes this function to a function on non-empty lists.
     *
     * @return This function promoted to transform non-empty lists.
     */
    public final F2W<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> nelM() {
        return lift(F2Functions.nelM(this));
    }

    /**
     * Promotes this function to a function on Options.
     *
     * @return This function promoted to transform Options.
     */
    public final F2W<Option<A>, Option<B>, Option<C>> optionM() {
        return lift(F2Functions.optionM(this));
    }

    /**
     * Promotes this function to a function on Sets.
     *
     * @param o An ordering for the result of the promoted function.
     * @return This function promoted to transform Sets.
     */
    public final F2W<Set<A>, Set<B>, Set<C>> setM(final Ord<C> o) {
        return lift(F2Functions.setM(this, o));
    }

    /**
     * Promotes this function to a function on Streams.
     *
     * @return This function promoted to transform Streams.
     */
    public final F2W<Stream<A>, Stream<B>, Stream<C>> streamM() {
        return lift(F2Functions.streamM(this));
    }

    /**
     * Promotes this function to a function on Trees.
     *
     * @return This function promoted to transform Trees.
     */
    public final F2W<Tree<A>, Tree<B>, Tree<C>> treeM() {
        return lift(F2Functions.treeM(this));
    }

    /**
     * Promotes this function to zip two arrays, applying the function lock-step over both Arrays.
     *
     * @return A function that zips two arrays with this function.
     */
    public final F2W<Array<A>, Array<B>, Array<C>> zipArrayM() {
        return lift(F2Functions.zipArrayM(this));
    }

    /**
     * Promotes this function to zip two iterables, applying the function lock-step over both iterables.
     *
     * @return A function that zips two iterables with this function.
     */
    public final F2W<Iterable<A>, Iterable<B>, Iterable<C>> zipIterableM() {
        return lift(F2Functions.zipIterableM(this));
    }

    /**
     * Promotes this function to zip two lists, applying the function lock-step over both lists.
     *
     * @return A function that zips two lists with this function.
     */
    public final F2W<List<A>, List<B>, List<C>> zipListM() {
        return lift(F2Functions.zipListM(this));
    }


    /**
     * Promotes this function to zip two streams, applying the function lock-step over both streams.
     *
     * @return A function that zips two streams with this function.
     */
    public final F2W<Stream<A>, Stream<B>, Stream<C>> zipStreamM() {
        return lift(F2Functions.zipStreamM(this));
    }

    /**
     * Promotes this function to zip two non-empty lists, applying the function lock-step over both lists.
     *
     * @return A function that zips two non-empty lists with this function.
     */
    public final F2W<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zipNelM() {
        return lift(F2Functions.zipNelM(this));
    }

    /**
     * Promotes this function to zip two sets, applying the function lock-step over both sets.
     *
     * @param o An ordering for the resulting set.
     * @return A function that zips two sets with this function.
     */
    public final F2W<Set<A>, Set<B>, Set<C>> zipSetM(final Ord<C> o) {
        return lift(F2Functions.zipSetM(this, o));
    }

    /**
     * Promotes this function to zip two trees, applying the function lock-step over both trees.
     * The structure of the resulting tree is the structural intersection of the two trees.
     *
     * @return A function that zips two trees with this function.
     */
    public final F2W<Tree<A>, Tree<B>, Tree<C>> zipTreeM() {
        return lift(F2Functions.zipTreeM(this));
    }

    /**
     * Promotes this function to zip two zippers, applying the function lock-step over both zippers in both directions.
     * The structure of the resulting zipper is the structural intersection of the two zippers.
     *
     * @return A function that zips two zippers with this function.
     */
    public final F2W<Zipper<A>, Zipper<B>, Zipper<C>> zipZipperM() {
        return lift(F2Functions.zipZipperM(this));
    }

    /**
     * Promotes this function to zip two TreeZippers, applying the function lock-step over both zippers in all directions.
     * The structure of the resulting TreeZipper is the structural intersection of the two TreeZippers.
     *
     * @return A function that zips two TreeZippers with this function.
     */
    public final F2W<TreeZipper<A>, TreeZipper<B>, TreeZipper<C>> zipTreeZipperM() {
        return lift(F2Functions.zipTreeZipperM(this));
    }

    public final <Z> F2W<Z, B, C> contramapFirst(F<Z, A> f) {
        return lift(F2Functions.contramapFirst(this, f));
    }

    public final <Z> F2W<A, Z, C> contramapSecond(F<Z, B> f) {
        return lift(F2Functions.contramapSecond(this, f));
    }

    public final <X, Y> F2W<X, Y, C> contramap(F<X, A> f, F<Y, B> g) {
        return lift(F2Functions.contramap(this, f, g));
    }

    public final <Z> F2W<A, B, Z> map(F<C, Z> f) {
        return lift(F2Functions.map(this, f));
    }


    public static class F2WFunc<A, B, C> extends F2W<A, B, C> {
        final F2<A, B, C> func;
        public F2WFunc(F2<A, B, C> f) {
            func = f;
        }

        @Override
        public final C f(A a, B b) {
            return func.f(a, b);
        }
    }

    /**
     * Lifts the function into the fully featured function wrapper
     */
    public static <A, B, C> F2W<A, B, C> lift(final F2<A, B, C> f) {
        return new F2WFunc<>(f);
    }



}