/*
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you under the Apache License, Version 2.0 (the
 *  "License"); you may not use this file except in compliance
 *  with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing,
 *  software distributed under the License is distributed on an
 *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 *  specific language governing permissions and limitations
 *  under the License.
 */
package org.apache.groovy.parser.antlr4;

import org.codehaus.groovy.ast.ClassHelper;
import org.codehaus.groovy.ast.Parameter;
import org.codehaus.groovy.ast.expr.ArgumentListExpression;
import org.codehaus.groovy.ast.expr.BinaryExpression;
import org.codehaus.groovy.ast.expr.BooleanExpression;
import org.codehaus.groovy.ast.expr.ConstantExpression;
import org.codehaus.groovy.ast.expr.DeclarationExpression;
import org.codehaus.groovy.ast.expr.Expression;
import org.codehaus.groovy.ast.expr.MethodCallExpression;
import org.codehaus.groovy.ast.expr.VariableExpression;
import org.codehaus.groovy.ast.stmt.BlockStatement;
import org.codehaus.groovy.ast.stmt.CatchStatement;
import org.codehaus.groovy.ast.stmt.EmptyStatement;
import org.codehaus.groovy.ast.stmt.ExpressionStatement;
import org.codehaus.groovy.ast.stmt.IfStatement;
import org.codehaus.groovy.ast.stmt.Statement;
import org.codehaus.groovy.ast.stmt.ThrowStatement;
import org.codehaus.groovy.ast.stmt.TryCatchStatement;
import org.codehaus.groovy.syntax.Types;
import org.objectweb.asm.Opcodes;

import java.util.Collections;
import java.util.List;

import static org.codehaus.groovy.ast.tools.GeneralUtils.localVarX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.nullX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.tryCatchS;
import static org.codehaus.groovy.runtime.DefaultGroovyMethods.asBoolean;
import static org.codehaus.groovy.syntax.Token.newSymbol;

/**
 * Transform try-with-resources to try-catch-finally
 * Reference JLS "14.20.3. try-with-resources"(https://docs.oracle.com/javase/specs/jls/se7/html/jls-14.html)
 */
public class TryWithResourcesASTTransformation {
    private AstBuilder astBuilder;

    public TryWithResourcesASTTransformation(AstBuilder astBuilder) {
        this.astBuilder = astBuilder;
    }

    /**
     * Reference JLS "14.20.3. try-with-resources"(https://docs.oracle.com/javase/specs/jls/se7/html/jls-14.html)
     *
     * @param tryCatchStatement the try-with-resources statement to transform
     * @return try-catch-finally statement, which contains no resources clause
     */
    public Statement transform(TryCatchStatement tryCatchStatement) {
        if (!asBoolean(tryCatchStatement.getResourceStatements())) {
            return tryCatchStatement;
        }

        if (this.isBasicTryWithResourcesStatement(tryCatchStatement)) {
            return this.transformBasicTryWithResourcesStatement(tryCatchStatement);
        } else {
            return this.transformExtendedTryWithResourcesStatement(tryCatchStatement);
        }
    }

    private boolean isBasicTryWithResourcesStatement(TryCatchStatement tryCatchStatement) {
        if (tryCatchStatement.getFinallyStatement() instanceof EmptyStatement &&
                !asBoolean(tryCatchStatement.getCatchStatements())) {
            return true;
        }

        return false;
    }

    private ExpressionStatement makeVariableDeclarationFinal(ExpressionStatement variableDeclaration) {
        if (!asBoolean(variableDeclaration)) {
            return variableDeclaration;
        }

        if (!(variableDeclaration.getExpression() instanceof DeclarationExpression)) {
            throw new IllegalArgumentException("variableDeclaration is not a declaration statement");
        }

        DeclarationExpression declarationExpression = (DeclarationExpression) variableDeclaration.getExpression();
        if (!(declarationExpression.getLeftExpression() instanceof VariableExpression)) {
            throw astBuilder.createParsingFailedException("The expression statement is not a variable delcaration statement", variableDeclaration);
        }

        VariableExpression variableExpression = (VariableExpression) declarationExpression.getLeftExpression();
        variableExpression.setModifiers(variableExpression.getModifiers() | Opcodes.ACC_FINAL);

        return variableDeclaration;
    }

    private int primaryExcCnt = 0;
    private String genPrimaryExcName() {
        return "__$$primaryExc" + primaryExcCnt++;
    }

    /*
     *   try ResourceSpecification
     *       Block
     *   Catchesopt
     *   Finallyopt
     *
     *   **The above AST should be transformed to the following AST**
     *
     *   try {
     *       try ResourceSpecification
     *           Block
     *   }
     *   Catchesopt
     *   Finallyopt
     */
    private Statement transformExtendedTryWithResourcesStatement(TryCatchStatement tryCatchStatement) {
        /*
         *  try ResourceSpecification
         *      Block
         */
        TryCatchStatement newTryWithResourcesStatement = tryCatchS(tryCatchStatement.getTryStatement());
        tryCatchStatement.getResourceStatements().forEach(newTryWithResourcesStatement::addResource);

        /*
         *   try {
         *       << the following try-with-resources has been transformed >>
         *       try ResourceSpecification
         *           Block
         *   }
         *   Catchesopt
         *   Finallyopt
         */
        TryCatchStatement newTryCatchStatement = tryCatchS(
                astBuilder.createBlockStatement(this.transform(newTryWithResourcesStatement)),
                tryCatchStatement.getFinallyStatement());
        tryCatchStatement.getCatchStatements().forEach(newTryCatchStatement::addCatch);

        return newTryCatchStatement;
    }

    /*
     *   try (VariableModifiersopt R Identifier = Expression ...)
     *      Block
     *
     *  **The above AST should be transformed to the following AST**
     *
     *   {
     *       final VariableModifiers_minus_final R Identifier = Expression;
     *       Throwable #primaryExc = null;
     *
     *       try ResourceSpecification_tail
     *           Block
     *       catch (Throwable #t) {
     *           #primaryExc = #t;
     *           throw #t;
     *       } finally {
     *           if (Identifier != null) {
     *               if (#primaryExc != null) {
     *                   try {
     *                       Identifier.close();
     *                   } catch (Throwable #suppressedExc) {
     *                       #primaryExc.addSuppressed(#suppressedExc);
     *                   }
     *               } else {
     *                   Identifier.close();
     *               }
     *           }
     *       }
     *   }
     *
     */
    private Statement transformBasicTryWithResourcesStatement(TryCatchStatement tryCatchStatement) {
        // { ... }
        BlockStatement blockStatement = new BlockStatement();

        // final VariableModifiers_minus_final R Identifier = Expression;
        ExpressionStatement firstResourceStatement =
                this.makeVariableDeclarationFinal(
                        tryCatchStatement.getResourceStatement(0));
        astBuilder.appendStatementsToBlockStatement(blockStatement, firstResourceStatement);

        // Throwable #primaryExc = null;
        String primaryExcName = this.genPrimaryExcName();
        VariableExpression primaryExcX = localVarX(primaryExcName, ClassHelper.THROWABLE_TYPE.getPlainNodeReference());
        ExpressionStatement primaryExcDeclarationStatement =
                new ExpressionStatement(
                        new DeclarationExpression(
                                primaryExcX,
                                newSymbol(Types.ASSIGN, -1, -1),
                                nullX()
                        )
                );
        astBuilder.appendStatementsToBlockStatement(blockStatement, primaryExcDeclarationStatement);

        // The generated try-catch-finally statement
        String firstResourceIdentifierName =
                ((DeclarationExpression) tryCatchStatement.getResourceStatement(0).getExpression()).getLeftExpression().getText();

        TryCatchStatement newTryCatchStatement = tryCatchS(
                tryCatchStatement.getTryStatement(),
                this.createFinallyBlockForNewTryCatchStatement(primaryExcName, firstResourceIdentifierName));

        List<ExpressionStatement> resourceStatements = tryCatchStatement.getResourceStatements();
        // 2nd, 3rd, ..., n'th resources declared in resources
        List<ExpressionStatement> tailResourceStatements = resourceStatements.subList(1, resourceStatements.size());
        tailResourceStatements.stream().forEach(newTryCatchStatement::addResource);

        newTryCatchStatement.addCatch(this.createCatchBlockForOuterNewTryCatchStatement(primaryExcName));
        astBuilder.appendStatementsToBlockStatement(blockStatement, this.transform(newTryCatchStatement));

        return blockStatement;
    }

    /*
     *   catch (Throwable #t) {
     *       #primaryExc = #t;
     *       throw #t;
     *   }
     *
     */
    private CatchStatement createCatchBlockForOuterNewTryCatchStatement(String primaryExcName) {
        // { ... }
        BlockStatement blockStatement = new BlockStatement();
        String tExcName = this.genTExcName();

        // #primaryExc = #t;
        ExpressionStatement primaryExcAssignStatement =
                new ExpressionStatement(
                        new BinaryExpression(
                                new VariableExpression(primaryExcName),
                                newSymbol(Types.ASSIGN, -1, -1),
                                new VariableExpression(tExcName)));
        astBuilder.appendStatementsToBlockStatement(blockStatement, primaryExcAssignStatement);

        // throw #t;
        ThrowStatement throwTExcStatement = new ThrowStatement(new VariableExpression(tExcName));
        astBuilder.appendStatementsToBlockStatement(blockStatement, throwTExcStatement);

        // Throwable #t
        Parameter tExcParameter = new Parameter(ClassHelper.THROWABLE_TYPE.getPlainNodeReference(), tExcName);

        return new CatchStatement(tExcParameter, blockStatement);
    }

    private int tExcCnt = 0;
    private String genTExcName() {
        return "__$$t" + tExcCnt++;
    }

    /*
     *   finally {
     *       if (Identifier != null) {
     *           if (#primaryExc != null) {
     *              try {
     *                  Identifier.close();
     *              } catch (Throwable #suppressedExc) {
     *                  #primaryExc.addSuppressed(#suppressedExc);
     *              }
     *           } else {
     *               Identifier.close();
     *           }
     *       }
     *   }
     *
     * We can simplify the above code to a Groovy version as follows:
     *
     *   finally {
     *      if (#primaryExc != null)
     *         try {
     *             Identifier?.close();
     *         } catch (Throwable #suppressedExc) {
     *             #primaryExc.addSuppressed(#suppressedExc);
     *         }
     *      else
     *          Identifier?.close();
     *
     *   }
     *
     */
    private BlockStatement createFinallyBlockForNewTryCatchStatement(String primaryExcName, String firstResourceIdentifierName) {
        BlockStatement finallyBlock = new BlockStatement();

        // primaryExc != null
        BooleanExpression conditionExpression =
                new BooleanExpression(
                        new BinaryExpression(
                                new VariableExpression(primaryExcName),
                                newSymbol(Types.COMPARE_NOT_EQUAL, -1, -1),
                                new ConstantExpression(null)));

        // try-catch statement
        TryCatchStatement newTryCatchStatement = tryCatchS(
                astBuilder.createBlockStatement(this.createCloseResourceStatement(firstResourceIdentifierName)) /* { Identifier?.close(); }*/);

        String suppressedExcName = this.genSuppressedExcName();
        newTryCatchStatement.addCatch(
                // catch (Throwable #suppressedExc) { .. }
                new CatchStatement(
                        new Parameter(ClassHelper.THROWABLE_TYPE.getPlainNodeReference(), suppressedExcName),
                        astBuilder.createBlockStatement(this.createAddSuppressedStatement(primaryExcName, suppressedExcName)) // #primaryExc.addSuppressed(#suppressedExc);
                )
        );

        // if (#primaryExc != null) { ... }
        IfStatement ifStatement =
                new IfStatement(
                        conditionExpression,
                        newTryCatchStatement,
                        this.createCloseResourceStatement(firstResourceIdentifierName) // Identifier?.close();
                );
        astBuilder.appendStatementsToBlockStatement(finallyBlock, ifStatement);

        return astBuilder.createBlockStatement(finallyBlock);
    }

    private int suppressedExcCnt = 0;
    private String genSuppressedExcName() {
        return "__$$suppressedExc" + suppressedExcCnt++;
    }

    /*
     *  Identifier?.close();
     */
    private ExpressionStatement createCloseResourceStatement(String firstResourceIdentifierName) {
        MethodCallExpression closeMethodCallExpression =
                new MethodCallExpression(new VariableExpression(firstResourceIdentifierName), "close", new ArgumentListExpression());

        closeMethodCallExpression.setImplicitThis(false);
        closeMethodCallExpression.setSafe(true);

        return new ExpressionStatement(closeMethodCallExpression);
    }

    /*
     *  #primaryExc.addSuppressed(#suppressedExc);
     */
    private ExpressionStatement createAddSuppressedStatement(String primaryExcName, String suppressedExcName) {
        MethodCallExpression addSuppressedMethodCallExpression =
                new MethodCallExpression(
                        new VariableExpression(primaryExcName),
                        "addSuppressed",
                        new ArgumentListExpression(Collections.singletonList(new VariableExpression(suppressedExcName))));
        addSuppressedMethodCallExpression.setImplicitThis(false);
        addSuppressedMethodCallExpression.setSafe(true);

        return new ExpressionStatement(addSuppressedMethodCallExpression);
    }

    /**
     * See https://docs.oracle.com/javase/specs/jls/se9/html/jls-14.html
     * 14.20.3.1. Basic try-with-resources
     *
     * If a basic try-with-resource statement is of the form:
     * try (VariableAccess ...)
     *      Block
     *
     * then the resource is first converted to a local variable declaration by the following translation:
     * try (T #r = VariableAccess ...) {
     *      Block
     * }
     */
    public BinaryExpression transformResourceAccess(Expression variableAccessExpression) {
        return new BinaryExpression(
                new VariableExpression(genResourceName()),
                newSymbol(Types.ASSIGN, -1, -1),
                variableAccessExpression
        );
    }

    private int resourceCnt = 0;
    private String genResourceName() {
        return "__$$resource" + resourceCnt++;
    }

}
