// Copyright (c) 2012, 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:expect/expect.dart";
import 'dart:async';
import "package:async_helper/async_helper.dart";
import 'mock_compiler.dart';
import 'package:compiler/compiler.dart';
import 'package:compiler/implementation/dart2jslib.dart' as leg;
import 'package:compiler/implementation/dart_backend/dart_backend.dart';
import 'package:compiler/implementation/elements/elements.dart';
import 'package:compiler/implementation/tree/tree.dart';

const coreLib = r'''
library corelib;
class Object {
  Object();
}
class bool {}
class num {}
class int extends num {}
class double extends num {}
abstract class String {}
class Function {}
class List<T> {}
class Map<K,V> {}
class BoundClosure {}
class Closure {}
class Dynamic_ {}
class Null {}
class TypeError {}
class Type {}
class StackTrace {}
class LinkedHashMap {
  factory LinkedHashMap._empty() => null;
  factory LinkedHashMap._literal(elements) => null;
}
class Math {
  static double parseDouble(String s) => 1.0;
}
print(x) {}
identical(a, b) => true;
const proxy = 0;
''';

const corePatch = r'''
import 'dart:_js_helper';
import 'dart:_interceptors';
import 'dart:_isolate_helper';
import 'dart:_foreign_helper';
''';

const ioLib = r'''
library io;
class Platform {
  static int operatingSystem;
}
''';

const htmlLib = r'''
library html;
Window __window;
Window get window => __window;
abstract class Window {
  Navigator get navigator;
}
abstract class Navigator {
  String get userAgent;
}
''';

const helperLib = r'''
library js_helper;
class JSInvocationMirror {}
assertHelper(a) {}
class Closure {}
class BoundClosure {}
const patch = 0;
''';

const foreignLib = r'''
var JS;
''';

const isolateHelperLib = r'''
class _WorkerStub {
}
''';

testDart2Dart(String src, {void continuation(String s), bool minify: false,
    bool stripTypes: false}) {
  // If continuation is not provided, check that source string remains the same.
  if (continuation == null) {
    continuation = (s) { Expect.equals(src, s); };
  }
  testDart2DartWithLibrary(src, '', continuation: continuation, minify: minify,
      stripTypes: stripTypes);
}

/**
 * Library name is assumed to be 'mylib' in 'mylib.dart' file.
 */
testDart2DartWithLibrary(
    String srcMain, String srcLibrary,
    {void continuation(String s), bool minify: false,
    bool stripTypes: false}) {
  fileUri(path) => new Uri(scheme: 'file', path: path);

  final scriptUri = fileUri('script.dart');
  final libUri = fileUri('mylib.dart');

  provider(uri) {
    if (uri == scriptUri) return new Future.value(srcMain);
    if (uri.toString() == libUri.toString()) {
      return new Future.value(srcLibrary);
    }
    if (uri.path.endsWith('/core.dart')) {
      return new Future.value(coreLib);
    } else if (uri.path.endsWith('/core_patch.dart')) {
      return new Future.value(corePatch);
    } else if (uri.path.endsWith('/io.dart')) {
      return new Future.value(ioLib);
    } else if (uri.path.endsWith('/js_helper.dart')) {
      return new Future.value(helperLib);
    } else if (uri.path.endsWith('/html_dart2js.dart')) {
      // TODO(smok): The file should change to html_dartium at some point.
      return new Future.value(htmlLib);
    } else if (uri.path.endsWith('/foreign_helper.dart')) {
      return new Future.value(foreignLib);
    } else if (uri.path.endsWith('/isolate_helper.dart')) {
      return new Future.value(isolateHelperLib);
    }
    return new Future.value('');
  }

  handler(uri, begin, end, message, kind) {
    if (identical(kind, Diagnostic.ERROR) || identical(kind, Diagnostic.CRASH)) {
      Expect.fail('$uri: $begin-$end: $message [$kind]');
    }
  }

  final options = <String>['--output-type=dart'];
  // Some tests below are using dart:io.
  options.add('--categories=Client,Server');
  if (minify) options.add('--minify');
  if (stripTypes) options.add('--force-strip=types');

  asyncTest(() => compile(
      scriptUri,
      fileUri('libraryRoot/'),
      fileUri('packageRoot/'),
      provider,
      handler,
      options).then(continuation));
}

testSimpleFileUnparse() {
  final src = '''
should_be_dropped() {
}

should_be_kept() {
}

main() {
  should_be_kept();
}
''';
  testDart2Dart(src, continuation: (String s) {
    print(s);
    Expect.equals('''
should_be_kept() {}
main() {
  should_be_kept();
}
''', s);
  });
}
testTopLevelField() {
  testDart2Dart('''
final String x = "asd";
main() {
  x;
}
''');
}

testSimpleTopLevelClass() {
  testDart2Dart('''
main() {
  new A();
}
class A {
  A() {}
}
''');
}

testClassWithSynthesizedConstructor() {
  testDart2Dart('''
main() {
  new A();
}
class A {}
''');
}

testClassWithMethod() {
  testDart2Dart(r'''
main() {
  var a = new A();
  a.foo();
}
class A {
  void foo() {}
}
''');
}

testExtendsImplements() {
  testDart2Dart('''
main() {
  new B<Object>();
}
class A<T> {}
class B<T> extends A<T> {}
''');
}

testVariableDefinitions() {
  testDart2Dart('''
main() {
  var x, y;
  final String s = null;
}
''');
  testDart2Dart('''
main() {
  final int x = 0, y = 0;
  final String s = null;
}
''');
  testDart2Dart('''
foo(f, g) {}
main() {
  foo(1, 2);
}
''');
  testDart2Dart('''
foo(f(arg)) {}
main() {
  foo(main);
}
''');
  // A couple of static/finals inside a class.
  testDart2Dart('''
main() {
  A.a;
  A.b;
}
class A {
  static const String a = "5";
  static const String b = "4";
}
''');
  // Class member of typedef-ed function type.
  // Maybe typedef should be included in the result too, but it
  // works fine without it.
  testDart2Dart('''
typedef void foofunc(arg);
main() {
  new A((arg) {});
}
class A {
  A(foofunc this.handler);
  final foofunc handler;
}
''');
}

testGetSet() {
  // Top-level get/set.
  testDart2Dart('''
set foo(arg) {}
get foo {
  return 5;
}
main() {
  foo;
  foo = 5;
}
''');
  // Field get/set.
  testDart2Dart('''
main() {
  var a = new A();
  a.foo;
  a.foo = 5;
}
class A {
  set foo(a) {}
  get foo {
    return 5;
  }
}
''');
  // Typed get/set.
  testDart2Dart('''
String get foo {
  return "a";
}
main() {
  foo;
}
''');
}

testAbstractClass() {
  testDart2Dart('''
main() {
  A.foo;
}
abstract class A {
  static final num foo = 0;
}
''');
}

testConflictSendsRename() {
  // Various Send-s to current library and external library. Verify that
  // everything is renamed correctly in conflicting class names and global
  // functions.
  var librarySrc = '''
library mylib;

globalfoo() {}
var globalVar;
var globalVarInitialized = 6, globalVarInitialized2 = 7;

class A {
  A(){}
  A.fromFoo(){}
  static staticfoo(){}
  foo(){}
  static const field = 5;
}
''';
  var mainSrc = '''
import 'mylib.dart' as mylib;

globalfoo() {}
var globalVar;
var globalVarInitialized = 6, globalVarInitialized2 = 7;

class A {
  A(){}
  A.fromFoo(){}
  static staticfoo(){}
  foo(){}
  static const field = 5;
}

main() {
  globalVar;
  globalVarInitialized;
  globalVarInitialized2;
  globalfoo();
  A.field;
  A.staticfoo();
  new A();
  new A.fromFoo();
  new A().foo();

  mylib.globalVar;
  mylib.globalVarInitialized;
  mylib.globalVarInitialized2;
  mylib.globalfoo();
  mylib.A.field;
  mylib.A.staticfoo();
  new mylib.A();
  new mylib.A.fromFoo();
  new mylib.A().foo();
}
''';
  var expectedResult = '''
globalfoo() {}
var globalVar;
var globalVarInitialized = 6;
var globalVarInitialized2 = 7;
class A {
  A() {}
  A.fromFoo() {}
  static staticfoo() {}
  foo() {}
  static const field = 5;
}
A_globalfoo() {}
var A_globalVar;
var A_globalVarInitialized = 6;
var A_globalVarInitialized2 = 7;
class A_A {
  A_A() {}
  A_A.A_fromFoo() {}
  static A_staticfoo() {}
  foo() {}
  static const A_field = 5;
}
main() {
  A_globalVar;
  A_globalVarInitialized;
  A_globalVarInitialized2;
  A_globalfoo();
  A_A.A_field;
  A_A.A_staticfoo();
  new A_A();
  new A_A.A_fromFoo();
  new A_A().foo();
  globalVar;
  globalVarInitialized;
  globalVarInitialized2;
  globalfoo();
  A.field;
  A.staticfoo();
  new A();
  new A.fromFoo();
  new A().foo();
}
''';
  testDart2DartWithLibrary(mainSrc, librarySrc,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

testNoConflictSendsRename() {
  // Various Send-s to current library and external library. Nothing should be
  // renamed here, only library prefixes must be cut.
  var librarySrc = '''
library mylib;

globalfoo() {}

class A {
  A(){}
  A.fromFoo(){}
  static staticfoo(){}
  foo(){}
  static const field = 5;
}
''';
  var mainSrc = '''
import 'mylib.dart' as mylib;

myglobalfoo() {}

class MyA {
  MyA(){}
  MyA.myfromFoo(){}
  static mystaticfoo(){}
  myfoo(){}
  static const myfield = 5;
}

main() {
  myglobalfoo();
  MyA.myfield;
  MyA.mystaticfoo();
  new MyA();
  new MyA.myfromFoo();
  new MyA().myfoo();

  mylib.globalfoo();
  mylib.A.field;
  mylib.A.staticfoo();
  new mylib.A();
  new mylib.A.fromFoo();
  new mylib.A().foo();
}
''';
  var expectedResult = '''
globalfoo() {}
class A {
  A() {}
  A.fromFoo() {}
  static staticfoo() {}
  foo() {}
  static const field = 5;
}
myglobalfoo() {}
class MyA {
  MyA() {}
  MyA.myfromFoo() {}
  static mystaticfoo() {}
  myfoo() {}
  static const myfield = 5;
}
main() {
  myglobalfoo();
  MyA.myfield;
  MyA.mystaticfoo();
  new MyA();
  new MyA.myfromFoo();
  new MyA().myfoo();
  globalfoo();
  A.field;
  A.staticfoo();
  new A();
  new A.fromFoo();
  new A().foo();
}
''';
  testDart2DartWithLibrary(mainSrc, librarySrc,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

testConflictLibraryClassRename() {
  var librarySrc = '''
library mylib;

topfoo() {}

class A {
  foo() {}
}
''';
  var mainSrc = '''
import 'mylib.dart' as mylib;
topfoo() {
  var x = 5;
}
class A {
  num foo() {}
  A.fromFoo() {}
  mylib.A myliba;
  List<A> mylist;
}
mylib.A getA() => null;
main() {
  var a = new mylib.A();
  a.foo();
  var b = new A.fromFoo();
  b.foo();
  var GREATVAR = b.myliba;
  b.mylist;
  a = getA();
  topfoo();
  mylib.topfoo();
}
''';
  var expectedResult = '''
topfoo() {}
class A {
  foo() {}
}
A_topfoo() {
  var x = 5;
}
class A_A {
  num foo() {}
  A_A.fromFoo() {}
  A myliba;
  List<A_A> mylist;
}
A getA() => null;
main() {
  var a = new A();
  a.foo();
  var b = new A_A.fromFoo();
  b.foo();
  var GREATVAR = b.myliba;
  b.mylist;
  a = getA();
  A_topfoo();
  topfoo();
}
''';
  testDart2DartWithLibrary(mainSrc, librarySrc,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

testClassExtendsWithArgs() {
  testDart2Dart('''
main() {
  new B<Object>();
}
class A<T extends Object> {}
class B<T extends Object> extends A<T> {}
''');
}

testStaticInvocation() {
  testDart2Dart('''
main() {
  var x = Math.parseDouble("1");
}
''');
}

testLibraryGetSet() {
  var librarySrc = '''
library mylib;

get topgetset => 5;
set topgetset(arg) {}
''';
  var mainSrc = '''
import 'mylib.dart' as mylib;

get topgetset => 6;
set topgetset(arg) {}

main() {
  topgetset;
  topgetset = 6;

  mylib.topgetset;
  mylib.topgetset = 5;
}
''';
  var expectedResult = '''
get topgetset => 5;
set topgetset(arg) {}
get A_topgetset => 6;
set A_topgetset(arg) {}
main() {
  A_topgetset;
  A_topgetset = 6;
  topgetset;
  topgetset = 5;
}
''';
  testDart2DartWithLibrary(mainSrc, librarySrc,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

testFieldTypeOutput() {
  testDart2Dart('''
main() {
  new A().field;
}
class B {}
class A {
  B field;
}
''');
}

class DynoMap implements Map<Element, ElementAst> {
  final compiler;
  DynoMap(this.compiler);

  ElementAst operator[](Element element) => new ElementAst(element);

  noSuchMethod(Invocation invocation) => throw 'unimplemented method';
}

PlaceholderCollector collectPlaceholders(compiler, element) =>
  new PlaceholderCollector(compiler, new Set<String>(), new DynoMap(compiler))
      ..collect(element);

testLocalFunctionPlaceholder() {
  var src = '''
main() {
  function localfoo() {}
  localfoo();
}
''';
  MockCompiler compiler = new MockCompiler.internal(emitJavaScript: false);
  asyncTest(() => compiler.init().then((_) {
    assert(compiler.backend is DartBackend);
    compiler.parseScript(src);
    FunctionElement mainElement = compiler.mainApp.find(leg.Compiler.MAIN);
    compiler.processQueue(compiler.enqueuer.resolution, mainElement);
    PlaceholderCollector collector = collectPlaceholders(compiler, mainElement);
    FunctionExpression mainNode = mainElement.node;
    Block body = mainNode.body;
    FunctionDeclaration functionDeclaration = body.statements.nodes.head;
    FunctionExpression fooNode = functionDeclaration.function;
    LocalPlaceholder fooPlaceholder =
        collector.functionScopes[mainElement].localPlaceholders.first;
    Expect.isTrue(fooPlaceholder.nodes.contains(fooNode.name));
  }));
}

testTypeVariablesAreRenamed() {
  // Somewhat a hack: we require all the references of the identifier
  // to be renamed in the same way for the whole library. Hence
  // if we have a class and type variable with the same name, they
  // both should be renamed.
  var librarySrc = '''
library mylib;
typedef void MyFunction<T extends num>(T arg);
class T {}
class B<T> {}
class A<T> extends B<T> { T f; }
''';
  var mainSrc = '''
import 'mylib.dart' as mylib;
typedef void MyFunction<T extends num>(T arg);
class T {}
class B<T> {}
class A<T> extends B<T> { T f; }

main() {
  MyFunction myf1;
  mylib.MyFunction myf2;
  new A<int>().f;
  new T();

  new mylib.A<int>().f;
  new mylib.T();
}
''';
  var expectedResult = '''
typedef void MyFunction<T extends num>(T arg);
class T {}
class B<T> {}
class A<T> extends B<T> {
  T f;
}
typedef void A_MyFunction<A_T extends num>(A_T arg);
class A_T {}
class A_B<A_T> {}
class A_A<A_T> extends A_B<A_T> {
  A_T f;
}
main() {
  A_MyFunction myf1;
  MyFunction myf2;
  new A_A<int>().f;
  new A_T();
  new A<int>().f;
  new T();
}
''';
  testDart2DartWithLibrary(mainSrc, librarySrc,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

testClassTypeArgumentBound() {
  var librarySrc = '''
library mylib;

class I {}
class A<T extends I> {}

''';
  var mainSrc = '''
import 'mylib.dart' as mylib;

class I {}
class A<T extends I> {}

main() {
  new A();
  new mylib.A();
}
''';
  var expectedResult = '''
class I {}
class A<T extends I> {}
class A_I {}
class A_A<A_T extends A_I> {}
main() {
  new A_A();
  new A();
}
''';
  testDart2DartWithLibrary(mainSrc, librarySrc,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

testDoubleMains() {
  var librarySrc = '''
library mylib;
main() {}
''';
  var mainSrc = '''
import 'mylib.dart' as mylib;
main() {
  mylib.main();
}
''';
  var expectedResult = '''
A_main() {}
main() {
  A_main();
}
''';
  testDart2DartWithLibrary(mainSrc, librarySrc,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

testStaticAccessIoLib() {
  var src = '''
import 'dart:io';

main() {
  Platform.operatingSystem;
}
''';
  var expectedResult = '''
import "dart:io" as p;
main() {
  p.Platform.operatingSystem;
}
''';
  testDart2Dart(src,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

testMinification() {
  var src = '''
class ClassWithVeryVeryLongName {}
main() {
  new ClassWithVeryVeryLongName();
}
''';
  var expectedResult =
      'class A{}'
      'main(){new A();}';
  testDart2Dart(src, continuation:
      (String result) { Expect.equals(expectedResult, result); }, minify: true);
}

testClosureLocalsMinified() {
  var src = '''
main() {
  var a = 7;
  void foo1(a,b) {
    void foo2(c,d) {
       var E = a;
    }
    foo2(b, a);
  }
  foo1(a, 8);
}
''';
  var expectedResult =
      'main(){var A=7; B(A,C){ D(E,F){var G=A;}D(C,A);}B(A,8);}';
  testDart2Dart(src, continuation:
      (String result) { Expect.equals(expectedResult, result); }, minify: true);
}

testParametersMinified() {
  var src = '''
class A {
  var a;
  static foo(arg1) {
    // Should not rename arg1 to a.
    arg1 = 5;
  }
}

fooglobal(arg,{optionalarg: 7}) {
  arg = 6;
}

main() {
  new A().a;
  A.foo(8);
  fooglobal(8);
}
''';
  var expectedResult =
      'class B{var E;static C(A){A=5;}}D(A,{optionalarg: 7}){A=6;}'
      'main(){new B().E;B.C(8);D(8);}';
  testDart2Dart(src, continuation:
      (String result) { Expect.equals(expectedResult, result); }, minify: true);
}

testDeclarationTypePlaceholders() {
  var src = '''
String globalfield;
const String globalconstfield;

void foo(String arg) {}

main() {
  String localvar;
  foo("5");
}
''';
  var expectedResult = '''
foo( arg) {}
main() {
  var localvar;
  foo("5");
}
''';
  testDart2Dart(src,
      continuation: (String result) { Expect.equals(expectedResult, result); },
      stripTypes: true);
}

testPlatformLibraryMemberNamesAreFixed() {
  var src = '''
import 'dart:html';

class A {
  static String get userAgent => window.navigator.userAgent;
}

main() {
  A.userAgent;
}
''';
  var expectedResult = '''
import "dart:html" as p;
class A {
  static String get A_userAgent => p.window.navigator.userAgent;
}
main() {
  A.A_userAgent;
}
''';
  testDart2Dart(src,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

testConflictsWithCoreLib() {
  var src = '''
import 'dart:core' as fisk;

print(x) { throw 'fisk'; }

main() {
  fisk.print('corelib');
  print('local');
}
''';
  var expectedResult = """
A_print(x) {
  throw 'fisk';
}
main() {
  print('corelib');
  A_print('local');
}
""";
  testDart2Dart(src,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

testUnresolvedNamedConstructor() {
  var src = '''
class A {
  A() {}
}

main() {
  new A();
  new A.named();
}
''';
  var expectedResult = """
class A {
  A() {}
}
main() {
  new A();
  new A_Unresolved();
}
""";
  testDart2Dart(src,
      continuation: (String result) { Expect.equals(expectedResult, result); });
}

main() {
  testSimpleFileUnparse();
  testTopLevelField();
  testSimpleTopLevelClass();
  testClassWithSynthesizedConstructor();
  testClassWithMethod();
  testExtendsImplements();
  testVariableDefinitions();
  testGetSet();
  testAbstractClass();
  testConflictSendsRename();
  testNoConflictSendsRename();
  testConflictLibraryClassRename();
  testClassExtendsWithArgs();
  testStaticInvocation();
  testLibraryGetSet();
  testFieldTypeOutput();
  testTypeVariablesAreRenamed();
  testClassTypeArgumentBound();
  testDoubleMains();
  testStaticAccessIoLib();
  testLocalFunctionPlaceholder();
  testMinification();
  testClosureLocalsMinified();
  testParametersMinified();
  testDeclarationTypePlaceholders();
  testPlatformLibraryMemberNamesAreFixed();
  testConflictsWithCoreLib();
  testUnresolvedNamedConstructor();
}