// 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 'package:expect/expect.dart';
import 'package:kernel/ast.dart';
import 'package:kernel/src/equivalence.dart';

final Component component1 = createComponent();
final Component component2 = createComponent();

List<Test> tests = [
  Test(IntLiteral(0), IntLiteral(0)),
  Test(IntLiteral(42), IntLiteral(42)),
  Test(
    IntLiteral(0),
    IntLiteral(42),
    inequivalence: '''
Values 0 and 42 are not equivalent
.root
 IntLiteral.value
''',
  ),
  Test(StringLiteral('0'), StringLiteral('0')),
  Test(StringLiteral('42'), StringLiteral('42')),
  Test(
    StringLiteral('0'),
    StringLiteral('42'),
    inequivalence: '''
Values 0 and 42 are not equivalent
.root
 StringLiteral.value
''',
  ),
  Test(IntLiteral(0), IntLiteral(42), strategy: const IgnoreIntLiteralValue()),
  Test(
    StringLiteral('0'),
    StringLiteral('42'),
    strategy: const IgnoreIntLiteralValue(),
    inequivalence: '''
Values 0 and 42 are not equivalent
.root
 StringLiteral.value
''',
  ),
  Test(
    IntLiteral(0),
    StringLiteral('0'),
    inequivalence: '''
Inequivalent nodes
1: IntLiteral(0)
2: StringLiteral("0")
.root
''',
  ),
  Test(Not(Not(Not(BoolLiteral(true)))), Not(Not(Not(BoolLiteral(true))))),
  Test(
    Not(Not(BoolLiteral(true))),
    Not(Not(Not(BoolLiteral(true)))),
    inequivalence: '''
Inequivalent nodes
1: BoolLiteral(true)
2: Not(!true)
.root
 Not.operand
  Not.operand
''',
  ),
  Test(
    Not(Not(Not(BoolLiteral(true)))),
    Not(Not(BoolLiteral(true))),
    inequivalence: '''
Inequivalent nodes
1: Not(!true)
2: BoolLiteral(true)
.root
 Not.operand
  Not.operand
''',
  ),
  Test(
    Not(Not(Not(BoolLiteral(true)))),
    Not(Not(Not(BoolLiteral(false)))),
    inequivalence: '''
Values true and false are not equivalent
.root
 Not.operand
  Not.operand
   Not.operand
    BoolLiteral.value
''',
  ),
  Test(component1, component2),
  Test(component1.libraries[0], component2.libraries[0]),
  Test(
    component1.libraries[0],
    component2.libraries[1],
    inequivalence: '''
Inequivalent nodes
1: library import://uri1
2: library import://uri2
.root
''',
  ),
  Test(
    component1.libraries[1],
    component2.libraries[2],
    inequivalence: '''
Inequivalent nodes
1: library import://uri2
2: library import://uri3
.root
''',
  ),
  Test(
    component1.libraries[1],
    component2.libraries[3],
    inequivalence: '''
Values file://uri2/ and file://uri3/ are not equivalent
.root
 Library(library import://uri2).fileUri
''',
  ),
  Test(
    component1.libraries[0].procedures[0],
    component2.libraries[0].procedures[1],
    inequivalence: '''
Inequivalent nodes
1: foo
2: bar
.root
''',
  ),
  // TODO(johnniwinther): Improve message for inequivalent references with the
  // same simple name.
  Test(
    component1.libraries[0].procedures[0],
    component2.libraries[2].procedures[0],
    inequivalence: '''
Inequivalent nodes
1: foo
2: foo
.root
''',
  ),
  Test(
    StaticTearOff.byReference(Reference()),
    StaticTearOff.byReference(Reference()),
  ),
  Test(
    StaticTearOff.byReference(component1.libraries[0].procedures[0].reference),
    StaticTearOff.byReference(component2.libraries[0].procedures[0].reference),
  ),
  // TODO(johnniwinther): Improve message for inequivalent references with the
  // same simple name.
  Test(
    StaticTearOff.byReference(component1.libraries[0].procedures[0].reference),
    StaticTearOff.byReference(component2.libraries[2].procedures[0].reference),
    inequivalence: '''
Inequivalent references:
1: Reference to foo
2: Reference to foo
.root
 StaticTearOff.targetReference
''',
  ),
];

void main() {
  for (Test test in tests) {
    EquivalenceResult result = checkEquivalence(
      test.a,
      test.b,
      strategy: test.strategy,
    );
    if (test.isEquivalent) {
      Expect.equals(
        result.isEquivalent,
        test.isEquivalent,
        'Unexpected result for\n${test.a}\n${test.b}:\n$result',
      );
    } else if (result.isEquivalent) {
      Expect.equals(
        result.isEquivalent,
        test.isEquivalent,
        'Unexpected equivalence for\n${test.a}\n${test.b}:\n'
        'Expected ${test.inequivalence}',
      );
    } else {
      Expect.stringEquals(
        result.toString(),
        test.inequivalence!,
        'Unexpected inequivalence result for\n${test.a}\n${test.b}:\n'
        'Expected:\n---\n${test.inequivalence}\n---\n'
        'Actual:\n---\n${result}\n---',
      );
    }
  }
}

class Test {
  final Node a;
  final Node b;
  final String? inequivalence;
  final EquivalenceStrategy strategy;

  new(
    this.a,
    this.b, {
    this.inequivalence,
    this.strategy = const EquivalenceStrategy(),
  });

  bool get isEquivalent => inequivalence == null;
}

class IgnoreIntLiteralValue extends EquivalenceStrategy {
  const new();

  @override
  bool checkIntLiteral_value(
    EquivalenceVisitor visitor,
    IntLiteral a,
    IntLiteral b,
  ) => true;
}

Component createComponent() {
  Component component = new Component();
  Uri fileUri1 = Uri.parse('file://uri1');
  Uri fileUri2 = Uri.parse('file://uri2');
  Uri fileUri3 = Uri.parse('file://uri3');
  Uri importUri1 = Uri.parse('import://uri1');
  Uri importUri2 = Uri.parse('import://uri2');
  Uri importUri3 = Uri.parse('import://uri3');
  Library library1 = new Library(importUri1, fileUri: fileUri1);
  component.libraries.add(library1);
  Procedure procedure1foo = new Procedure(
    new Name('foo'),
    ProcedureKind.Method,
    new FunctionNode(null),
    fileUri: fileUri1,
  );
  library1.addProcedure(procedure1foo);
  Procedure procedure1bar = new Procedure(
    new Name('bar'),
    ProcedureKind.Method,
    new FunctionNode(null),
    fileUri: fileUri1,
  );
  library1.addProcedure(procedure1bar);

  Library library2 = new Library(importUri2, fileUri: fileUri2);
  component.libraries.add(library2);

  Library library3 = new Library(importUri3, fileUri: fileUri2);
  component.libraries.add(library3);
  Procedure procedure3foo = new Procedure(
    new Name('foo'),
    ProcedureKind.Method,
    new FunctionNode(null),
    fileUri: fileUri1,
  );
  library3.addProcedure(procedure3foo);

  Library library4 = new Library(importUri2, fileUri: fileUri3);
  component.libraries.add(library4);

  return component;
}