// 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.

// Smoke test of the dart2js compiler API.
library analyze_only;

import "package:expect/expect.dart";
import 'dart:async';
import "package:async_helper/async_helper.dart";

import '../../utils/dummy_compiler_test.dart' as dummy;
import 'package:compiler/compiler.dart';
import 'package:compiler/src/commandline_options.dart';
import 'package:compiler/src/diagnostics/messages.dart' show
    MessageKind, MessageTemplate;

import 'output_collector.dart';

runCompiler(String main, List<String> options,
            onValue(String code, List errors, List warnings)) {
  List errors = new List();
  List warnings = new List();

  Future<String> localProvider(Uri uri) {
    if (uri.scheme != 'main') return dummy.provider(uri);
    return new Future<String>.value(main);
  }

  void localHandler(Uri uri, int begin, int end,
                    String message, Diagnostic kind) {
    dummy.handler(uri, begin, end, message, kind);
    if (kind == Diagnostic.ERROR) {
      errors.add(message);
    } else if (kind == Diagnostic.WARNING) {
      warnings.add(message);
    }
  }

  print('-----------------------------------------------');
  print('main source:\n$main');
  print('options: $options\n');
  asyncStart();
  OutputCollector outputCollector = new OutputCollector();
  Future<CompilationResult> result =
      compile(new Uri(scheme: 'main'),
              new Uri(scheme: 'lib', path: '/'),
              new Uri(scheme: 'package', path: '/'),
              localProvider, localHandler, options, outputCollector);
  result.then((_) {
    onValue(outputCollector.getOutput('', 'js'), errors, warnings);
  }, onError: (e, st) {
    throw 'Compilation failed: ${e} ${st}';
  }).then(asyncSuccess).catchError((error, stack) {
    print('\n\n-----------------------------------------------');
    print('main source:\n$main');
    print('options: $options\n');
    print('threw:\n $error\n$stack');
    print('-----------------------------------------------\n\n');
    throw error;
  });
}

main() {
  runCompiler(
    "",
    [Flags.generateCodeWithCompileTimeErrors],
    (String code, List errors, List warnings) {
      Expect.isNotNull(code);
      Expect.isTrue(errors.isEmpty, 'errors is not empty: $errors');
      MessageTemplate template =
          MessageTemplate.TEMPLATES[MessageKind.MISSING_MAIN];
      Expect.equals(
          "${template.message({'main': 'main'})}",
          warnings.single);
    });

  runCompiler(
    "main() {}",
    [Flags.generateCodeWithCompileTimeErrors],
    (String code, List errors, List warnings) {
      Expect.isNotNull(code);
      Expect.isTrue(errors.isEmpty);
      Expect.isTrue(warnings.isEmpty);
    });

  runCompiler(
    "",
    [Flags.analyzeOnly],
    (String code, List errors, List warnings) {
      Expect.isNull(code);
      Expect.isTrue(errors.isEmpty, 'errors is not empty: $errors');
      MessageTemplate template =
          MessageTemplate.TEMPLATES[MessageKind.CONSIDER_ANALYZE_ALL];
      Expect.equals(
          "${template.message({'main': 'main'})}",
          warnings.single);
    });

  runCompiler(
    "main() {}",
    [Flags.analyzeOnly],
    (String code, List errors, List warnings) {
      Expect.isNull(code);
      Expect.isTrue(errors.isEmpty);
      Expect.isTrue(warnings.isEmpty);
    });

  runCompiler(
    "Foo foo; // Unresolved but not analyzed.",
    [Flags.analyzeOnly],
    (String code, List errors, List warnings) {
      Expect.isNull(code);
      Expect.isTrue(errors.isEmpty, 'errors is not empty: $errors');
      MessageTemplate template =
          MessageTemplate.TEMPLATES[MessageKind.CONSIDER_ANALYZE_ALL];
      Expect.equals(
          "${template.message({'main': 'main'})}",
          warnings.single);
    });

  runCompiler(
    """main() {
         Foo foo; // Unresolved and analyzed.
       }""",
    [Flags.analyzeOnly],
    (String code, List errors, List warnings) {
      Expect.isNull(code);
      Expect.isTrue(errors.isEmpty);
      Expect.equals(1, warnings.length);
      Expect.equals(
          "Cannot resolve type 'Foo'.", warnings[0].toString());
    });

  runCompiler(
    """main() {
         Foo foo; // Unresolved and analyzed.
       }""",
    [Flags.analyzeOnly, Flags.analyzeSignaturesOnly],
    (String code, List errors, List warnings) {
      Expect.isNull(code);
      Expect.isTrue(errors.isEmpty);
      Expect.isTrue(warnings.isEmpty);
    });

  runCompiler(
    "Foo foo; // Unresolved and analyzed.",
    [Flags.analyzeOnly, Flags.analyzeAll],
    (String code, List errors, List warnings) {
      Expect.isNull(code);
      Expect.isTrue(errors.isEmpty);
      Expect.equals(
          "Cannot resolve type 'Foo'.", warnings[0].toString());
    });

  runCompiler(
    """Foo foo; // Unresolved and analyzed.
       main() {}""",
    [Flags.analyzeOnly, Flags.analyzeAll],
    (String code, List errors, List warnings) {
      Expect.isNull(code);
      Expect.isTrue(errors.isEmpty, 'Unexpected errors: $errors.');
      Expect.equals(1, warnings.length, 'Unexpected warning count: $warnings.');
      Expect.equals(
          "Cannot resolve type 'Foo'.", warnings[0].toString());
    });

  runCompiler(
    "",
    [Flags.analyzeOnly, Flags.analyzeAll],
    (String code, List errors, List warnings) {
      Expect.isNull(code);
      Expect.isTrue(errors.isEmpty);
      Expect.isTrue(warnings.isEmpty);
    });

  // --analyze-signatures-only implies --analyze-only
  runCompiler(
    "",
    [Flags.analyzeSignaturesOnly, Flags.analyzeAll],
    (String code, List errors, List warnings) {
      Expect.isNull(code);
      Expect.isTrue(errors.isEmpty);
      Expect.isTrue(warnings.isEmpty);
    });
}