// Copyright (c) 2019, 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:analyzer/dart/ast/ast.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/src/generated/source.dart';
import 'package:nnbd_migration/instrumentation.dart';
import 'package:nnbd_migration/nnbd_migration.dart';

/// The instrumentation information gathered from the migration engine.
class InstrumentationInformation {
  /// The node used for type sources that are always `null`.
  NullabilityNodeInfo always;

  /// A map from elements outside of the code being migrated, to the nullability
  /// nodes associated with the type of the element.
  final Map<Element, DecoratedTypeInfo> externalDecoratedType = {};

  /// A map from the graph edges between nullability nodes, to information about
  /// the edge that was created and why it was created.
  final Map<EdgeInfo, EdgeOriginInfo> edgeOrigin = {};

  /// The node used for type sources that are never `null`.
  NullabilityNodeInfo never;

  /// A list of the steps in the propagation of nullability information through
  /// the nullability graph, to report details of the step that was performed
  /// and why it was performed.
  final List<PropagationInfo> propagationSteps = [];

  /// The instrumentation information that is specific to a single source.
  final Map<Source, SourceInformation> sourceInformation = {};

  /// Initialize a newly created holder of instrumentation information.
  InstrumentationInformation();

  /// Return information about the given [node].
  NodeInformation nodeInfoFor(NullabilityNodeInfo node) {
    for (MapEntry<Source, SourceInformation> sourceEntry
        in sourceInformation.entries) {
      SourceInformation sourceInfo = sourceEntry.value;
      for (MapEntry<AstNode, DecoratedTypeInfo> entry
          in sourceInfo.implicitReturnType.entries) {
        if (entry.value.node == node) {
          return NodeInformation(
              sourceEntry.key.fullName, entry.key, entry.value);
        }
      }
      for (MapEntry<AstNode, DecoratedTypeInfo> entry
          in sourceInfo.implicitType.entries) {
        if (entry.value.node == node) {
          return NodeInformation(
              sourceEntry.key.fullName, entry.key, entry.value);
        }
      }
      for (MapEntry<AstNode, List<DecoratedTypeInfo>> entry
          in sourceInfo.implicitTypeArguments.entries) {
        for (var type in entry.value) {
          if (type.node == node) {
            return NodeInformation(sourceEntry.key.fullName, entry.key, type);
          }
        }
      }
    }
    // The loop below doesn't help because we still don't have access to an AST
    // node.
//    for (MapEntry<Element, DecoratedTypeInfo> entry in externalDecoratedType.entries) {
//      if (entry.value.node == node) {
//        return NodeInformation(null, null, entry.value);
//      }
//    }
    return null;
  }
}

/// The instrumentation information about a [NullabilityNodeInfo].
class NodeInformation {
  final String filePath;

  final AstNode astNode;

  final DecoratedTypeInfo decoratedType;

  NodeInformation(this.filePath, this.astNode, this.decoratedType);
}

/// The instrumentation information gathered from the migration engine that is
/// specific to a single source.
class SourceInformation {
  /// A map from the type annotations found in the source code, to the
  /// nullability nodes that are associated with that type.
  final Map<TypeAnnotation, NullabilityNodeInfo> explicitTypeNullability = {};

  /// A map from the fixes that were decided on to the reasons for the fix.
  final Map<SingleNullabilityFix, List<FixReasonInfo>> fixes = {};

  /// A map from AST nodes that have an implicit return type to the nullability
  /// node associated with the implicit return type of the AST node. The node
  /// can be an
  /// - executable declaration,
  /// - function-typed formal parameter declaration,
  /// - function type alias declaration,
  /// - generic function type, or
  /// - function expression.
  final Map<AstNode, DecoratedTypeInfo> implicitReturnType = {};

  /// A map from AST nodes that have an implicit type to the nullability node
  /// associated with the implicit type of the AST node. The node can be a
  /// - formal parameter,
  /// - declared identifier, or
  /// - variable in a variable declaration list.
  final Map<AstNode, DecoratedTypeInfo> implicitType = {};

  /// Called whenever the migration engine encounters an AST node with implicit
  /// type arguments, to report the nullability nodes associated with the
  /// implicit type arguments of the AST node.
  ///
  /// A map from AST nodes that have implicit type arguments to the nullability
  /// nodes associated with the implicit type arguments of the AST node. The
  /// node can be a
  /// - constructor redirection,
  /// - function expression invocation,
  /// - method invocation,
  /// - instance creation expression,
  /// - list/map/set literal, or
  /// - type annotation.
  final Map<AstNode, List<DecoratedTypeInfo>> implicitTypeArguments = {};

  /// Initialize a newly created holder of instrumentation information that is
  /// specific to a single source.
  SourceInformation();
}