// Copyright (c) 2013, 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.

library mirror_system_helper;

import 'dart:async';
import 'package:compiler/implementation/mirrors/source_mirrors.dart';
import 'package:compiler/implementation/mirrors/dart2js_mirrors.dart';
import 'mock_compiler.dart';

export 'package:compiler/implementation/mirrors/source_mirrors.dart';
export 'package:compiler/implementation/mirrors/mirrors_util.dart';

const String SOURCE = 'source';
final Uri SOURCE_URI = new Uri(scheme: SOURCE, path: SOURCE);

// TODO(johnniwinther): Move this to a mirrors helper library.
Future<MirrorSystem> createMirrorSystem(String source) {
  MockCompiler compiler = new MockCompiler.internal(
      analyzeOnly: true,
      analyzeAll: true,
      preserveComments: true);
    compiler.registerSource(SOURCE_URI, source);
    compiler.librariesToAnalyzeWhenRun = <Uri>[SOURCE_URI];
  return compiler.runCompiler(null).then((_) {
    return new Dart2JsMirrorSystem(compiler);
  });
}

/**
 * Returns [:true:] if [type] is an instance of [:decl:] with type arguments
 * equal to [typeArgument].
 */
bool isInstance(ClassMirror decl, List<TypeMirror> typeArguments,
            ClassMirror type) {
  if (type.isOriginalDeclaration) return false;
  if (!isSameDeclaration(decl, type)) return false;
  return areEqualsTypes(typeArguments, type.typeArguments);
}

/**
 * Returns [:true:] if [type] is the same type as [expected]. This method
 * equates a non-generic declaration with its instantiation.
 */
bool isEqualType(TypeMirror expected, TypeMirror type) {
  if (expected == type) return true;
  if (expected is ClassMirror && type is ClassMirror) {
    if (!isSameDeclaration(expected, type)) return false;
    if (expected.isOriginalDeclaration || expected.typeArguments.isEmpty) {
      return type.isOriginalDeclaration || type.typeArguments.isEmpty;
    }
    return areEqualsTypes(expected.typeArguments, type.typeArguments);
  }
  return true;
}

/**
 * Returns [:true:] if [types] are equals to [expected] using the equalitry
 * defined by [isEqualType].
 */
bool areEqualsTypes(List<TypeMirror> expected, List<TypeMirror> types) {
  return checkSameList(expected, types, isEqualType);
}

/**
 * Returns [:true:] if an instance of [type] with type arguments equal to
 * [typeArguments] is found in [types].
 */
bool containsType(ClassMirror decl, List<TypeMirror> typeArguments,
                  Iterable<TypeMirror> types) {
  return types.any((type) => isInstance(decl, typeArguments, type));
}

/**
 * Returns the declaration of [type].
 */
TypeMirror toDeclaration(TypeMirror type) {
  return type is ClassMirror ? type.originalDeclaration : type;
}

/**
 * Returns [:true:] if [type] is of the same declaration as [expected].
 */
bool isSameDeclaration(TypeMirror expected, TypeMirror type) {
  return toDeclaration(expected) == toDeclaration(type);
}

/**
 * Returns [:true:] if a type of the declaration of [expected] is in [types].
 */
bool containsDeclaration(TypeMirror expected, Iterable<TypeMirror> types) {
  for (var type in types) {
    if (isSameDeclaration(expected, type)) {
      return true;
    }
  }
  return false;
}

/**
 * Returns [:true:] if declarations of [expected] are the same as those of
 * [types], taking order into account.
 */
bool isSameDeclarationList(Iterable<TypeMirror> expected,
                           Iterable<TypeMirror> types) {
  return checkSameList(expected, types, isSameDeclaration);
}

/**
 * Returns [:true:] if declarations of [expected] are the same as those of
 * [iterable], not taking order into account.
 */
bool isSameDeclarationSet(Iterable<TypeMirror> expected,
                          Iterable<TypeMirror> types) {
   Set<TypeMirror> expectedSet = expected.map(toDeclaration).toSet();
   Set<TypeMirror> typesSet = types.map(toDeclaration).toSet();
   return expectedSet.length == typesSet.length &&
          expectedSet.containsAll(typesSet);
}

/**
 * Utility method for checking whether [expected] and [iterable] contains the
 * same elements with respect to the checking function [check], takin order
 * into account.
 */
bool checkSameList(Iterable<TypeMirror> expected,
                   Iterable<TypeMirror> types,
                   bool check(TypeMirror a, TypeMirror b)) {
  if (expected.length != types.length) return false;
  Iterator<TypeMirror> expectedIterator = expected.iterator;
  Iterator<TypeMirror> typesIterator = types.iterator;
  while (expectedIterator.moveNext() && typesIterator.moveNext()) {
    if (!check(expectedIterator.current, typesIterator.current)) {
      return false;
    }
  }
  return true;
}