// Copyright (c) 2021, 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 'dart:convert';

import "package:expect/expect.dart";

/// Helper class for determining when no argument is passed to a function.
class Absent {
  const Absent();
}

const absent = Absent();

/// Returns an approximate representation of the syntax that was used to
/// construct [x].  Extra parentheses are used around unary and binary
/// expressions to disambiguate precedence.
String syntax(Object? x) {
  var knownSyntax = SyntaxTracker.known[x];
  if (knownSyntax != null) return knownSyntax;
  if (x is SyntaxTracker || x is num) {
    return x.toString();
  } else if (x is List) {
    return '[${x.map(syntax).join(', ')}]';
  } else if (x is Set) {
    if (x.isEmpty) return 'Set()';
    return '{${x.map(syntax).join(', ')}}';
  } else if (x is Map) {
    if (x.isEmpty) return '{}';
    var entries = x.entries
        .map((entry) => '${syntax(entry.key)}: ${syntax(entry.value)}');
    return '{ ${entries.join(', ')} }';
  } else if (x is String) {
    return json.encode(x);
  } else {
    throw UnimplementedError('Unknown syntax for $x.  '
        'Consider adding to `SyntaxTracker.known`.');
  }
}

/// Instances of this class record the syntax of operations performed on them.
class SyntaxTracker {
  final String _syntax;

  SyntaxTracker(this._syntax);

  String toString() => _syntax;

  static String args([Object? x = absent, Object? y = absent]) =>
      '(${[x, y].where((v) => v is! Absent).join(', ')})';

  static String typeArgs(Type T, Type U) =>
      T == dynamic && U == dynamic ? '' : '<${syntax(T)}, ${syntax(U)}>';

  /// Simple objects with known syntactic representations.  Tests can add to
  /// this map.
  static Map<Object?, String> known = {
    true: 'true',
    false: 'false',
    null: 'null'
  };
}

/// Extension allowing us to detect the syntax of most operations performed on
/// arbitrary types.
extension SyntaxTrackingExtension on Object? {
  Object? method<T, U>([Object? x = absent, Object? y = absent]) => SyntaxTracker(
      '${syntax(this)}.method${SyntaxTracker.typeArgs(T, U)}${SyntaxTracker.args(x, y)}');

  Object? call<T, U>([Object? x = absent, Object? y = absent]) => SyntaxTracker(
      '${syntax(this)}${SyntaxTracker.typeArgs(T, U)}${SyntaxTracker.args(x, y)}');

  Object? get getter => SyntaxTracker('${syntax(this)}.getter');

  Object? operator [](Object? index) =>
      SyntaxTracker('${syntax(this)}[${syntax(index)}]');

  Object? operator -() => SyntaxTracker('(-${syntax(this)})');

  Object? operator ~() => SyntaxTracker('(~${syntax(this)})');

  Object? operator *(Object? other) =>
      SyntaxTracker('(${syntax(this)} * ${syntax(other)})');

  Object? operator /(Object? other) =>
      SyntaxTracker('(${syntax(this)} / ${syntax(other)})');

  Object? operator ~/(Object? other) =>
      SyntaxTracker('(${syntax(this)} ~/ ${syntax(other)})');

  Object? operator %(Object? other) =>
      SyntaxTracker('(${syntax(this)} % ${syntax(other)})');

  Object? operator +(Object? other) =>
      SyntaxTracker('(${syntax(this)} + ${syntax(other)})');

  Object? operator -(Object? other) =>
      SyntaxTracker('(${syntax(this)} - ${syntax(other)})');

  Object? operator <<(Object? other) =>
      SyntaxTracker('(${syntax(this)} << ${syntax(other)})');

  Object? operator >>(Object? other) =>
      SyntaxTracker('(${syntax(this)} >> ${syntax(other)})');

  Object? operator &(Object? other) =>
      SyntaxTracker('(${syntax(this)} & ${syntax(other)})');

  Object? operator ^(Object? other) =>
      SyntaxTracker('(${syntax(this)} ^ ${syntax(other)})');

  Object? operator |(Object? other) =>
      SyntaxTracker('(${syntax(this)} | ${syntax(other)})');

  Object? operator <(Object? other) =>
      SyntaxTracker('(${syntax(this)} < ${syntax(other)})');

  Object? operator >(Object? other) =>
      SyntaxTracker('(${syntax(this)} > ${syntax(other)})');

  Object? operator <=(Object? other) =>
      SyntaxTracker('(${syntax(this)} <= ${syntax(other)})');

  Object? operator >=(Object? other) =>
      SyntaxTracker('(${syntax(this)} >= ${syntax(other)})');
}

void checkSyntax(Object? x, String expectedSyntax) {
  Expect.equals(expectedSyntax, syntax(x));
}

Object? f<T, U>([Object? x = absent, Object? y = absent]) => SyntaxTracker(
    'f${SyntaxTracker.typeArgs(T, U)}${SyntaxTracker.args(x, y)}');

Object? x = SyntaxTracker('x');