// Copyright (c) 2014, 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 services.status;

import 'package:analysis_services/search/search_engine.dart';
import 'package:analysis_services/src/correction/source_range.dart';
import 'package:analyzer/src/generated/ast.dart';
import 'package:analyzer/src/generated/element.dart';
import 'package:analyzer/src/generated/engine.dart';
import 'package:analyzer/src/generated/java_core.dart';
import 'package:analyzer/src/generated/source.dart';


/**
 * An outcome of a condition checking operation.
 */
class RefactoringStatus {
  /**
   * The current severity of this [RefactoringStatus] - the maximum of the
   * severities of its [entries].
   */
  RefactoringStatusSeverity _severity = RefactoringStatusSeverity.OK;

  /**
   * A list of [RefactoringStatusEntry]s.
   */
  final List<RefactoringStatusEntry> entries = [];

  /**
   * Creates a new OK [RefactoringStatus].
   */
  RefactoringStatus();

  /**
   * Creates a new [RefactoringStatus] with the ERROR severity.
   */
  factory RefactoringStatus.error(String msg,
      [RefactoringStatusContext context]) {
    RefactoringStatus status = new RefactoringStatus();
    status.addError(msg, context);
    return status;
  }

  /**
   * Creates a new [RefactoringStatus] with the FATAL severity.
   */
  factory RefactoringStatus.fatal(String msg,
      [RefactoringStatusContext context]) {
    RefactoringStatus status = new RefactoringStatus();
    status.addFatalError(msg, context);
    return status;
  }

  /**
   * Creates a new [RefactoringStatus] with the WARNING severity.
   */
  factory RefactoringStatus.warning(String msg,
      [RefactoringStatusContext context]) {
    RefactoringStatus status = new RefactoringStatus();
    status.addWarning(msg, context);
    return status;
  }

  /**
   * Returns the first [RefactoringStatusEntry] with the highest severity.
   *
   * If there is more than one entry with the highest severity then there is no
   * guarantee as to which will be returned.
   *
   * Returns `null` if no entries.
   */
  RefactoringStatusEntry get entryWithHighestSeverity {
    for (RefactoringStatusEntry entry in entries) {
      if (entry.severity == _severity) {
        return entry;
      }
    }
    return null;
  }

  /**
   * Returns `true` if the severity is FATAL or ERROR.
   */
  bool get hasError =>
      _severity == RefactoringStatusSeverity.FATAL ||
          _severity == RefactoringStatusSeverity.ERROR;

  /**
   * Returns `true` if the severity is FATAL.
   */
  bool get hasFatalError => _severity == RefactoringStatusSeverity.FATAL;

  /**
   * Returns `true` if the severity is WARNING.
   */
  bool get hasWarning => _severity == RefactoringStatusSeverity.WARNING;

  /**
   * Return `true` if the severity is `OK`.
   */
  bool get isOK => _severity == RefactoringStatusSeverity.OK;

  /**
   * Returns the message of the [RefactoringStatusEntry] with highest severity;
   * may be `null` if no entries.
   */
  String get message {
    RefactoringStatusEntry entry = entryWithHighestSeverity;
    if (entry == null) {
      return null;
    }
    return entry.message;
  }

  /**
   * Returns the current severity of this [RefactoringStatus].
   */
  RefactoringStatusSeverity get severity => _severity;

  /**
   * Adds an ERROR entry with the given message and status.
   */
  void addError(String msg, [RefactoringStatusContext context]) {
    _addEntry(
        new RefactoringStatusEntry(RefactoringStatusSeverity.ERROR, msg, context));
  }

  /**
   * Adds a FATAL entry with the given message and status.
   */
  void addFatalError(String msg, [RefactoringStatusContext context]) {
    _addEntry(
        new RefactoringStatusEntry(RefactoringStatusSeverity.FATAL, msg, context));
  }

  /**
   * Merges [other] into this [RefactoringStatus].
   *
   * The [other]'s entries are added to this.
   *
   * The resulting severity is the more severe of this and [other] severities.
   *
   * Merging with `null` is allowed - it has no effect.
   */
  void addStatus(RefactoringStatus other) {
    if (other == null) {
      return;
    }
    entries.addAll(other.entries);
    _severity = RefactoringStatusSeverity._max(_severity, other.severity);
  }

  /**
   * Adds a WARNING entry with the given message and status.
   */
  void addWarning(String msg, [RefactoringStatusContext context]) {
    _addEntry(
        new RefactoringStatusEntry(RefactoringStatusSeverity.WARNING, msg, context));
  }

  /**
   * Returns a copy of this [RefactoringStatus] with ERROR replaced with FATAL.
   */
  RefactoringStatus escalateErrorToFatal() {
    RefactoringStatus result = new RefactoringStatus();
    for (RefactoringStatusEntry entry in entries) {
      if (entry.severity == RefactoringStatusSeverity.ERROR) {
        entry = new RefactoringStatusEntry(
            RefactoringStatusSeverity.FATAL,
            entry.message,
            entry.context);
      }
      result._addEntry(entry);
    }
    return result;
  }

  @override
  String toString() {
    StringBuffer sb = new StringBuffer();
    sb.write("<");
    sb.write(_severity.name);
    if (!isOK) {
      sb.write("\n");
      for (RefactoringStatusEntry entry in entries) {
        sb.write("\t");
        sb.write(entry);
        sb.write("\n");
      }
    }
    sb.write(">");
    return sb.toString();
  }

  /**
   * Adds the given [RefactoringStatusEntry] and updates [severity].
   */
  void _addEntry(RefactoringStatusEntry entry) {
    entries.add(entry);
    _severity = RefactoringStatusSeverity._max(_severity, entry.severity);
  }
}


/**
 * [RefactoringStatusContext] can be used to annotate [RefactoringStatusEntry]s
 * with additional information typically presented in the user interface.
 */
class RefactoringStatusContext {
  /**
   * The [AnalysisContext] in which this status occurs.
   */
  final AnalysisContext context;

  /**
   * The [Source] in which this status occurs.
   */
  final Source source;

  /**
   * The [SourceRange] with specific location where this status occurs.
   */
  final SourceRange range;

  /**
   * Creates a new [RefactoringStatusContext].
   */
  RefactoringStatusContext(this.context, this.source, this.range);

  /**
   * Creates a new [RefactoringStatusContext] for the given [Element].
   */
  factory RefactoringStatusContext.forElement(Element element) {
    AnalysisContext context = element.context;
    Source source = element.source;
    SourceRange range = rangeElementName(element);
    return new RefactoringStatusContext(context, source, range);
  }

  /**
   * Creates a new [RefactoringStatusContext] for the given [SearchMatch].
   */
  factory RefactoringStatusContext.forMatch(SearchMatch match) {
    Element enclosingElement = match.element;
    return new RefactoringStatusContext(
        enclosingElement.context,
        enclosingElement.source,
        match.sourceRange);
  }

  /**
   * Creates a new [RefactoringStatusContext] for the given [AstNode].
   */
  factory RefactoringStatusContext.forNode(AstNode node) {
    CompilationUnit unit = node.getAncestor((node) => node is CompilationUnit);
    CompilationUnitElement unitElement = unit.element;
    AnalysisContext context = unitElement.context;
    Source source = unitElement.source;
    SourceRange range = rangeNode(node);
    return new RefactoringStatusContext(context, source, range);
  }

  /**
   * Creates a new [RefactoringStatusContext] for the given [CompilationUnit].
   */
  factory RefactoringStatusContext.forUnit(CompilationUnit unit,
      SourceRange range) {
    CompilationUnitElement unitElement = unit.element;
    AnalysisContext context = unitElement.context;
    Source source = unitElement.source;
    return new RefactoringStatusContext(context, source, range);
  }

  @override
  String toString() {
    JavaStringBuilder builder = new JavaStringBuilder();
    builder.append("[source=");
    builder.append(source);
    builder.append(", range=");
    builder.append(range);
    builder.append("]");
    return builder.toString();
  }
}


/**
 * An immutable object representing an entry in a [RefactoringStatus].
 *
 * A [RefactoringStatusEntry] consists of a severity, a message and a context.
 */
class RefactoringStatusEntry {
  /**
   * The severity level.
   */
  final RefactoringStatusSeverity severity;

  /**
   * The message of the status entry.
   */
  final String message;

  /**
   * The [RefactoringStatusContext] which can be used to show more detailed
   * information regarding this status entry in the UI.
   *
   * May be `null` indicating that no context is available.
   */
  final RefactoringStatusContext context;

  RefactoringStatusEntry(this.severity, this.message, [this.context]);

  /**
   * Returns whether the entry represents an error or not.
   */
  bool get isError => severity == RefactoringStatusSeverity.ERROR;

  /**
   * Returns whether the entry represents a fatal error or not.
   */
  bool get isFatalError => severity == RefactoringStatusSeverity.FATAL;

  /**
   * Returns whether the entry represents a warning or not.
   */
  bool get isWarning => severity == RefactoringStatusSeverity.WARNING;

  @override
  String toString() {
    if (context != null) {
      return "${severity}: ${message}; Context: ${context}";
    } else {
      return "${severity}: ${message}";
    }
  }
}


/**
 * Severity of [RefactoringStatus].
 */
class RefactoringStatusSeverity {
  /**
   * The severity indicating the nominal case.
   */
  static const OK = const RefactoringStatusSeverity('OK', 0);

  /**
   * The severity indicating a warning.
   *
   * Use this severity if the refactoring can be performed, but you assume that
   * the user could not be aware of problems or confusions resulting from the
   * execution.
   */
  static const WARNING = const RefactoringStatusSeverity('WARNING', 2);

  /**
   * The severity indicating an error.
   *
   * Use this severity if the refactoring can be performed, but the refactoring
   * will not be behavior preserving and/or the partial execution will lead to
   * an inconsistent state (e.g. compile errors).
   */
  static const ERROR = const RefactoringStatusSeverity('ERROR', 3);

  /**
   * The severity indicating a fatal error.
   *
   * Use this severity if the refactoring cannot be performed, and execution
   * would lead to major problems. Note that this completely blocks the user
   * from performing this refactoring.
   *
   * It is often preferable to use an [ERROR] status and allow a partial
   * execution (e.g. if just one reference to a refactored element cannot be
   * updated).
   */
  static const FATAL = const RefactoringStatusSeverity('FATAL', 4);

  final String name;
  final int ordinal;

  const RefactoringStatusSeverity(this.name, this.ordinal);

  @override
  String toString() => name;

  /**
   * Returns the most severe [RefactoringStatusSeverity].
   */
  static RefactoringStatusSeverity _max(RefactoringStatusSeverity a,
      RefactoringStatusSeverity b) {
    if (b.ordinal > a.ordinal) {
      return b;
    }
    return a;
  }
}