/*
 * Copyright (c) 2013, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html
 * 
 * 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.dart.engine.parser;

import com.google.dart.engine.EngineTestCase;
import com.google.dart.engine.ast.CompilationUnit;
import com.google.dart.engine.error.GatheringErrorListener;
import com.google.dart.engine.scanner.CharSequenceReader;
import com.google.dart.engine.scanner.IncrementalScanner;
import com.google.dart.engine.scanner.Scanner;
import com.google.dart.engine.scanner.Token;
import com.google.dart.engine.source.Source;
import com.google.dart.engine.source.TestSource;
import com.google.dart.engine.utilities.ast.AstComparator;

public class IncrementalParserTest extends EngineTestCase {
  public void fail_replace_identifier_with_functionLiteral_in_initializer() {
    // Function literals aren't allowed inside initializers; incremental parsing needs to gather
    // the appropriate context.
    //
    // "class A { var a; A(b) : a = b ? b : 0 { } }"
    // "class A { var a; A(b) : a = b ? () {} : 0 { } }"
    assertParse("class A { var a; A(b) : a = b ? ", "b", "() {}", " : 0 { } }");
  }

  public void test_delete_everything() {
    // "f() => a + b;"
    // ""
    assertParse("", "f() => a + b;", "", "");
  }

  public void test_delete_identifier_beginning() {
    // "f() => abs + b;"
    // "f() => s + b;"
    assertParse("f() => ", "ab", "", "s + b;");
  }

  public void test_delete_identifier_end() {
    // "f() => abs + b;"
    // "f() => a + b;"
    assertParse("f() => a", "bs", "", " + b;");
  }

  public void test_delete_identifier_middle() {
    // "f() => abs + b;"
    // "f() => as + b;"
    assertParse("f() => a", "b", "", "s + b;");
  }

  public void test_delete_mergeTokens() {
    // "f() => a + b + c;"
    // "f() => ac;"
    assertParse("f() => a", " + b + ", "", "c;");
  }

  public void test_insert_afterIdentifier1() {
    // "f() => a + b;"
    // "f() => abs + b;"
    assertParse("f() => a", "", "bs", " + b;");
  }

  public void test_insert_afterIdentifier2() {
    // "f() => a + b;"
    // "f() => a + bar;"
    assertParse("f() => a + b", "", "ar", ";");
  }

  public void test_insert_beforeIdentifier1() {
    // "f() => a + b;"
    // "f() => xa + b;"
    assertParse("f() => ", "", "x", "a + b;");
  }

  public void test_insert_beforeIdentifier2() {
    // "f() => a + b;"
    // "f() => a + xb;"
    assertParse("f() => a + ", "", "x", "b;");
  }

  public void test_insert_convertOneFunctionToTwo() {
    // "f() {}"
    // "f() => 0; g() {}"
    assertParse("f()", "", " => 0; g()", " {}");
  }

  public void test_insert_end() {
    // "class A {}"
    // "class A {} class B {}"
    assertParse("class A {}", "", " class B {}", "");
  }

  public void test_insert_insideClassBody() {
    // "class C {C(); }"
    // "class C { C(); }"
    assertParse("class C {", "", " ", "C(); }");
  }

  public void test_insert_insideIdentifier() {
    // "f() => cob;"
    // "f() => cow.b;"
    assertParse("f() => co", "", "w.", "b;");
  }

  public void test_insert_newIdentifier1() {
    // "f() => a; c;"
    // "f() => a; b c;"
    assertParse("f() => a;", "", " b", " c;");
  }

  public void test_insert_newIdentifier2() {
    // "f() => a;  c;"
    // "f() => a;b  c;"
    assertParse("f() => a;", "", "b", "  c;");
  }

  public void test_insert_newIdentifier3() {
    // "/** A simple function. */ f() => a; c;"
    // "/** A simple function. */ f() => a; b c;"
    assertParse("/** A simple function. */ f() => a;", "", " b", " c;");
  }

  public void test_insert_newIdentifier4() {
    // "/** An [A]. */ class A {} class B { m() { return 1; } }"
    // "/** An [A]. */ class A {} class B { m() { return 1 + 2; } }"
    assertParse("/** An [A]. */ class A {} class B { m() { return 1", "", " + 2", "; } }");
  }

  public void test_insert_period() {
    // "f() => a + b;"
    // "f() => a + b.;"
    assertParse("f() => a + b", "", ".", ";");
  }

  public void test_insert_period_betweenIdentifiers1() {
    // "f() => a b;"
    // "f() => a. b;"
    assertParse("f() => a", "", ".", " b;");
  }

  public void test_insert_period_betweenIdentifiers2() {
    // "f() => a b;"
    // "f() => a .b;"
    assertParse("f() => a ", "", ".", "b;");
  }

  public void test_insert_period_betweenIdentifiers3() {
    // "f() => a  b;"
    // "f() => a . b;"
    assertParse("f() => a ", "", ".", " b;");
  }

  public void test_insert_period_insideExistingIdentifier() {
    // "f() => ab;"
    // "f() => a.b;"
    assertParse("f() => a", "", ".", "b;");
  }

  public void test_insert_periodAndIdentifier() {
    // "f() => a + b;"
    // "f() => a + b.x;"
    assertParse("f() => a + b", "", ".x", ";");
  }

  public void test_insert_simpleToComplexExression() {
    // "/** An [A]. */ class A {} class B { m() => 1; }"
    // "/** An [A]. */ class A {} class B { m() => 1 + 2; }"
    assertParse("/** An [A]. */ class A {} class B { m() => 1", "", " + 2", "; }");
  }

  public void test_insert_whitespace_end() {
    // "f() => a + b;"
    // "f() => a + b; "
    assertParse("f() => a + b;", "", " ", "");
  }

  public void test_insert_whitespace_end_multiple() {
    // "f() => a + b;"
    // "f() => a + b;  "
    assertParse("f() => a + b;", "", "  ", "");
  }

  public void test_insert_whitespace_middle() {
    // "f() => a + b;"
    // "f() => a  + b;"
    assertParse("f() => a", "", " ", " + b;");
  }

  public void test_replace_identifier_beginning() {
    // "f() => bell + b;"
    // "f() => fell + b;"
    assertParse("f() => ", "b", "f", "ell + b;");
  }

  public void test_replace_identifier_end() {
    // "f() => bell + b;"
    // "f() => belt + b;"
    assertParse("f() => bel", "l", "t", " + b;");
  }

  public void test_replace_identifier_middle() {
    // "f() => first + b;"
    // "f() => frost + b;"
    assertParse("f() => f", "ir", "ro", "st + b;");
  }

  public void test_replace_multiple_partialFirstAndLast() {
    // "f() => aa + bb;"
    // "f() => ab * ab;"
    assertParse("f() => a", "a + b", "b * a", "b;");
  }

  public void test_replace_operator_oneForMany() {
    // "f() => a + b;"
    // "f() => a * c - b;"
    assertParse("f() => a ", "+", "* c -", " b;");
  }

  public void test_replace_operator_oneForOne() {
    // "f() => a + b;"
    // "f() => a * b;"
    assertParse("f() => a ", "+", "*", " b;");
  }

  /**
   * Given a description of the original and modified contents, perform an incremental scan of the
   * two pieces of text.
   * 
   * @param prefix the unchanged text before the edit region
   * @param removed the text that was removed from the original contents
   * @param added the text that was added to the modified contents
   * @param suffix the unchanged text after the edit region
   */
  private void assertParse(String prefix, String removed, String added, String suffix) {
    //
    // Compute the information needed to perform the test.
    //
    String originalContents = prefix + removed + suffix;
    String modifiedContents = prefix + added + suffix;
    int replaceStart = prefix.length();
    Source source = new TestSource();
    //
    // Parse the original contents.
    //
    GatheringErrorListener originalListener = new GatheringErrorListener();
    Scanner originalScanner = new Scanner(
        source,
        new CharSequenceReader(originalContents),
        originalListener);
    Token originalTokens = originalScanner.tokenize();
    assertNotNull(originalTokens);
    Parser originalParser = new Parser(source, originalListener);
    CompilationUnit originalUnit = originalParser.parseCompilationUnit(originalTokens);
    assertNotNull(originalUnit);
    //
    // Parse the modified contents.
    //
    GatheringErrorListener modifiedListener = new GatheringErrorListener();
    Scanner modifiedScanner = new Scanner(
        source,
        new CharSequenceReader(modifiedContents),
        modifiedListener);
    Token modifiedTokens = modifiedScanner.tokenize();
    assertNotNull(modifiedTokens);
    Parser modifiedParser = new Parser(source, modifiedListener);
    CompilationUnit modifiedUnit = modifiedParser.parseCompilationUnit(modifiedTokens);
    assertNotNull(modifiedUnit);
    //
    // Incrementally parse the modified contents.
    //
    GatheringErrorListener incrementalListener = new GatheringErrorListener();
    IncrementalScanner incrementalScanner = new IncrementalScanner(source, new CharSequenceReader(
        modifiedContents), incrementalListener);
    Token incrementalTokens = incrementalScanner.rescan(
        originalTokens,
        replaceStart,
        removed.length(),
        added.length());
    assertNotNull(incrementalTokens);
    IncrementalParser incrementalParser = new IncrementalParser(
        source,
        incrementalScanner.getTokenMap(),
        incrementalListener);
    CompilationUnit incrementalUnit = incrementalParser.reparse(
        originalUnit,
        incrementalScanner.getLeftToken(),
        incrementalScanner.getRightToken(),
        replaceStart,
        prefix.length() + removed.length());
    assertNotNull(incrementalUnit);
    //
    // Validate that the results of the incremental parse are the same as the full parse of the
    // modified source.
    //
    assertTrue(AstComparator.equalNodes(modifiedUnit, incrementalUnit));
    // TODO(brianwilkerson) Verify that the errors are correct?
  }
}