package ch.usi.pl.parser;

import static ch.usi.pl.parser.Parsers.oneOf;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

/** Demostration of a parser combinator library in Java. */
public class Parsers {
    /**
     * A parser combinator. This is mostly just a function from an input String
     * to a Result, which is either an A and the unconsumed tail of the input
     * String, or a failure.
     */
    static abstract class Parser<A> {
        /** The parser function proper. */
        abstract Result<A> parse(String in);

        <B> Parser<Pair<A, B>> then(final Parser<B> pb) {
            final Parser<A> pa = this;
            return new SequenceParser<A, B>(pa, pb);
        }

        <B, C> Parser<C> thenWithConstructor(final Parser<B> pb, Function2<A, B, C> f) {
            throw new UnsupportedOperationException("probably a bad idea to implement this; bind will be more useful");
        }

        <C> Parser<C> bind(Function1<A, Parser<C>> f) {
            throw new UnsupportedOperationException("unimplemented: we'll do this Tuesday");
        }

        // Alternative version of 'then', using 'bind'.
        // Note, I don't need to deal with parser success or failure or the
        // input string.
        <B> Parser<Pair<A, B>> thenWithBind(final Parser<B> pb) {
            return bind(new Function1<A, Parser<Pair<A, B>>>() {
                public Parser<Pair<A, B>> apply(final A fst) {
                    return pb.map(new Function1<B, Pair<A, B>>() {
                        public Pair<A, B> apply(B snd) {
                            return new Pair<A, B>(fst, snd);
                        }
                    });
                }
            });
        }

        Parser<A> or(final Parser<A> pb) {
            final Parser<A> pa = this;
            return new AltParser<A>(pa, pb);
        }

        Parser<List<A>> zeroOrMore() {
            return new StarParser<A>(this);
        }

        // Alternative version of zeroOrMore.
        // This would work except for the recursive call!
        // It goes into an infinite loop building the parser.
        Parser<List<A>> zeroOrMore_Broken() {
            return this.then(this.zeroOrMore_Broken()).map(Parsers.<A> cons()).or(empty(Collections.<A> emptyList()));
        }

        // Alternative version of zeroOrMore_Broken where we push the
        // construction into the parse method.
        // Unsatisfying.
        Parser<List<A>> zeroOrMore_Hack() {
            return new AtLeastZeroParser<A>(this);
        }

        // Version of atLeastZero, using bind rather than then.
        Parser<List<A>> zeroOrMore_Bind() {
            return this.bind(new Function1<A, Parser<List<A>>>() {
                @Override
                public Parser<List<A>> apply(final A head) {
                    Function1<List<A>, List<A>> prepend = new Function1<List<A>, List<A>>() {
                        public List<A> apply(List<A> tail) {
                            List<A> xs = new ArrayList<A>();
                            xs.add(head);
                            xs.addAll(tail);
                            return xs;
                        }
                    };
                    return zeroOrMore_Bind().map(prepend);
                }
            }).or(empty(Collections.<A> emptyList()));
        }

        <B> Parser<B> map(Function1<A, B> f) {
            return new MapParser<A, B>(this, f);
        }
    }

    /**
     * Slightly nicer version of StarParser, where I don't need to mess with the
     * parser plumbing as much. We still define a subclass of Parser to avoid
     * the infinite loop in zeroOrMore, above.
     */
    static class AtLeastZeroParser<A> extends Parser<List<A>> {
        Parser<A> p;

        AtLeastZeroParser(Parser<A> p) {
            this.p = p;
        }

        @Override
        Result<List<A>> parse(String in) {
            return p.then(this).map(Parsers.<A> cons()).or(empty(Collections.<A> emptyList())).parse(in);
        }
    }

    static <A> Function1<Pair<A, List<A>>, List<A>> cons() {
        return new Function1<Pair<A, List<A>>, List<A>>() {
            @Override
            public List<A> apply(Pair<A, List<A>> arg) {
                List<A> xs = new ArrayList<A>();
                xs.add(arg.fst);
                xs.addAll(arg.snd);
                return xs;
            }
        };
    }

    static class MapParser<A, B> extends Parser<B> {
        private Parser<A> p;
        private Function1<A, B> f;

        MapParser(Parser<A> p, Function1<A, B> f) {
            this.p = p;
            this.f = f;
        }

        @Override
        Result<B> parse(String in) {
            Result<A> a = p.parse(in);
            if (a.success) {
                return new Result<B>(f.apply(a.result), true, a.tail);
            }
            else {
                return fail(in);
            }
        }

    }

    /** Return a parser that consumes no input, but returns a value of type A. */
    static <A> Parser<A> empty(final A value) {
        return new Parser<A>() {
            @Override
            Result<A> parse(String in) {
                return new Result<A>(value, true, in);
            }
        };
    }

    static class StarParser<A> extends Parser<List<A>> {
        private final Parser<A> p;

        StarParser(Parser<A> p) {
            this.p = p;
        }

        @Override
        Result<List<A>> parse(String in) {
            Result<A> r = p.parse(in);
            if (!r.success) {
                return new Result<List<A>>(Collections.<A> emptyList(), true, in);
            }
            else {
                Result<List<A>> t = this.parse(r.tail);
                if (t.success) {
                    List<A> xs = new ArrayList<A>();
                    xs.add(r.result);
                    xs.addAll(t.result);
                    return new Result<List<A>>(xs, true, t.tail());
                }
                else {
                    return new Result<List<A>>(Collections.singletonList(r.result), true, r.tail);
                }
            }
        }
    }

    static class AltParser<A> extends Parser<A> {
        private final Parser<A> pa;
        private final Parser<A> pb;

        AltParser(Parser<A> pa, Parser<A> pb) {
            this.pa = pa;
            this.pb = pb;
        }

        Result<A> parse(String in) {
            Result<A> ra = pa.parse(in);
            if (ra.success()) {
                return ra;
            }
            else {
                return pb.parse(in);
            }
        }
    }

    /** A parser that parses first an A, then a B, returning both. */
    static class SequenceParser<A, B> extends Parser<Pair<A, B>> {
        private final Parser<A> pa;
        private final Parser<B> pb;

        SequenceParser(Parser<A> pa, Parser<B> pb) {
            this.pa = pa;
            this.pb = pb;
        }

        @Override
        Result<Pair<A, B>> parse(String in) {
            Result<A> ra = pa.parse(in);
            if (ra.success) {
                Result<B> rb = pb.parse(ra.tail);
                if (rb.success) {
                    return new Result<Pair<A, B>>(new Pair<A, B>(ra.result, rb.result), true, rb.tail);
                }
            }
            return fail(in);
        }
    }

    /**
     * A parser that parses a single character in a String of possible matching
     * characters.
     */
    static Parser<Character> oneOf(final String set) {
        return new OneOfParser(set);
    }

    /**
     * A parser that parses a single character in a String of possible matching
     * characters.
     */
    static class OneOfParser extends Parser<Character> {
        private final String set;

        OneOfParser(String set) {
            this.set = set;
        }

        @Override
        Result<Character> parse(String in) {
            if (in.length() >= 1) {
                for (int i = 0; i < set.length(); i++) {
                    char ch = set.charAt(i);
                    if (in.charAt(0) == ch) {
                        return new Result<Character>(ch, true, in.substring(1));
                    }
                }
            }
            return fail(in);
        }
    }

    /** A failed parse result. */
    static <A> Result<A> fail(String in) {
        return new Result<A>(null, false, in);
    }

    /** Parser result */
    static class Result<A> {
        /** Whether the parse succeeded or not. */
        private final boolean success;

        /** The actual result if the parser was successful. */
        private final A result;

        /** The uncomsumed input. */
        private final String tail;

        Result(A result, boolean success, String tail) {
            this.result = result;
            this.success = success;
            this.tail = tail;
        }

        boolean success() {
            return success;
        }

        A result() {
            if (success)
                return result;
            else
                throw new RuntimeException("parse failed");
        }

        String tail() {
            if (success)
                return tail;
            else
                throw new RuntimeException("parse failed");
        }
    }

    static class Pair<A, B> {
        final A fst;
        final B snd;

        Pair(A fst, B snd) {
            this.fst = fst;
            this.snd = snd;
        }
    }

    interface Either<A, B> {
    }

    class Left<A, B> implements Either<A, B> {
        A a;

        void match(Visitor<A, B> m) {
            m.handleA(a);
        }
    }

    class Right<A, B> implements Either<A, B> {
        B b;

        void match(Visitor<A, B> m) {
            m.handleB(b);
        }
    }

    interface Visitor<A, B> {
        void handleA(A a);

        void handleB(B b);
    }

    /** Read an InputStream into a String. */
    static String slurp(InputStream is) throws IOException {
        Scanner s = new Scanner(is).useDelimiter("\\A");
        return s.hasNext() ? s.next() : "";
    }
    

    public static void main(String[] args) throws IOException {
        Parser<Character> ws = oneOf(" \t\n");
        Parser<Character> digit = oneOf("0123456789");
        Parser<Character> lower = oneOf("abcdefghijklmnopqrstuvwxyz");
        Parser<Character> upper = oneOf("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
        Parser<Character> letter = lower.or(upper);

        assert (digit.parse("0").result() == '0');
        assert (ws.parse(" ").result() == ' ');

        String s = Parsers.slurp(System.in);

        Result<List<Character>> r = letter.or(digit).zeroOrMore_Hack().parse(s);

        if (r.success()) {
            System.out.println(r.result());
        }
        else {
            System.out.println("fail");
        }
    }

}