// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:async';

import 'package:analyzer/dart/ast/ast.dart';
import 'package:analyzer/src/dart/analysis/driver.dart';
import 'package:analyzer/src/generated/parser.dart' as analyzer;
import 'package:analyzer/src/generated/source.dart';
import 'package:analyzer_plugin/src/utilities/completion/completion_target.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';

import '../../../support/abstract_context.dart';

main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(CompletionTargetTest);
  });
}

@reflectiveTest
class CompletionTargetTest extends AbstractContextTest {
  Source testSource;
  int completionOffset;
  CompletionTarget target;

  bool get usingFastaParser => analyzer.Parser.useFasta;

  Future<Null> addTestSource(String content) async {
    expect(completionOffset, isNull, reason: 'Call addTestSource exactly once');
    completionOffset = content.indexOf('^');
    expect(completionOffset, isNot(equals(-1)), reason: 'missing ^');
    int nextOffset = content.indexOf('^', completionOffset + 1);
    expect(nextOffset, equals(-1), reason: 'too many ^');
    content = content.substring(0, completionOffset) +
        content.substring(completionOffset + 1);
    testSource = addSource(provider.convertPath('/test.dart'), content);
    AnalysisResult result = await driver.getResult(testSource.fullName);
    target = new CompletionTarget.forOffset(result.unit, completionOffset);
  }

  Future<Null> assertTarget(entityText, nodeText,
      {int argIndex: null,
      bool isFunctionalArgument: false,
      String droppedToken}) async {
    void assertCommon() {
      expect(target.entity.toString(), entityText, reason: 'entity');
      expect(target.containingNode.toString(), nodeText,
          reason: 'containingNode');
      expect(target.argIndex, argIndex, reason: 'argIndex');
      expect(target.droppedToken?.toString(), droppedToken ?? isNull,
          reason: 'droppedToken');
    }

    // Assert with parsed unit
    assertCommon();
    AnalysisResult result = await driver.getResult(testSource.fullName);
    target = new CompletionTarget.forOffset(result.unit, completionOffset);
    // Assert more with resolved unit
    assertCommon();
    expect(target.isFunctionalArgument(), isFunctionalArgument);
  }

  test_ArgumentList_InstanceCreationExpression() async {
    // ArgumentList  InstanceCreationExpression  Block
    await addTestSource('main() {new Foo(^)}');
    await assertTarget(')', '()', argIndex: 0);
  }

  test_ArgumentList_InstanceCreationExpression2() async {
    // ArgumentList  InstanceCreationExpression  Block
    await addTestSource('main() {new Foo(a,^)}');
    await assertTarget(')', '(a)', argIndex: 1);
  }

  test_ArgumentList_InstanceCreationExpression_functionArg2() async {
    // ArgumentList  InstanceCreationExpression  Block
    await addTestSource('main() {new B(^)} class B{B(f()){}}');
    await assertTarget(')', '()', argIndex: 0, isFunctionalArgument: true);
  }

  test_ArgumentList_InstanceCreationExpression_functionArg3() async {
    // ArgumentList  InstanceCreationExpression  Block
    await addTestSource('main() {new B(1, f: ^)} class B{B(int i, {f()}){}}');
    await assertTarget('', 'f: ', argIndex: 1, isFunctionalArgument: true);
  }

  test_ArgumentList_MethodInvocation() async {
    // ArgumentList  MethodInvocation  Block
    await addTestSource('main() {foo(^)}');
    await assertTarget(')', '()', argIndex: 0);
  }

  test_ArgumentList_MethodInvocation2() async {
    // ArgumentList  MethodInvocation  Block
    await addTestSource('main() {foo(^n)}');
    await assertTarget('n', '(n)', argIndex: 0);
  }

  test_ArgumentList_MethodInvocation3() async {
    // ArgumentList  MethodInvocation  Block
    await addTestSource('main() {foo(n^)}');
    await assertTarget('n', '(n)', argIndex: 0);
  }

  test_ArgumentList_MethodInvocation3a() async {
    // ArgumentList  MethodInvocation  Block
    await addTestSource('main() {foo((n)^)}');
    await assertTarget(')', '((n))', argIndex: 0);
  }

  test_ArgumentList_MethodInvocation4() async {
    // ArgumentList  MethodInvocation  Block
    await addTestSource('main() {foo(n,^)}');
    await assertTarget(')', '(n)', argIndex: 1);
  }

  test_ArgumentList_MethodInvocation_functionArg() async {
    // ArgumentList  MethodInvocation  Block
    await addTestSource('main() {foo(^)} foo(f()) {}');
    await assertTarget(')', '()', argIndex: 0, isFunctionalArgument: true);
  }

  test_ArgumentList_MethodInvocation_functionArg2() async {
    // ArgumentList  MethodInvocation  Block
    await addTestSource('main() {new B().boo(^)} class B{boo(f()){}}');
    await assertTarget(')', '()', argIndex: 0, isFunctionalArgument: true);
  }

  test_ArgumentList_MethodInvocation_functionArg3() async {
    // ArgumentList  MethodInvocation  Block
    await addTestSource('main() {foo(f: ^)} foo({f()}) {}');
    await assertTarget('', 'f: ', argIndex: 0, isFunctionalArgument: true);
  }

  test_ArgumentList_MethodInvocation_functionArg4() async {
    // ArgumentList  MethodInvocation  Block
    await addTestSource('main() {new B().boo(f: ^)} class B{boo({f()}){}}');
    await assertTarget('', 'f: ', argIndex: 0, isFunctionalArgument: true);
  }

  test_AsExpression_identifier() async {
    // SimpleIdentifier  TypeName  AsExpression
    await addTestSource(
        'class A {var b; X _c; foo() {var a; (a^ as String).foo();}');
    await assertTarget('a as String', '(a as String)');
  }

  test_AsExpression_keyword() async {
    // SimpleIdentifier  TypeName  AsExpression
    await addTestSource(
        'class A {var b; X _c; foo() {var a; (a ^as String).foo();}');
    await assertTarget('as', 'a as String');
  }

  test_AsExpression_keyword2() async {
    // SimpleIdentifier  TypeName  AsExpression
    await addTestSource(
        'class A {var b; X _c; foo() {var a; (a a^s String).foo();}');
    await assertTarget('as', 'a as String');
  }

  test_AsExpression_keyword3() async {
    // SimpleIdentifier  TypeName  AsExpression
    await addTestSource(
        'class A {var b; X _c; foo() {var a; (a as^ String).foo();}');
    await assertTarget('as', 'a as String');
  }

  test_AsExpression_type() async {
    // SimpleIdentifier  TypeName  AsExpression
    await addTestSource(
        'class A {var b; X _c; foo() {var a; (a as ^String).foo();}');
    await assertTarget('String', 'a as String');
  }

  test_Block() async {
    // Block
    await addTestSource('main() {^}');
    await assertTarget('}', '{}');
  }

  test_Block_keyword() async {
    await addTestSource(
        'class C { static C get instance => null; } main() {C.in^}');
    await assertTarget('in', 'C.in');
  }

  test_Block_keyword2() async {
    await addTestSource(
        'class C { static C get instance => null; } main() {C.i^n}');
    await assertTarget('in', 'C.in');
  }

  test_FormalParameter_partialType() async {
    // SimpleIdentifier  PrefixedIdentifier  TypeName
    await addTestSource('foo(b.^ f) { }');
    await assertTarget('f', 'b.f');
  }

  test_FormalParameter_partialType2() async {
    // SimpleIdentifier  PrefixedIdentifier  TypeName
    await addTestSource('foo(b.z^ f) { }');
    await assertTarget('z', 'b.z');
  }

  test_FormalParameter_partialType3() async {
    // SimpleIdentifier  PrefixedIdentifier  TypeName
    await addTestSource('foo(b.^) { }');
    await assertTarget('', 'b.');
  }

  test_FormalParameterList() async {
    // Token  FormalParameterList  FunctionExpression
    await addTestSource('foo(^) { }');
    await assertTarget(')', '()');
  }

  test_FunctionDeclaration_inLineComment() async {
    // Comment  CompilationUnit
    await addTestSource('''
      // normal comment ^
      zoo(z) { } String name;''');
    await assertTarget('// normal comment ', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_inLineComment2() async {
    // Comment  CompilationUnit
    await addTestSource('''
      // normal ^comment
      zoo(z) { } String name;''');
    await assertTarget('// normal comment', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_inLineComment3() async {
    // Comment  CompilationUnit
    await addTestSource('''
      // normal comment ^
      // normal comment 2
      zoo(z) { } String name;''');
    await assertTarget('// normal comment ', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_inLineComment4() async {
    // Comment  CompilationUnit
    await addTestSource('''
      // normal comment
      // normal comment 2^
      zoo(z) { } String name;''');
    await assertTarget('// normal comment 2', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_inLineDocComment() async {
    // Comment  FunctionDeclaration  CompilationUnit
    await addTestSource('''
      /// some dartdoc ^
      zoo(z) { } String name;''');
    await assertTarget('/// some dartdoc ', '');
    expect(target.containingNode is Comment, isTrue);
    expect(target.containingNode.parent.toSource(), 'zoo(z) {}');
  }

  test_FunctionDeclaration_inLineDocComment2() async {
    // Comment  FunctionDeclaration  CompilationUnit
    await addTestSource('''
      /// some ^dartdoc
      zoo(z) { } String name;''');
    await assertTarget('/// some dartdoc', '');
    expect(target.containingNode is Comment, isTrue);
    expect(target.containingNode.parent.toSource(), 'zoo(z) {}');
  }

  test_FunctionDeclaration_inStarComment() async {
    // Comment  CompilationUnit
    await addTestSource('/* ^ */ zoo(z) {} String name;');
    await assertTarget('/*  */', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_inStarComment2() async {
    // Comment  CompilationUnit
    await addTestSource('/*  *^/ zoo(z) {} String name;');
    await assertTarget('/*  */', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_inStarDocComment() async {
    // Comment  FunctionDeclaration  CompilationUnit
    await addTestSource('/** ^ */ zoo(z) { } String name;');
    await assertTarget('/**  */', '');
    expect(target.containingNode is Comment, isTrue);
    expect(target.containingNode.parent.toSource(), 'zoo(z) {}');
  }

  test_FunctionDeclaration_inStarDocComment2() async {
    // Comment  FunctionDeclaration  CompilationUnit
    await addTestSource('/**  *^/ zoo(z) { } String name;');
    await assertTarget('/**  */', '');
    expect(target.containingNode is Comment, isTrue);
    expect(target.containingNode.parent.toSource(), 'zoo(z) {}');
  }

  test_FunctionDeclaration_returnType() async {
    // CompilationUnit
    await addTestSource('^ zoo(z) { } String name;');
    await assertTarget('zoo(z) {}', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_returnType_afterLineComment() async {
    // FunctionDeclaration  CompilationUnit
    await addTestSource('''
      // normal comment
      ^ zoo(z) {} String name;''');
    await assertTarget('zoo(z) {}', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_returnType_afterLineComment2() async {
    // FunctionDeclaration  CompilationUnit
    // TOD(danrubel) left align all test source
    await addTestSource('''
// normal comment
^ zoo(z) {} String name;''');
    await assertTarget('zoo(z) {}', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_returnType_afterLineDocComment() async {
    // SimpleIdentifier  FunctionDeclaration  CompilationUnit
    await addTestSource('''
      /// some dartdoc
      ^ zoo(z) { } String name; ''');
    await assertTarget('zoo', 'zoo(z) {}');
  }

  test_FunctionDeclaration_returnType_afterLineDocComment2() async {
    // SimpleIdentifier  FunctionDeclaration  CompilationUnit
    await addTestSource('''
/// some dartdoc
^ zoo(z) { } String name;''');
    await assertTarget('zoo', 'zoo(z) {}');
  }

  test_FunctionDeclaration_returnType_afterStarComment() async {
    // CompilationUnit
    await addTestSource('/* */ ^ zoo(z) { } String name;');
    await assertTarget('zoo(z) {}', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_returnType_afterStarComment2() async {
    // CompilationUnit
    await addTestSource('/* */^ zoo(z) { } String name;');
    await assertTarget('zoo(z) {}', 'zoo(z) {} String name;');
  }

  test_FunctionDeclaration_returnType_afterStarDocComment() async {
    // FunctionDeclaration  CompilationUnit
    await addTestSource('/** */ ^ zoo(z) { } String name;');
    await assertTarget('zoo', 'zoo(z) {}');
  }

  test_FunctionDeclaration_returnType_afterStarDocComment2() async {
    // FunctionDeclaration  CompilationUnit
    await addTestSource('/** */^ zoo(z) { } String name;');
    await assertTarget('zoo', 'zoo(z) {}');
  }

  test_InstanceCreationExpression_identifier() async {
    // InstanceCreationExpression  ExpressionStatement  Block
    await addTestSource('class C {foo(){var f; {var x;} new ^C();}}');
    await assertTarget('C', 'new C()');
  }

  test_InstanceCreationExpression_keyword() async {
    // InstanceCreationExpression  ExpressionStatement  Block
    await addTestSource('class C {foo(){var f; {var x;} new^ }}');
    await assertTarget('new ();', '{var f; {var x;} new ();}');
  }

  test_InstanceCreationExpression_keyword2() async {
    // InstanceCreationExpression  ExpressionStatement  Block
    await addTestSource('class C {foo(){var f; {var x;} new^ C();}}');
    await assertTarget('new C();', '{var f; {var x;} new C();}');
  }

  test_MapLiteralEntry() async {
    // MapLiteralEntry  MapLiteral  VariableDeclaration
    await addTestSource('foo = {^');
    // fasta scanner inserts synthetic closing '}'
    await assertTarget('}', '{}');
  }

  test_MapLiteralEntry1() async {
    // MapLiteralEntry  MapLiteral  VariableDeclaration
    await addTestSource('foo = {T^');
    await assertTarget('T : ', '{T : }');
  }

  test_MapLiteralEntry2() async {
    // SimpleIdentifier  MapLiteralEntry  MapLiteral  VariableDeclaration
    await addTestSource('foo = {7:T^};');
    await assertTarget('T', '7 : T');
  }

  test_MethodDeclaration_inLineComment() async {
    // Comment  ClassDeclaration  CompilationUnit
    await addTestSource('''
      class C2 {
        // normal comment ^
        zoo(z) { } String name; }''');
    await assertTarget(
        '// normal comment ', 'class C2 {zoo(z) {} String name;}');
  }

  test_IfStatement_droppedToken() async {
    // Comment  ClassDeclaration  CompilationUnit
    await addTestSource('main() { if (v i^) }');
    if (usingFastaParser) {
      await assertTarget(')', '(v)', droppedToken: 'i');
    } else {
      await assertTarget('i;', 'if (v) i;');
    }
  }

  test_MethodDeclaration_inLineComment2() async {
    // Comment  ClassDeclaration  CompilationUnit
    await addTestSource('''
      class C2 {
        // normal ^comment
        zoo(z) { } String name; }''');
    await assertTarget(
        '// normal comment', 'class C2 {zoo(z) {} String name;}');
  }

  test_MethodDeclaration_inLineComment3() async {
    // Comment  ClassDeclaration  CompilationUnit
    await addTestSource('''
      class C2 {
        // normal comment ^
        // normal comment 2
        zoo(z) { } String name; }''');
    await assertTarget(
        '// normal comment ', 'class C2 {zoo(z) {} String name;}');
  }

  test_MethodDeclaration_inLineComment4() async {
    // Comment  ClassDeclaration  CompilationUnit
    await addTestSource('''
      class C2 {
        // normal comment
        // normal comment 2^
        zoo(z) { } String name; }''');
    await assertTarget(
        '// normal comment 2', 'class C2 {zoo(z) {} String name;}');
  }

  test_MethodDeclaration_inLineDocComment() async {
    // Comment  MethodDeclaration  ClassDeclaration  CompilationUnit
    await addTestSource('''
      class C2 {
        /// some dartdoc ^
        zoo(z) { } String name; }''');
    await assertTarget('/// some dartdoc ', '');
    expect(target.containingNode is Comment, isTrue);
    expect(target.containingNode.parent.toSource(), 'zoo(z) {}');
  }

  test_MethodDeclaration_inLineDocComment2() async {
    // Comment  MethodDeclaration  ClassDeclaration  CompilationUnit
    await addTestSource('''
      class C2 {
        /// some ^dartdoc
        zoo(z) { } String name; }''');
    await assertTarget('/// some dartdoc', '');
    expect(target.containingNode is Comment, isTrue);
    expect(target.containingNode.parent.toSource(), 'zoo(z) {}');
  }

  test_MethodDeclaration_inStarComment() async {
    // Comment  ClassDeclaration  CompilationUnit
    await addTestSource('class C2 {/* ^ */ zoo(z) {} String name;}');
    await assertTarget('/*  */', 'class C2 {zoo(z) {} String name;}');
  }

  test_MethodDeclaration_inStarComment2() async {
    // Comment  ClassDeclaration  CompilationUnit
    await addTestSource('class C2 {/*  *^/ zoo(z) {} String name;}');
    await assertTarget('/*  */', 'class C2 {zoo(z) {} String name;}');
  }

  test_MethodDeclaration_inStarDocComment() async {
    // Comment  MethodDeclaration  ClassDeclaration  CompilationUnit
    await addTestSource('class C2 {/** ^ */ zoo(z) { } String name; }');
    await assertTarget('/**  */', '');
    expect(target.containingNode is Comment, isTrue);
    expect(target.containingNode.parent.toSource(), 'zoo(z) {}');
  }

  test_MethodDeclaration_inStarDocComment2() async {
    // Comment  MethodDeclaration  ClassDeclaration  CompilationUnit
    await addTestSource('class C2 {/**  *^/ zoo(z) { } String name; }');
    await assertTarget('/**  */', '');
    expect(target.containingNode is Comment, isTrue);
    expect(target.containingNode.parent.toSource(), 'zoo(z) {}');
  }

  test_MethodDeclaration_returnType() async {
    // ClassDeclaration  CompilationUnit
    await addTestSource('class C2 {^ zoo(z) { } String name; }');
    await assertTarget('zoo(z) {}', 'class C2 {zoo(z) {} String name;}');
  }

  test_MethodDeclaration_returnType_afterLineComment() async {
    // MethodDeclaration  ClassDeclaration  CompilationUnit
    await addTestSource('''
      class C2 {
        // normal comment
        ^ zoo(z) {} String name;}''');
    await assertTarget('zoo(z) {}', 'class C2 {zoo(z) {} String name;}');
  }

  test_MethodDeclaration_returnType_afterLineComment2() async {
    // MethodDeclaration  ClassDeclaration  CompilationUnit
    // TOD(danrubel) left align all test source
    await addTestSource('''
class C2 {
  // normal comment
^ zoo(z) {} String name;}''');
    await assertTarget('zoo(z) {}', 'class C2 {zoo(z) {} String name;}');
  }

  test_MethodDeclaration_returnType_afterLineDocComment() async {
    // SimpleIdentifier  MethodDeclaration  ClassDeclaration  CompilationUnit
    await addTestSource('''
      class C2 {
        /// some dartdoc
        ^ zoo(z) { } String name; }''');
    await assertTarget('zoo', 'zoo(z) {}');
  }

  test_MethodDeclaration_returnType_afterLineDocComment2() async {
    // SimpleIdentifier  MethodDeclaration  ClassDeclaration  CompilationUnit
    await addTestSource('''
class C2 {
  /// some dartdoc
^ zoo(z) { } String name; }''');
    await assertTarget('zoo', 'zoo(z) {}');
  }

  test_MethodDeclaration_returnType_afterStarComment() async {
    // ClassDeclaration  CompilationUnit
    await addTestSource('class C2 {/* */ ^ zoo(z) { } String name; }');
    await assertTarget('zoo(z) {}', 'class C2 {zoo(z) {} String name;}');
  }

  test_MethodDeclaration_returnType_afterStarComment2() async {
    // ClassDeclaration  CompilationUnit
    await addTestSource('class C2 {/* */^ zoo(z) { } String name; }');
    await assertTarget('zoo(z) {}', 'class C2 {zoo(z) {} String name;}');
  }

  test_MethodDeclaration_returnType_afterStarDocComment() async {
    // MethodDeclaration  ClassDeclaration  CompilationUnit
    await addTestSource('class C2 {/** */ ^ zoo(z) { } String name; }');
    await assertTarget('zoo', 'zoo(z) {}');
  }

  test_MethodDeclaration_returnType_afterStarDocComment2() async {
    // MethodDeclaration  ClassDeclaration  CompilationUnit
    await addTestSource('class C2 {/** */^ zoo(z) { } String name; }');
    await assertTarget('zoo', 'zoo(z) {}');
  }

  test_SwitchStatement_c() async {
    // Token('c') SwitchStatement
    await addTestSource('main() { switch(x) {c^} }');
    await assertTarget('}', 'switch (x) {}', droppedToken: 'c');
  }

  test_SwitchStatement_c2() async {
    // Token('c') SwitchStatement
    await addTestSource('main() { switch(x) { c^ } }');
    await assertTarget('}', 'switch (x) {}', droppedToken: 'c');
  }

  test_SwitchStatement_empty() async {
    // SwitchStatement
    await addTestSource('main() { switch(x) {^} }');
    await assertTarget('}', 'switch (x) {}');
  }

  test_SwitchStatement_empty2() async {
    // SwitchStatement
    await addTestSource('main() { switch(x) { ^ } }');
    await assertTarget('}', 'switch (x) {}');
  }

  test_TypeArgumentList() async {
    // TypeName  TypeArgumentList  TypeName
    await addTestSource('main() { C<^> c; }');
    await assertTarget('', '<>');
  }

  test_TypeArgumentList2() async {
    // TypeName  TypeArgumentList  TypeName
    await addTestSource('main() { C<C^> c; }');
    await assertTarget('C', '<C>');
  }

  test_VariableDeclaration_lhs_identifier_after() async {
    // VariableDeclaration  VariableDeclarationList
    await addTestSource('main() {int b^ = 1;}');
    await assertTarget('b = 1', 'int b = 1');
  }

  test_VariableDeclaration_lhs_identifier_before() async {
    // VariableDeclaration  VariableDeclarationList
    await addTestSource('main() {int ^b = 1;}');
    await assertTarget('b = 1', 'int b = 1');
  }
}