package ch.usi.pl.hw6;

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 ParsersHW {
    /**
     * 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);

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

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

        /** Just like then, but delays evaluating the argument until needed. */
        <B> Parser<Pair<A, B>> lazyThen(final Thunk<Parser<B>> lazyPb) {
            // TODO
            throw new UnsupportedOperationException("implement 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(ParsersHW.<A> cons()).or(empty(Collections.<A> emptyList()));
        }

        Parser<List<A>> zeroOrMore() {
            // TODO
            throw new UnsupportedOperationException("implement this");
        }

        Parser<List<A>> oneOrMore() {
            // TODO
            throw new UnsupportedOperationException("implement this");
        }

        Parser<List<A>> zeroOrMore(Parser<?> sep) {
            // TODO
            throw new UnsupportedOperationException("implement this");
        }

        Parser<List<A>> oneOrMore(Parser<?> sep) {
            // TODO
            throw new UnsupportedOperationException("implement this");
        }

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

    static abstract class Thunk<A> {
        abstract A compute();

        A force() {
            // TODO
            throw new UnsupportedOperationException("implement this");
        }
    }

    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 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.isEmpty()) {
                char ch = in.charAt(0);
                if (set.indexOf(ch) >= 0)
                    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 interface Function1<A, R> {
        R apply(A arg);
    }

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

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

    /** 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) {
        // TODO: add your test cases here.
        // Remember you may need to enable assertions (run with java -ea) to 
        // make assert statements do anything.
        throw new RuntimeException("unimplemented test cases");
    }
}