/*

 * Copyright (c) 2017, 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.tools.javac.comp;

import com.sun.tools.javac.code.Flags;

import com.sun.tools.javac.code.Symbol.VarSymbol;

import com.sun.tools.javac.code.Symtab;

import com.sun.tools.javac.code.Type;

import com.sun.tools.javac.code.Types;

import com.sun.tools.javac.comp.MatchBindingsComputer.BindingSymbol;

import com.sun.tools.javac.tree.JCTree;

import com.sun.tools.javac.tree.JCTree.JCAssign;

import com.sun.tools.javac.tree.JCTree.JCBinary;

import com.sun.tools.javac.tree.JCTree.JCConditional;

import com.sun.tools.javac.tree.JCTree.JCExpression;

import com.sun.tools.javac.tree.JCTree.JCForLoop;

import com.sun.tools.javac.tree.JCTree.JCIdent;

import com.sun.tools.javac.tree.JCTree.JCIf;

import com.sun.tools.javac.tree.JCTree.JCInstanceOf;

import com.sun.tools.javac.tree.JCTree.JCLabeledStatement;

import com.sun.tools.javac.tree.JCTree.JCMethodDecl;

import com.sun.tools.javac.tree.JCTree.JCStatement;

import com.sun.tools.javac.tree.JCTree.JCVariableDecl;

import com.sun.tools.javac.tree.JCTree.JCBindingPattern;

import com.sun.tools.javac.tree.JCTree.JCWhileLoop;

import com.sun.tools.javac.tree.JCTree.Tag;

import com.sun.tools.javac.tree.TreeMaker;

import com.sun.tools.javac.tree.TreeTranslator;

import com.sun.tools.javac.util.Assert;

import com.sun.tools.javac.util.Context;

import com.sun.tools.javac.util.List;

import com.sun.tools.javac.util.ListBuffer;

import com.sun.tools.javac.util.Log;

import com.sun.tools.javac.util.Names;

import com.sun.tools.javac.util.Options;

import java.util.Map;

import java.util.Map.Entry;

import java.util.stream.Collectors;

import com.sun.tools.javac.code.Symbol.MethodSymbol;

import static com.sun.tools.javac.code.TypeTag.BOOLEAN;

import static com.sun.tools.javac.code.TypeTag.BOT;

import com.sun.tools.javac.comp.MatchBindingsComputer.BindingSymbol;

import com.sun.tools.javac.jvm.Target;

import com.sun.tools.javac.tree.JCTree.JCBlock;

import com.sun.tools.javac.tree.JCTree.JCDoWhileLoop;

import com.sun.tools.javac.tree.JCTree.JCStatement;

import com.sun.tools.javac.tree.JCTree.LetExpr;

import com.sun.tools.javac.util.List;

/**

 * This pass translates pattern-matching constructs, such as instanceof <pattern>.

 */

public class TransPatterns extends TreeTranslator {

    protected static final Context.Key<TransPatterns> transPatternsKey = new Context.Key<>();

    public static TransPatterns instance(Context context) {

        TransPatterns instance = context.get(transPatternsKey);

        if (instance == null)

            instance = new TransPatterns(context);

        return instance;

    }

    private final Symtab syms;

    private final Types types;

    private final Operators operators;

    private final Log log;

    private final ConstFold constFold;

    private final Names names;

    private final Target target;

    private final MatchBindingsComputer matchBindingsComputer;

    private TreeMaker make;

    BindingContext bindingContext = new BindingContext() {

        @Override

        VarSymbol getBindingFor(BindingSymbol varSymbol) {

            return null;

        }

        @Override

        JCStatement decorateStatement(JCStatement stat) {

            return stat;

        }

        @Override

        JCExpression decorateExpression(JCExpression expr) {

            return expr;

        }

        @Override

        BindingContext pop() {

            //do nothing

            return this;

        }

        @Override

        boolean tryPrepend(BindingSymbol binding, JCVariableDecl var) {

            return false;

        }

    };

    JCLabeledStatement pendingMatchLabel = null;

    boolean debugTransPatterns;

    private MethodSymbol currentMethodSym = null;

    protected TransPatterns(Context context) {

        context.put(transPatternsKey, this);

        syms = Symtab.instance(context);

        make = TreeMaker.instance(context);

        types = Types.instance(context);

        operators = Operators.instance(context);

        log = Log.instance(context);

        constFold = ConstFold.instance(context);

        names = Names.instance(context);

        target = Target.instance(context);

        matchBindingsComputer = MatchBindingsComputer.instance(context);

        debugTransPatterns = Options.instance(context).isSet("debug.patterns");

    }

    @Override

    public void visitTypeTest(JCInstanceOf tree) {

        if (tree.pattern.hasTag(Tag.BINDINGPATTERN)) {

            //E instanceof T N

            //=>

            //(let T' N$temp = E; N$temp instanceof T && (N = (T) N$temp == (T) N$temp))

            JCBindingPattern patt = (JCBindingPattern)tree.pattern;

            VarSymbol pattSym = patt.symbol;

            Type tempType = tree.expr.type.hasTag(BOT) ?

                    syms.objectType

                    : tree.expr.type;

            VarSymbol temp = new VarSymbol(pattSym.flags() | Flags.SYNTHETIC,

                    names.fromString(pattSym.name.toString() + target.syntheticNameChar() + "temp"),

                    tempType,

                    patt.symbol.owner);

            JCExpression translatedExpr = translate(tree.expr);

            Type castTargetType = types.boxedTypeOrType(pattSym.erasure(types));

            result = makeTypeTest(make.Ident(temp), make.Type(castTargetType));

            VarSymbol bindingVar = bindingContext.getBindingFor(patt.symbol);

            if (bindingVar != null) {

                JCAssign fakeInit = (JCAssign)make.at(tree.pos).Assign(

                        make.Ident(bindingVar), convert(make.Ident(temp), castTargetType)).setType(bindingVar.erasure(types));

                result = makeBinary(Tag.AND, (JCExpression)result,

                        makeBinary(Tag.EQ, fakeInit, convert(make.Ident(temp), castTargetType)));

            }

            result = make.at(tree.pos).LetExpr(make.VarDef(temp, translatedExpr), (JCExpression)result).setType(syms.booleanType);

            ((LetExpr) result).needsCond = true;

        } else {

            super.visitTypeTest(tree);

        }

    }

    @Override

    public void visitBinary(JCBinary tree) {

        List<BindingSymbol> matchBindings;

        switch (tree.getTag()) {

            case AND:

                matchBindings = matchBindingsComputer.getMatchBindings(tree.lhs, true);

                break;

            case OR:

                matchBindings = matchBindingsComputer.getMatchBindings(tree.lhs, false);

                break;

            default:

                matchBindings = List.nil();

                break;

        }

        bindingContext = new BasicBindingContext(matchBindings);

        try {

            super.visitBinary(tree);

            result = bindingContext.decorateExpression(tree);

        } finally {

            bindingContext.pop();

        }

    }

    @Override

    public void visitConditional(JCConditional tree) {

        bindingContext = new BasicBindingContext(

                matchBindingsComputer.getMatchBindings(tree.cond, true)

                        .appendList(matchBindingsComputer.getMatchBindings(tree.cond, false)));

        try {

            super.visitConditional(tree);

            result = bindingContext.decorateExpression(tree);

        } finally {

            bindingContext.pop();

        }

    }

    @Override

    public void visitIf(JCIf tree) {

        bindingContext = new BasicBindingContext(getMatchBindings(tree.cond));

        try {

            super.visitIf(tree);

            result = bindingContext.decorateStatement(tree);

        } finally {

            bindingContext.pop();

        }

    }

    @Override

    public void visitForLoop(JCForLoop tree) {

        bindingContext = new BasicBindingContext(getMatchBindings(tree.cond));

        try {

            super.visitForLoop(tree);

            result = bindingContext.decorateStatement(tree);

        } finally {

            bindingContext.pop();

        }

    }

    @Override

    public void visitWhileLoop(JCWhileLoop tree) {

        bindingContext = new BasicBindingContext(getMatchBindings(tree.cond));

        try {

            super.visitWhileLoop(tree);

            result = bindingContext.decorateStatement(tree);

        } finally {

            bindingContext.pop();

        }

    }

    @Override

    public void visitDoLoop(JCDoWhileLoop tree) {

        bindingContext = new BasicBindingContext(getMatchBindings(tree.cond));

        try {

            super.visitDoLoop(tree);

            result = bindingContext.decorateStatement(tree);

        } finally {

            bindingContext.pop();

        }

    }

    @Override

    public void visitMethodDef(JCMethodDecl tree) {

        MethodSymbol prevMethodSym = currentMethodSym;

        try {

            currentMethodSym = tree.sym;

            super.visitMethodDef(tree);

        } finally {

            currentMethodSym = prevMethodSym;

        }

    }

    @Override

    public void visitIdent(JCIdent tree) {

        VarSymbol bindingVar = null;

        if ((tree.sym.flags() & Flags.MATCH_BINDING) != 0) {

            bindingVar = bindingContext.getBindingFor((BindingSymbol)tree.sym);

        }

        if (bindingVar == null) {

            super.visitIdent(tree);

        } else {

            result = make.at(tree.pos).Ident(bindingVar);

        }

    }

    @Override

    public void visitBlock(JCBlock tree) {

        ListBuffer<JCStatement> statements = new ListBuffer<>();

        bindingContext = new BasicBindingContext(List.nil()) {

            boolean tryPrepend(BindingSymbol binding, JCVariableDecl var) {

                //{

                //    if (E instanceof T N) {

                //        return ;

                //    }

                //    //use of N:

                //}

                //=>

                //{

                //    T N;

                //    if ((let T' N$temp = E; N$temp instanceof T && (N = (T) N$temp == (T) N$temp))) {

                //        return ;

                //    }

                //    //use of N:

                //}

                hoistedVarMap.put(binding, var.sym);

                statements.append(var);

                return true;

            }

        };

        try {

            for (List<JCStatement> l = tree.stats; l.nonEmpty(); l = l.tail) {

                statements.append(translate(l.head));

            }

            tree.stats = statements.toList();

            result = tree;

        } finally {

            bindingContext.pop();

        }

    }

    public JCTree translateTopLevelClass(Env<AttrContext> env, JCTree cdef, TreeMaker make) {

        try {

            this.make = make;

            translate(cdef);

        } finally {

            // note that recursive invocations of this method fail hard

            this.make = null;

        }

        return cdef;

    }

    /** Make an instanceof expression.

     *  @param lhs      The expression.

     *  @param type     The type to be tested.

     */

    JCInstanceOf makeTypeTest(JCExpression lhs, JCExpression type) {

        JCInstanceOf tree = make.TypeTest(lhs, type);

        tree.type = syms.booleanType;

        return tree;

    }

    /** Make an attributed binary expression (copied from Lower).

     *  @param optag    The operators tree tag.

     *  @param lhs      The operator's left argument.

     *  @param rhs      The operator's right argument.

     */

    JCBinary makeBinary(JCTree.Tag optag, JCExpression lhs, JCExpression rhs) {

        JCBinary tree = make.Binary(optag, lhs, rhs);

        tree.operator = operators.resolveBinary(tree, optag, lhs.type, rhs.type);

        tree.type = tree.operator.type.getReturnType();

        return tree;

    }

    JCExpression convert(JCExpression expr, Type target) {

        JCExpression result = make.at(expr.pos()).TypeCast(make.Type(target), expr);

        result.type = target;

        return result;

    }

    private List<BindingSymbol> getMatchBindings(JCExpression cond) {

        return matchBindingsComputer.getMatchBindings(cond, true)

                        .appendList(matchBindingsComputer.getMatchBindings(cond, false));

    }

    abstract class BindingContext {

        abstract VarSymbol getBindingFor(BindingSymbol varSymbol);

        abstract JCStatement decorateStatement(JCStatement stat);

        abstract JCExpression decorateExpression(JCExpression expr);

        abstract BindingContext pop();

        abstract boolean tryPrepend(BindingSymbol binding, JCVariableDecl var);

    }

    class BasicBindingContext extends BindingContext {

        List<BindingSymbol> matchBindings;

        Map<BindingSymbol, VarSymbol> hoistedVarMap;

        BindingContext parent;

        public BasicBindingContext(List<BindingSymbol> matchBindings) {

            this.matchBindings = matchBindings;

            this.parent = bindingContext;

            this.hoistedVarMap = matchBindings.stream()

                    .filter(v -> parent.getBindingFor(v) == null)

                    .collect(Collectors.toMap(v -> v, v -> {

                        VarSymbol res = new VarSymbol(v.flags(), v.name, v.type, v.owner);

                        res.setTypeAttributes(v.getRawTypeAttributes());

                        return res;

                    }));

        }

        @Override

        VarSymbol getBindingFor(BindingSymbol varSymbol) {

            VarSymbol res = parent.getBindingFor(varSymbol);

            if (res != null) {

                return res;

            }

            return hoistedVarMap.entrySet().stream()

                    .filter(e -> e.getKey().isAliasFor(varSymbol))

                    .findFirst()

                    .map(e -> e.getValue()).orElse(null);

        }

        @Override

        JCStatement decorateStatement(JCStatement stat) {

            if (hoistedVarMap.isEmpty()) return stat;

            //if (E instanceof T N) {

            //     //use N

            //}

            //=>

            //{

            //    T N;

            //    if ((let T' N$temp = E; N$temp instanceof T && (N = (T) N$temp == (T) N$temp))) {

            //        //use N

            //    }

            //}

            ListBuffer<JCStatement> stats = new ListBuffer<>();

            for (Entry<BindingSymbol, VarSymbol> e : hoistedVarMap.entrySet()) {

                JCVariableDecl decl = makeHoistedVarDecl(stat.pos, e.getValue());

                if (!e.getKey().isPreserved() ||

                    !parent.tryPrepend(e.getKey(), decl)) {

                    stats.add(decl);

                }

            }

            if (stats.nonEmpty()) {

                stats.add(stat);

                stat = make.at(stat.pos).Block(0, stats.toList());

            }

            return stat;

        }

        @Override

        JCExpression decorateExpression(JCExpression expr) {

            //E instanceof T N && /*use of N*/

            //=>

            //(let T N; (let T' N$temp = E; N$temp instanceof T && (N = (T) N$temp == (T) N$temp)) && /*use of N*/)

            for (VarSymbol vsym : hoistedVarMap.values()) {

                expr = make.at(expr.pos).LetExpr(makeHoistedVarDecl(expr.pos, vsym), expr).setType(expr.type);

            }

            return expr;

        }

        @Override

        BindingContext pop() {

            return bindingContext = parent;

        }

        @Override

        boolean tryPrepend(BindingSymbol binding, JCVariableDecl var) {

            return false;

        }

        private JCVariableDecl makeHoistedVarDecl(int pos, VarSymbol varSymbol) {

            return make.at(pos).VarDef(varSymbol, null);

        }

    }

}