/*

 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.source.util;

import java.util.function.Consumer;

import javax.lang.model.element.Modifier;

import com.sun.source.doctree.DocTree;

import com.sun.source.tree.CompilationUnitTree;

/**

 *  Note: a crude experiment to explore a builder for javac ASTs.

 */

public interface TreeBuilder {

    CompilationUnitTree createCompilationUnitTree(Consumer<CompilationUnit> unit); //TODO: should be in Trees?

    //mixins:

    interface WithModifiers<T extends WithModifiers<T>> {

        T modifiers(Consumer<Modifiers> modifiers);

    }

    interface WithJavadoc<T extends WithJavadoc<T>> {

        T javadoc(DocTree doc);

        T javadoc(String doc);

    }

    //builders:

    interface CompilationUnit {

        CompilationUnit _package(String... qname);

        CompilationUnit _class(String name, Consumer<Class> clazz);

    }

    interface Class extends WithModifiers<Class>, WithJavadoc<Class> {

        //setters:

        Class superclass(Consumer<Type> sup);

        default Class superclass(String sup) {

            return superclass(t -> t.type(sup));

        }

        Class superinterface(Consumer<Type> sup);

        default Class superinterface(String sup) {

            return superinterface(t -> t.type(sup));

        }

        //type parameters?

        //adders:

        default Class field(String name, Consumer<Type> type) {

            //TODO: has this overload a meaning

            return field(name, type, V -> {});

        }

        Class field(String name, Consumer<Type> type, Consumer<Variable> field);

        Class method(String name, Consumer<Type> restype, Consumer<Method> method);

        Class _class(String name, Consumer<Class> clazz);

        //TODO:initializer block

    }

    interface Variable extends WithModifiers<Variable>, WithJavadoc<Variable> {

        //setters:

        Variable init(Consumer<Expression> init);

        default Variable init(String init) {

            return init(E -> E.expression(init));

        }

    }

    interface Parameter extends WithModifiers<Parameter> {

        Parameter modifiers(Consumer<Modifiers> modifiers); //TODO: limit to final only?

        Parameter name(String name);

    }

    interface Method extends WithModifiers<Method>, WithJavadoc<Method> {

        default Method parameter(Consumer<Type> type) {

            return parameter(type, P -> {});

        }

        //TODO: parameter overload type+name?

        Method parameter(Consumer<Type> type, Consumer<Parameter> parameter);

        Method body(Consumer<Block> body);

        /**

         * Must include the '{' '}'.

         * @param body

         * @return 

         */

        Method body(String body);

        //throws, default value

    }

    interface Modifiers {

        Modifiers modifier(Modifier modifier);

        Modifiers annotation(Consumer<Annotation> annotation);

    }

    interface Annotation {

        //TODO...

    }

    //TODO: DeclaredType vs. Type?

    interface Type {

        default void _class(String className) {

            _class(N -> N.qualifiedName(className));

        }

        default void _class(Consumer<QualifiedName> className) {

            _class(className, A -> {});

        }

        void _class(Consumer<QualifiedName> className, Consumer<TypeArguments> typeArguments);

        void _int();

        void _float();

        void _void();

        void type(String type);

    }

    interface TypeArguments { //???

        TypeArguments type(Consumer<Type> t);

    }

    interface QualifiedName {

        void select(Consumer<QualifiedName> selected, String name);

        void ident(String simpleName);

        void ident(String... components);

        default void qualifiedName(String qualifiedName) {

            ident(qualifiedName.split("\\."));

        }

    }

    interface Expression {

        void equal_to(Consumer<Expression> lhs, Consumer<Expression> rhs);

        void minusminus(Consumer<Expression> expr);

        void plus(Consumer<Expression> lhs, Consumer<Expression> rhs);

        void cond(Consumer<Expression> cond, Consumer<Expression> truePart, Consumer<Expression> falsePart);

        void select(Consumer<Expression> selected, String name);

        void ident(String qnames);

        void literal(Object value);

        void expression(String expression);

    }

    interface StatementBase<S> {

        S _if(Consumer<Expression> cond, Consumer<Statement> ifPart);

        S _if(Consumer<Expression> cond, Consumer<Statement> ifPart, Consumer<Statement> elsePart);

        S _return();

        S _return(Consumer<Expression> expr);

        S expr(Consumer<Expression> expr);

        S skip();

        S statement(String statement);

    }

    interface Statement extends StatementBase<Void> {

    }

    interface Block extends StatementBase<Block>{

    }

    static void test(TreeBuilder builder) {

        builder.createCompilationUnitTree(

         U -> U._class("Foo", C -> C.field("x", Type::_int)

                                    .method("foo",

                                            Type::_void,

                                            M -> M.parameter(T -> T._class("Foo"))

                                                  .parameter(T -> T._float(), P -> P.name("whatever"))

                                                  .body(B -> B._if(E -> E.minusminus(V -> V.select(S -> S.ident("foo"), "bar")),

                                                                   Statement::skip,

                                                                   Statement::skip

                                                                  )

                                                       )

                                            )));

    }

    //annotations?

    //positions?

}