// Copyright (c) 2015, 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 'package:analysis_server/src/provisional/completion/dart/completion_dart.dart';
import 'package:analysis_server/src/services/completion/dart/completion_manager.dart';
import 'package:analysis_server/src/services/completion/dart/library_member_contributor.dart';
import 'package:analysis_server/src/services/completion/dart/suggestion_builder.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';

import 'completion_contributor_util.dart';

void main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(LibraryMemberContributorTest);
  });
}

@reflectiveTest
class LibraryMemberContributorTest extends DartCompletionContributorTest {
  @override
  DartCompletionContributor createContributor(
    DartCompletionRequest request,
    SuggestionBuilder builder,
  ) {
    return LibraryMemberContributor(request, builder);
  }

  Future<void> test_extension() async {
    // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
    addSource('$testPackageLibPath/b.dart', '''
extension MyExt on int {}
''');
    addTestSource('''
import "b.dart" as b;
void f() {b.^}
''');
    await computeSuggestions();
    assertSuggest('MyExt');
  }

  Future<void> test_libraryPrefix() async {
    // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
    addTestSource('''
import "dart:async" as bar;
foo() {bar.^}
''');
    await computeSuggestions();
    assertSuggestClass('Future');
    assertNotSuggested('loadLibrary');
  }

  Future<void> test_libraryPrefix2() async {
    // SimpleIdentifier  MethodInvocation  ExpressionStatement
    addTestSource('''
import "dart:async" as bar;
foo() {
  bar.^
  print("f");
}
''');
    await computeSuggestions();
    assertSuggestClass('Future');
  }

  Future<void> test_libraryPrefix3() async {
    // SimpleIdentifier  MethodInvocation  ExpressionStatement
    addTestSource('''
import "dart:async" as bar;
foo() {
  new bar.F^
  print("f");
}
''');
    await computeSuggestions();
    assertSuggestConstructor('Future');
    assertSuggestConstructor('Future.delayed');
  }

  Future<void> test_libraryPrefix_cascade() async {
    addTestSource('''
import "dart:math" as math;
void f() {
  math..^
}
''');
    await computeSuggestions();
    assertNoSuggestions();
  }

  Future<void> test_libraryPrefix_cascade2() async {
    addTestSource('''
import "dart:math" as math;
void f() {
  math.^.
}
''');
    await computeSuggestions();
    assertSuggestFunction('min', 'T');
  }

  Future<void> test_libraryPrefix_cascade3() async {
    addTestSource('''
import "dart:math" as math;
void f() {
  math..^a
}
''');
    await computeSuggestions();
    assertNoSuggestions();
  }

  Future<void> test_libraryPrefix_cascade4() async {
    addTestSource('''
import "dart:math" as math;
void f() {
  math.^.a
}
''');
    await computeSuggestions();
    assertSuggestFunction('min', 'T');
  }

  Future<void> test_libraryPrefix_deferred() async {
    // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
    addTestSource('import "dart:async" deferred as bar; foo() {bar.^}');
    await computeSuggestions();
    assertSuggestClass('Future');
    assertSuggestFunction('loadLibrary', 'Future<dynamic>');
  }

  Future<void> test_libraryPrefix_deferred_inPart() async {
    // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
    newFile('$testPackageLibPath/a.dart', '''
library testA;
import "dart:async" deferred as bar;
part "test.dart";
''');
    addTestSource('part of testA; foo() {bar.^}');
    await resolveFile('$testPackageLibPath/a.dart');
    // Assume that libraries containing has been computed for part files
    await computeSuggestions();
    assertSuggestClass('Future');
    assertSuggestFunction('loadLibrary', 'Future<dynamic>');
    assertNotSuggested('foo');
  }

  Future<void> test_libraryPrefix_with_exports() async {
    newFile('$testPackageLibPath/a.dart', 'library libA; class A { }');
    newFile('$testPackageLibPath/b.dart', '''
        library libB;
        export "a.dart";
        class B { }
        @deprecated class B1 { }''');
    addTestSource('''
import "b.dart" as foo;
void f() {foo.^}
class C { }
''');
    await computeSuggestions();
    assertSuggestClass('B');
    assertSuggestClass('B1', isDeprecated: true);
    assertSuggestClass('A');
    assertNotSuggested('C');
  }

  Future<void> test_PrefixedIdentifier_library() async {
    // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
    addSource('$testPackageLibPath/b.dart', '''
lib B;
var T1;
class X { }
class Y { }
''');
    addTestSource('''
import "b.dart" as b;
var T2;
class A { }
void f() {b.^}
''');
    await computeSuggestions();
    expect(replacementOffset, completionOffset);
    expect(replacementLength, 0);
    assertSuggestClass('X');
    assertSuggestClass('Y');
    assertSuggestTopLevelVar('T1', null);
    assertNotSuggested('T2');
    assertNotSuggested('Object');
    assertNotSuggested('b');
    assertNotSuggested('A');
    assertNotSuggested('==');
  }

  Future<void> test_PrefixedIdentifier_library_export_withShow() async {
    addSource('$testPackageLibPath/a.dart', r'''
class A {}
class B {}
''');
    addSource('$testPackageLibPath/b.dart', r'''
export 'a.dart' show A;
''');
    addTestSource(r'''
import 'b.dart' as p;
void f() {
  p.^
}
''');
    await computeSuggestions();
    assertSuggestClass('A');
    assertNotSuggested('B');
  }

  Future<void> test_PrefixedIdentifier_library_import_withShow() async {
    addSource('$testPackageLibPath/a.dart', r'''
class A {}
class B {}
''');
    addTestSource(r'''
import 'a.dart' as p show A;
void f() {
  p.^
}
''');
    await computeSuggestions();
    assertSuggestClass('A');
    assertNotSuggested('B');
  }

  Future<void> test_PrefixedIdentifier_library_inPart() async {
    // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
    newFile('$testPackageLibPath/b.dart', '''
        lib B;
        var T1;
        class X { }
        class Y { }''');
    newFile('$testPackageLibPath/a.dart', '''
library testA;
import "b.dart" as b;
part "test.dart";
var T2;
class A { }
''');
    addTestSource('''
part of testA;
void f() {b.^}
''');
    await resolveFile('$testPackageLibPath/a.dart');
    // Assume that libraries containing has been computed for part files
    await computeSuggestions();
    expect(replacementOffset, completionOffset);
    expect(replacementLength, 0);
    assertSuggestClass('X');
    assertSuggestClass('Y');
    assertSuggestTopLevelVar('T1', null);
    assertNotSuggested('T2');
    assertNotSuggested('Object');
    assertNotSuggested('b');
    assertNotSuggested('A');
    assertNotSuggested('==');
  }

  Future<void> test_PrefixedIdentifier_library_typesOnly() async {
    // SimpleIdentifier  PrefixedIdentifier  NamedType
    newFile('$testPackageLibPath/b.dart', '''
lib B;
var T1;
class X { }
class Y { }
typedef void TypeAliasLegacy();
typedef TypeAliasFunctionType = void Function();
typedef TypeAliasInterfaceType = List<int>;
''');
    addTestSource('''
import "b.dart" as b;
var T2;
class A { }
foo(b.^ f) {}
''');
    await computeSuggestions();
    expect(replacementOffset, completionOffset);
    expect(replacementLength, 0);
    assertSuggestClass('X');
    assertSuggestClass('Y');
    assertSuggestTypeAlias('TypeAliasLegacy',
        aliasedType: 'void Function()', returnType: 'void');
    assertSuggestTypeAlias('TypeAliasFunctionType',
        aliasedType: 'void Function()', returnType: 'void');
    assertSuggestTypeAlias('TypeAliasInterfaceType', aliasedType: 'List<int>');
    assertNotSuggested('T1');
    assertNotSuggested('T2');
    assertNotSuggested('Object');
    assertNotSuggested('b');
    assertNotSuggested('A');
    assertNotSuggested('==');
  }

  Future<void> test_PrefixedIdentifier_library_typesOnly2() async {
    // SimpleIdentifier  PrefixedIdentifier  NamedType
    newFile('$testPackageLibPath/b.dart', '''
lib B;
var T1;
class X { }
class Y { }
''');
    addTestSource('''
import "b.dart" as b;
var T2;
class A { }
foo(b.^) {}
''');
    await computeSuggestions();
    expect(replacementOffset, completionOffset);
    expect(replacementLength, 0);
    assertSuggestClass('X');
    assertSuggestClass('Y');
    assertNotSuggested('T1');
    assertNotSuggested('T2');
    assertNotSuggested('Object');
    assertNotSuggested('b');
    assertNotSuggested('A');
    assertNotSuggested('==');
  }

  Future<void> test_PrefixedIdentifier_parameter() async {
    // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
    newFile('$testPackageLibPath/b.dart', '''
lib B;
class _W {M y; var _z;}
class X extends _W {}
class M{}
''');
    addTestSource('''
import "b.dart";
foo(X x) {x.^}
''');
    await computeSuggestions();
    assertNoSuggestions();
  }

  Future<void> test_PrefixedIdentifier_prefix() async {
    // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
    newFile('$testPackageLibPath/a.dart', '''
class A {static int bar = 10;}
_B() {}
''');
    addTestSource('''
import "a.dart";
class X {foo(){A^.bar}}
''');
    await computeSuggestions();
    assertNoSuggestions();
  }
}