/*

 * 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.

 *

 * 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.

 */

/**

 * @test

 * @bug 8003280

 * @summary Add lambda tests

 * @compile  TypeInferenceComboTest.java

 * @run main/timeout=360 TypeInferenceComboTest

 */

import java.net.URI;

import java.util.Arrays;

import javax.tools.Diagnostic;

import javax.tools.JavaFileObject;

import javax.tools.SimpleJavaFileObject;

    enum Context {

        ASSIGNMENT("SAM#Type s = #LBody;"),

        METHOD_CALL("#GenericDeclKind void method1(SAM#Type s) { }\n" +

                    "void method2() {\n" +

                    "    method1(#LBody);\n" +

                    "}"),

        RETURN_OF_METHOD("SAM#Type method1() {\n" +

                "    return #LBody;\n" +

                "}"),

        LAMBDA_RETURN_EXPRESSION("SAM2 s2 = () -> {return (SAM#Type)#LBody;};\n"),

        ARRAY_INITIALIZER("Object[] oarray = {\"a\", 1, (SAM#Type)#LBody};");

        String context;

        Context(String context) {

            this.context = context;

        }

            String result = context;

            if (sk == SamKind.GENERIC) {

                if(this == Context.METHOD_CALL) {

                    if(gdk == GenericDeclKind.NON_GENERIC)

                    else //#GenericDeclKind is <T> or <T extends xxx>

                        result = result.replaceAll("#Type", "<T>");

                }

                else {

                    if(kw == Keyword.VOID)

                    else

                }

            }

            else

        }

    }

    enum SamKind {

        GENERIC("interface SAM<T> { #R m(#ARG); }"),

        NON_GENERIC("interface SAM { #R m(#ARG); }");

        String sam_str;

        SamKind(String sam_str) {

            this.sam_str = sam_str;

        }

        String getSam(TypeKind parameterT, TypeKind returnT) {

        }

    }

    enum TypeKind {

        VOID("void", ""),

        STRING("String", "\"hello\""),

        INTEGER("Integer", "1"),

        INT("int", "0"),

        SAM("SAM2", "null"),

        GENERIC("T", null);

        String typeStr;

        String valStr;

        TypeKind(String typeStr, String valStr) {

            this.typeStr = typeStr;

            this.valStr = valStr;

        }

    }

    enum LambdaKind {

        EXPRESSION("#VAL"),

        STATEMENT("{return #VAL;}");

        String stmt;

        LambdaKind(String stmt) {

            this.stmt = stmt;

        }

    }

    enum ParameterKind {

        EXPLICIT("#TYPE"),

        IMPLICIT("");

        String paramTemplate;

        ParameterKind(String paramTemplate) {

             this.paramTemplate = paramTemplate;

        }

    }

    enum Keyword {

        SUPER("super"),

        EXTENDS("extends"),

        VOID("");

        String keyStr;

        Keyword(String keyStr) {

            this.keyStr = keyStr;

        }

    }

    enum LambdaBody {

        String bodyStr;

        LambdaBody(String bodyStr) {

            this.bodyStr = bodyStr;

        }

            String result = bodyStr.replaceAll("#PK", pk.paramTemplate);

            if(result.contains("#TYPE")) {

                if (parameterT == TypeKind.GENERIC && this != RETURN_VOID)

                else

                    result = result.replaceAll("#TYPE", parameterT.typeStr);

            }

            if (this == RETURN_ARG && parameterT == returnT)

                return result.replaceAll("#RET", lk.stmt.replaceAll("#VAL", "arg"));

            else {

                if(returnT != TypeKind.GENERIC)

                else

            }

        }

    }

    enum GenericDeclKind {

        NON_GENERIC(""),

        GENERIC_NOBOUND("<T>"),

        GENERIC_BOUND("<T extends #ExtendedType>");

        String typeStr;

        GenericDeclKind(String typeStr) {

            this.typeStr = typeStr;

        }

        String getGenericDeclKind(TypeKind et) {

            return typeStr.replaceAll("#ExtendedType", et==null? "":et.typeStr);

        }

    }

    boolean checkTypeInference() {

        if (parameterType == TypeKind.VOID) {

            if (lambdaBodyType != LambdaBody.RETURN_VOID)

                return false;

        }

        else if (lambdaBodyType != LambdaBody.RETURN_ARG)

            return false;

                return false;

        }

        return true;

    }

    String templateStr = "#C\n" +

                         "interface SAM2 {\n" +

                         "    SAM m();\n" +

                         "}\n";

    SourceFile samSourceFile = new SourceFile("Sam.java", templateStr) {

        public String toString() {

        }

    };

    SourceFile clientSourceFile = new SourceFile("Client.java",

                                                 "class Client { \n" +

                                                 "    #Context\n" +

                                                 "}") {

        public String toString() {

        }

    };

        StringBuilder sb = new StringBuilder("SamKind:");

        DiagnosticChecker dc = new DiagnosticChecker();

        if (dc.errorFound == checkTypeInference()) {

        }

    }

    abstract class SourceFile extends SimpleJavaFileObject {

        protected String template;

        public SourceFile(String filename, String template) {

            super(URI.create("myfo:/" + filename), JavaFileObject.Kind.SOURCE);

            this.template = template;

        }

        @Override

        public CharSequence getCharContent(boolean ignoreEncodingErrors) {

            return toString();

        }

        public abstract String toString();

    }

        boolean errorFound = false;

        public void report(Diagnostic<? extends JavaFileObject> diagnostic) {

            if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {

                errorFound = true;

            }

        }

    }

    SamKind samKind;

    TypeKind samTargetType;

    TypeKind parameterType;

    TypeKind returnType;

    Context context;

    LambdaBody lambdaBodyType;

    LambdaKind lambdaKind;

    ParameterKind parameterKind;

    Keyword keyword;

    GenericDeclKind genericDeclKind;

        samKind = sk;

        samTargetType = samTargetT;

        parameterType = parameterT;

        returnType = returnT;

        context = c;

        lambdaKind = lk;

        parameterKind = pk;

        keyword = kw;

        lambdaBodyType = lb;

        genericDeclKind = gdk;

    }

    public static void main(String[] args) throws Exception {

        for(Context ct : Context.values()) {

            for (TypeKind returnT : TypeKind.values()) {

                for (TypeKind parameterT : TypeKind.values()) {

                    for(LambdaBody lb : LambdaBody.values()) {

                        for (ParameterKind parameterK : ParameterKind.values()) {

                            for(LambdaKind lambdaK : LambdaKind.values()) {

                                for (SamKind sk : SamKind.values()) {

                                    if (sk == SamKind.NON_GENERIC) {

                                    }

                                    else if (sk == SamKind.GENERIC) {

                                    }

                                }

                            }

                        }

                    }

                }

            }

        }

    }

}