/*
 * Copyright 2010 The Closure Compiler Authors.
 *
 * Licensed 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 com.google.javascript.jscomp;

import com.google.common.base.Preconditions;
import com.google.javascript.jscomp.NodeTraversal.AbstractPostOrderCallback;
import com.google.javascript.jscomp.VariableVisibilityAnalysis.VariableVisibility;
import com.google.javascript.rhino.Node;

/**
 * Tests of {@link VariableVisibilityAnalysis}.
 *
 * @author dcc@google.com (Devin Coughlin)
 */
public class VariableVisibilityAnalysisTest extends CompilerTestCase {

  private Compiler lastCompiler;
  private VariableVisibilityAnalysis lastAnalysis;

  @Override
  protected CompilerPass getProcessor(Compiler compiler) {
    lastAnalysis = new VariableVisibilityAnalysis(compiler);
    lastCompiler = compiler;

    return lastAnalysis;
  }

  public void testCapturedVariables() {
    String source =
        "global:var global;\n" +
        "function Outer() {\n" +
        "  captured:var captured;\n" +
        "  notcaptured:var notCaptured;\n" +
        "  function Inner() {\n" +
        "    alert(captured);" +
        "   }\n" +
        "}\n";

    analyze(source);

    assertIsCapturedLocal("captured");
    assertIsUncapturedLocal("notcaptured");
  }

  public void testGlobals() {
    String source =
      "global:var global;";

    analyze(source);

    assertIsGlobal("global");
  }

  public void testParameters() {
    String source =
      "function A(a,b,c) {\n" +
      "}\n";

    analyze(source);

    assertIsParameter("a");
    assertIsParameter("b");
    assertIsParameter("c");
  }

  public void testFunctions() {
    String source =
        "function global() {\n" +
        "  function inner() {\n" +
        "  }\n" +
        "  function innerCaptured() {\n" +
        "    (function(){innerCaptured()})()\n" +
        "  }\n" +
        "}\n";

    analyze(source);

    assertFunctionHasVisibility("global",
        VariableVisibility.GLOBAL);

    assertFunctionHasVisibility("inner",
        VariableVisibility.LOCAL);

    assertFunctionHasVisibility("innerCaptured",
        VariableVisibility.CAPTURED_LOCAL);
  }

  private void assertFunctionHasVisibility(String functionName,
      VariableVisibility visibility) {

    Node functionNode = searchForFunction(functionName);
    assertNotNull(functionNode);

    Node nameNode = functionNode.getFirstChild();
    assertEquals(visibility, lastAnalysis.getVariableVisibility(nameNode));
  }

  private void assertLabeledVariableHasVisibility(String label,
      VariableVisibility visibility) {
    Node labeledVariable = searchLabel(label);

    Preconditions.checkState(labeledVariable.isVar());

    // VAR
    //   NAME
    Node nameNode = labeledVariable.getFirstChild();

    assertEquals(visibility, lastAnalysis.getVariableVisibility(nameNode));
  }

  private void assertIsCapturedLocal(String label) {
    assertLabeledVariableHasVisibility(label,
        VariableVisibility.CAPTURED_LOCAL);
  }

  private void assertIsUncapturedLocal(String label) {
    assertLabeledVariableHasVisibility(label,
        VariableVisibility.LOCAL);
  }

  private void assertIsGlobal(String label) {
    assertLabeledVariableHasVisibility(label,
        VariableVisibility.GLOBAL);
  }

  private void assertIsParameter(String parameterName) {
    Node parameterNode = searchForParameter(parameterName);

    assertNotNull(parameterNode);

    assertEquals(VariableVisibility.PARAMETER,
        lastAnalysis.getVariableVisibility(parameterNode));
  }

  private VariableVisibilityAnalysis analyze(String src) {
    testSame(src);

    return lastAnalysis;
  }

  /*
   * Finds a parameter NAME node with the given name in the source AST.
   *
   * Behavior is undefined if there are multiple parameters with
   * parameterName.
   */
  private Node searchForParameter(final String parameterName) {
    Preconditions.checkArgument(parameterName != null);

    final Node[] foundNode = new Node[1];

    AbstractPostOrderCallback findParameter = new AbstractPostOrderCallback() {

      @Override
      public void visit(NodeTraversal t, Node n, Node parent) {
        if (n.getParent().isParamList()
            && parameterName.equals(n.getString())) {

          foundNode[0] = n;
        }
      }
    };

    new NodeTraversal(lastCompiler, findParameter)
        .traverse(lastCompiler.jsRoot);

    return foundNode[0];
  }

  /*
   * Finds a function node with the given name in the source AST.
   *
   * Behavior is undefined if there are multiple functions with
   * parameterName.
   */
  private Node searchForFunction(final String functionName) {
    Preconditions.checkArgument(functionName != null);

    final Node[] foundNode = new Node[1];

    AbstractPostOrderCallback findFunction = new AbstractPostOrderCallback() {

      @Override
      public void visit(NodeTraversal t, Node n, Node parent) {
        if (n.isFunction()
            && functionName.equals(NodeUtil.getFunctionName(n))) {
          foundNode[0] = n;
        }
      }
    };

    new NodeTraversal(lastCompiler, findFunction)
        .traverse(lastCompiler.jsRoot);

    return foundNode[0];
  }

  // Shamelessly stolen from NameReferenceGraphConstructionTest
  private Node searchLabel(String label) {
    LabeledVariableSearcher s = new LabeledVariableSearcher(label);

    new NodeTraversal(lastCompiler, s).traverse(lastCompiler.jsRoot);
    assertNotNull("Label " + label + " should be in the source code", s.found);

    return s.found;
  }

  /**
   * Quick traversal to find a given labeled variable in the AST.
   *
   * Finds the variable for foo in:
   * foo: var a = ...
   */
  private class LabeledVariableSearcher extends AbstractPostOrderCallback {
    Node found = null;
    final String target;

    LabeledVariableSearcher(String target) {
      this.target = target;
    }
    @Override
    public void visit(NodeTraversal t, Node n, Node parent) {
      if (n.isLabel() &&
          target.equals(n.getFirstChild().getString())) {

        // LABEL
        //     VAR
        //       NAME

        found = n.getLastChild();
      }
    }
  }
}