// Copyright (c) 2017, 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:code_builder/code_builder.dart';
import 'package:test/test.dart';

import '../../common.dart';

void main() {
  useDartfmt();

  test('should emit a simple expression', () {
    expect(literalNull, equalsDart('null'));
  });

  group('literal', () {
    test('forwards values that are already expressions', () {
      expect(literal(refer('foo')), equalsDart('foo'));
      expect(literal([refer('foo')]), equalsDart('[foo]'));
    });
    group('wraps', () {
      test('bool values', () {
        expect(literal(true), equalsDart('true'));
      });
      test('numeric values', () {
        expect(literal(1), equalsDart('1'));
        expect(literal(1.0), equalsDart('1.0'));
      });
      test('string values', () {
        expect(literal('foo'), equalsDart("'foo'"));
      });
      test('list values', () {
        expect(literal([1]), equalsDart('[1]'));
      });
      test('set values', () {
        expect(literal({1}), equalsDart('{1}'));
      });
      test('map values', () {
        expect(literal({'foo': 1}), equalsDart("{'foo': 1}"));
      });
      test('null', () {
        expect(literal(null), equalsDart('null'));
      });
    });
    test('uses `onError` for unhandled types', () {
      expect(
          literal(Uri.https('google.com'), onError: (value) {
            if (value is Uri) {
              return refer('Uri')
                  .newInstanceNamed('parse', [literalString(value.toString())]);
            }
            throw UnsupportedError('Not supported: $value');
          }),
          equalsDart("Uri.parse('https://google.com')"));
    });
  });

  test('should emit a String', () {
    expect(literalString(r'$monkey'), equalsDart(r"'$monkey'"));
  });

  test('should emit a raw String', () {
    expect(literalString(r'$monkey', raw: true), equalsDart(r"r'$monkey'"));
  });

  test('should escape single quotes in a String', () {
    expect(literalString(r"don't"), equalsDart(r"'don\'t'"));
  });

  test('does not allow single quote in raw string', () {
    expect(() => literalString(r"don't", raw: true), throwsArgumentError);
  });

  test('should escape a newline in a string', () {
    expect(literalString('some\nthing'), equalsDart(r"'some\nthing'"));
  });

  test('should emit a && expression', () {
    expect(literalTrue.and(literalFalse), equalsDart('true && false'));
  });

  test('should emit a || expression', () {
    expect(literalTrue.or(literalFalse), equalsDart('true || false'));
  });

  test('should emit a ! expression', () {
    expect(literalTrue.negate(), equalsDart('!true'));
  });

  test('should emit a list', () {
    expect(literalList([]), equalsDart('[]'));
  });

  test('should emit a const list', () {
    expect(literalConstList([]), equalsDart('const []'));
  });

  test('should emit an explicitly typed list', () {
    expect(literalList([], refer('int')), equalsDart('<int>[]'));
  });

  test('should emit a set', () {
    // ignore: prefer_collection_literals
    expect(literalSet(Set()), equalsDart('{}'));
  });

  test('should emit a const set', () {
    // ignore: prefer_collection_literals
    expect(literalConstSet(Set()), equalsDart('const {}'));
  });

  test('should emit an explicitly typed set', () {
    // ignore: prefer_collection_literals
    expect(literalSet(Set(), refer('int')), equalsDart('<int>{}'));
  });

  test('should emit a map', () {
    expect(literalMap({}), equalsDart('{}'));
  });

  test('should emit a const map', () {
    expect(literalConstMap({}), equalsDart('const {}'));
  });

  test('should emit an explicitly typed map', () {
    expect(
      literalMap({}, refer('int'), refer('bool')),
      equalsDart('<int, bool>{}'),
    );
  });

  test('should emit a map of other literals and expressions', () {
    expect(
      literalMap({
        1: 'one',
        2: refer('two'),
        refer('three'): 3,
        refer('Map').newInstance([]): null,
      }),
      equalsDart(r"{1: 'one', 2: two, three: 3, Map(): null, }"),
    );
  });

  test('should emit a map with spreads', () {
    expect(
      literalMap({
        literalSpread(): refer('one'),
        2: refer('two'),
        literalNullSafeSpread(): refer('three'),
        refer('Map').newInstance([]): null,
      }),
      equalsDart('{...one, 2: two, ...?three, Map(): null, }'),
    );
  });

  test('should emit a list of other literals and expressions', () {
    expect(
      literalList([
        <dynamic>[],
        // ignore: prefer_collection_literals
        Set<dynamic>(),
        true,
        null,
        refer('Map').newInstance([])
      ]),
      equalsDart('[[], {}, true, null, Map(), ]'),
    );
  });

  test('can toString a list literal with an expression as a value', () {
    expect(literalList([refer('foo')]).toString, isNot(throwsA(anything)));
  });

  test('should emit a set of other literals and expressions', () {
    expect(
      // ignore: prefer_collection_literals
      literalSet([
        <dynamic>[],
        // ignore: prefer_collection_literals
        Set<dynamic>(),
        true,
        null,
        refer('Map').newInstance([])
      ]),
      equalsDart('{[], {}, true, null, Map(), }'),
    );
  });

  test('should emit an empty record', () {
    expect(literalRecord([], {}), equalsDart('()'));
  });

  test('should emit a const empty record', () {
    expect(literalConstRecord([], {}), equalsDart('const ()'));
  });

  test('should emit a record with only positional fields', () {
    expect(literalRecord([1, ''], {}), equalsDart("(1, '')"));
  });

  test('should correctly emit a record with a single positional field', () {
    expect(literalRecord([1], {}), equalsDart('(1,)'));
  });

  test('should emit a record with only named fields', () {
    expect(literalRecord([], {'named': 1, 'other': []}),
        equalsDart('(named: 1, other: [])'));
  });

  test('should emit a record with both positional and named fields', () {
    expect(literalRecord([0], {'x': true, 'y': 0}),
        equalsDart('(0, x: true, y: 0)'));
  });

  test('should emit a record of other literals and expressions', () {
    expect(
        literalRecord([
          1,
          refer('one'),
          'one'
        ], {
          'named': refer('Foo').newInstance([literalNum(1)])
        }),
        equalsDart("(1, one, 'one', named: Foo(1))"));
  });

  test('should emit a type as an expression', () {
    expect(refer('Map'), equalsDart('Map'));
  });

  test('should emit a scoped type as an expression', () {
    expect(
      refer('Foo', 'package:foo/foo.dart'),
      equalsDart(
          '_i1.Foo', DartEmitter(allocator: Allocator.simplePrefixing())),
    );
  });

  test('should emit invoking Type()', () {
    expect(
      refer('Map').newInstance([]),
      equalsDart('Map()'),
    );
  });

  test('should emit invoking named constructor', () {
    expect(
      refer('Foo').newInstanceNamed('bar', []),
      equalsDart('Foo.bar()'),
    );
  });

  test('should emit invoking unnamed constructor when name is empty', () {
    expect(
      refer('Foo').newInstanceNamed('', []),
      equalsDart('Foo()'),
    );
  });

  test('should emit invoking const Type()', () {
    expect(
      refer('Object').constInstance([]),
      equalsDart('const Object()'),
    );
  });

  test('should emit invoking a property accessor', () {
    expect(refer('foo').property('bar'), equalsDart('foo.bar'));
  });

  test('should emit invoking a cascade property accessor', () {
    expect(refer('foo').cascade('bar'), equalsDart('foo..bar'));
  });

  test('should emit invoking a null safe property accessor', () {
    expect(refer('foo').nullSafeProperty('bar'), equalsDart('foo?.bar'));
  });

  test('should emit invoking a method with a single positional argument', () {
    expect(
      refer('foo').call([
        literal(1),
      ]),
      equalsDart('foo(1)'),
    );
  });

  test('should emit invoking a method with positional arguments', () {
    expect(
      refer('foo').call([
        literal(1),
        literal(2),
        literal(3),
      ]),
      equalsDart('foo(1, 2, 3, )'),
    );
  });

  test('should emit invoking a method with a single named argument', () {
    expect(
      refer('foo').call([], {
        'bar': literal(1),
      }),
      equalsDart('foo(bar: 1)'),
    );
  });

  test('should emit invoking a method with named arguments', () {
    expect(
      refer('foo').call([], {
        'bar': literal(1),
        'baz': literal(2),
      }),
      equalsDart('foo(bar: 1, baz: 2, )'),
    );
  });

  test('should emit invoking a method with positional and named arguments', () {
    expect(
      refer('foo').call([
        literal(1)
      ], {
        'bar': literal(2),
        'baz': literal(3),
      }),
      equalsDart('foo(1, bar: 2, baz: 3, )'),
    );
  });

  test('should emit invoking a method with a single type argument', () {
    expect(
      refer('foo').call(
        [],
        {},
        [
          refer('String'),
        ],
      ),
      equalsDart('foo<String>()'),
    );
  });

  test('should emit invoking a method with type arguments', () {
    expect(
      refer('foo').call(
        [],
        {},
        [
          refer('String'),
          refer('int'),
        ],
      ),
      equalsDart('foo<String, int>()'),
    );
  });

  test('should emit a function type', () {
    expect(
      FunctionType((b) => b.returnType = refer('void')),
      equalsDart('void Function()'),
    );
  });

  test('should emit a typedef statement', () {
    expect(
      FunctionType((b) => b.returnType = refer('void')).toTypeDef('Void0'),
      equalsDart('typedef Void0 = void Function();'),
    );
  });

  test('should emit a function type with type parameters', () {
    expect(
      FunctionType((b) => b
        ..returnType = refer('T')
        ..types.add(refer('T'))),
      equalsDart('T Function<T>()'),
    );
  });

  test('should emit a function type a single parameter', () {
    expect(
      FunctionType((b) => b..requiredParameters.add(refer('String'))),
      equalsDart('Function(String)'),
    );
  });

  test('should emit a function type with parameters', () {
    expect(
      FunctionType((b) => b
        ..requiredParameters.add(refer('String'))
        ..optionalParameters.add(refer('int'))),
      equalsDart('Function(String, [int, ])'),
    );
  });

  test('should emit a function type with named parameters', () {
    expect(
      FunctionType((b) => b
        ..namedParameters.addAll({
          'x': refer('int'),
          'y': refer('int'),
        })),
      equalsDart('Function({int x, int y, })'),
    );
  });

  test(
      'should emit a function type with named required and optional parameters',
      () {
    expect(
      FunctionType((b) => b
        ..namedRequiredParameters.addAll({
          'x': refer('int'),
        })
        ..namedParameters.addAll({
          'y': refer('int'),
        })),
      equalsDart('Function({required int x, int y, })'),
    );
  });

  test('should emit a function type with named required parameters', () {
    expect(
      FunctionType((b) => b
        ..namedRequiredParameters.addAll({
          'x': refer('int'),
          'y': refer('int'),
        })),
      equalsDart('Function({required int x, required int y, })'),
    );
  });

  test('should emit a nullable function type in a Null Safety library', () {
    final emitter = DartEmitter.scoped(useNullSafetySyntax: true);
    expect(
      FunctionType((b) => b
        ..requiredParameters.add(refer('String'))
        ..isNullable = true),
      equalsDart('Function(String)?', emitter),
    );
  });

  test('should emit a nullable function type in pre-Null Safety library', () {
    expect(
      FunctionType((b) => b
        ..requiredParameters.add(refer('String'))
        ..isNullable = true),
      equalsDart('Function(String)'),
    );
  });

  test('should emit a non-nullable function type in a Null Safety library', () {
    final emitter = DartEmitter.scoped(useNullSafetySyntax: true);
    expect(
      FunctionType((b) => b
        ..requiredParameters.add(refer('String'))
        ..isNullable = false),
      equalsDart('Function(String)', emitter),
    );
  });

  test('should emit a non-nullable function type in pre-Null Safety library',
      () {
    expect(
      FunctionType((b) => b
        ..requiredParameters.add(refer('String'))
        ..isNullable = false),
      equalsDart('Function(String)'),
    );
  });

  test('should emit a closure', () {
    expect(
      refer('map').property('putIfAbsent').call([
        literalString('foo'),
        Method((b) => b..body = literalTrue.code).closure,
      ]),
      equalsDart("map.putIfAbsent('foo', () => true, )"),
    );
  });

  test('should emit a generic closure', () {
    expect(
      refer('map').property('putIfAbsent').call([
        literalString('foo'),
        Method((b) => b
          ..types.add(refer('T'))
          ..body = literalTrue.code).genericClosure,
      ]),
      equalsDart("map.putIfAbsent('foo', <T>() => true, )"),
    );
  });

  test('should emit an assignment', () {
    expect(
      refer('foo').assign(literalTrue),
      equalsDart('foo = true'),
    );
  });

  test('should emit an if null assignment', () {
    expect(
      refer('foo').ifNullThen(literalTrue),
      equalsDart('foo ?? true'),
    );
  });

  test('should emit a null check', () {
    expect(refer('foo').nullChecked, equalsDart('foo!'));
  });

  test('should emit an if null index operator set', () {
    expect(
      refer('bar')
          .index(literalTrue)
          .ifNullThen(literalFalse)
          // ignore: deprecated_member_use_from_same_package
          .assignVar('foo')
          .statement,
      equalsDart('var foo = bar[true] ?? false;'),
    );
  });

  test('should emit a null-aware assignment', () {
    expect(
      refer('foo').assignNullAware(literalTrue),
      equalsDart('foo ??= true'),
    );
  });

  test('should emit an index operator', () {
    expect(
      // ignore: deprecated_member_use_from_same_package
      refer('bar').index(literalString('key')).assignVar('foo').statement,
      equalsDart("var foo = bar['key'];"),
    );
  });

  test('should emit an index operator set', () {
    expect(
      refer('bar')
          .index(literalString('key'))
          .assign(literalFalse)
          // ignore: deprecated_member_use_from_same_package
          .assignVar('foo')
          .statement,
      equalsDart("var foo = bar['key'] = false;"),
    );
  });

  test('should emit a null-aware index operator set', () {
    expect(
      refer('bar')
          .index(literalTrue)
          .assignNullAware(literalFalse)
          // ignore: deprecated_member_use_from_same_package
          .assignVar('foo')
          .statement,
      equalsDart('var foo = bar[true] ??= false;'),
    );
  });

  test('should emit assigning to a var', () {
    expect(
      // ignore: deprecated_member_use_from_same_package
      literalTrue.assignVar('foo'),
      equalsDart('var foo = true'),
    );
  });

  test('should emit assigning to a type', () {
    expect(
      // ignore: deprecated_member_use_from_same_package
      literalTrue.assignVar('foo', refer('bool')),
      equalsDart('bool foo = true'),
    );
  });

  test('should emit assigning to a final', () {
    expect(
      // ignore: deprecated_member_use_from_same_package
      literalTrue.assignFinal('foo'),
      equalsDart('final foo = true'),
    );
  });

  test('should emit assigning to a const', () {
    expect(
      // ignore: deprecated_member_use_from_same_package
      literalTrue.assignConst('foo'),
      equalsDart('const foo = true'),
    );
  });

  test('should emit await', () {
    expect(
      refer('future').awaited,
      equalsDart('await future'),
    );
  });

  test('should emit return', () {
    expect(
      literalNull.returned,
      equalsDart('return null'),
    );
  });

  test('should emit spread', () {
    expect(
      refer('foo').spread,
      equalsDart('...foo'),
    );
  });

  test('should emit null safe spread', () {
    expect(
      refer('foo').nullSafeSpread,
      equalsDart('...?foo'),
    );
  });

  test('should emit throw', () {
    expect(
      literalNull.thrown,
      equalsDart('throw null'),
    );
  });

  test('should emit an explicit cast', () {
    expect(
      refer('foo').asA(refer('String')).property('length'),
      equalsDart('(foo as String).length'),
    );
  });

  test('should emit an is check', () {
    expect(
      refer('foo').isA(refer('String')),
      equalsDart('foo is String'),
    );
  });

  test('should emit an is! check', () {
    expect(
      refer('foo').isNotA(refer('String')),
      equalsDart('foo is! String'),
    );
  });

  test('should emit an equality check', () {
    expect(
      refer('foo').equalTo(literalString('bar')),
      equalsDart("foo == 'bar'"),
    );
  });

  test('should emit an inequality check', () {
    expect(
      refer('foo').notEqualTo(literalString('bar')),
      equalsDart("foo != 'bar'"),
    );
  });

  test('should emit an greater than check', () {
    expect(
      refer('foo').greaterThan(literalString('bar')),
      equalsDart("foo > 'bar'"),
    );
  });

  test('should emit an less than check', () {
    expect(
      refer('foo').lessThan(literalString('bar')),
      equalsDart("foo < 'bar'"),
    );
  });

  test('should emit an greater or equals check', () {
    expect(
      refer('foo').greaterOrEqualTo(literalString('bar')),
      equalsDart("foo >= 'bar'"),
    );
  });

  test('should emit an less or equals check', () {
    expect(
      refer('foo').lessOrEqualTo(literalString('bar')),
      equalsDart("foo <= 'bar'"),
    );
  });

  test('should emit a conditional', () {
    expect(
      refer('foo').conditional(literal(1), literal(2)),
      equalsDart('foo ? 1 : 2'),
    );
  });

  test('should emit an operator add call', () {
    expect(refer('foo').operatorAdd(refer('foo2')), equalsDart('foo + foo2'));
  });

  test('should emit an operator subtract call', () {
    // ignore: deprecated_member_use_from_same_package
    expect(refer('foo').operatorSubstract(refer('foo2')),
        equalsDart('foo - foo2'));

    expect(
      refer('foo').operatorSubtract(refer('foo2')),
      equalsDart('foo - foo2'),
    );
  });

  test('should emit an operator divide call', () {
    expect(
        refer('foo').operatorDivide(refer('foo2')), equalsDart('foo / foo2'));
  });

  test('should emit an operator multiply call', () {
    expect(
        refer('foo').operatorMultiply(refer('foo2')), equalsDart('foo * foo2'));
  });

  test('should emit an euclidean modulo operator call', () {
    expect(refer('foo').operatorEuclideanModulo(refer('foo2')),
        equalsDart('foo % foo2'));
  });

  test('should emit an operator int divide call', () {
    expect(
      refer('foo').operatorIntDivide(refer('foo2')),
      equalsDart('foo ~/ foo2'),
    );
  });

  test('should emit a unary prefix increment operator call', () {
    expect(refer('foo').operatorUnaryPrefixIncrement(), equalsDart('++foo'));
  });

  test('should emit a unary postfix increment operator call', () {
    expect(refer('foo').operatorUnaryPostfixIncrement(), equalsDart('foo++'));
  });

  test('should emit a unary prefix minus operator call', () {
    expect(refer('foo').operatorUnaryMinus(), equalsDart('-foo'));
  });

  test('should emit a unary prefix decrement operator call', () {
    expect(refer('foo').operatorUnaryPrefixDecrement(), equalsDart('--foo'));
  });

  test('should emit a unary postfix decrement operator call', () {
    expect(refer('foo').operatorUnaryPostfixDecrement(), equalsDart('foo--'));
  });

  test('should emit a bitwise AND operator call', () {
    expect(
      refer('foo').operatorBitwiseAnd(refer('foo2')),
      equalsDart('foo & foo2'),
    );
  });

  test('should emit a bitwise OR operator call', () {
    expect(
      refer('foo').operatorBitwiseOr(refer('foo2')),
      equalsDart('foo | foo2'),
    );
  });

  test('should emit a bitwise XOR operator call', () {
    expect(
      refer('foo').operatorBitwiseXor(refer('foo2')),
      equalsDart('foo ^ foo2'),
    );
  });

  test('should emit a unary bitwise complement operator call', () {
    expect(
      refer('foo').operatorUnaryBitwiseComplement(),
      equalsDart('~foo'),
    );
  });

  test('should emit a shift left operator call', () {
    expect(
      refer('foo').operatorShiftLeft(refer('foo2')),
      equalsDart('foo << foo2'),
    );
  });

  test('should emit a shift right operator call', () {
    expect(
      refer('foo').operatorShiftRight(refer('foo2')),
      equalsDart('foo >> foo2'),
    );
  });

  test('should emit a shift right unsigned operator call', () {
    expect(
      refer('foo').operatorShiftRightUnsigned(refer('foo2')),
      equalsDart('foo >>> foo2'),
    );
  });

  test('should emit a const variable declaration', () {
    expect(declareConst('foo').assign(refer('bar')),
        equalsDart('const foo = bar'));
  });

  test('should emit a typed const variable declaration', () {
    expect(declareConst('foo', type: refer('String')).assign(refer('bar')),
        equalsDart('const String foo = bar'));
  });

  test('should emit a final variable declaration', () {
    expect(declareFinal('foo').assign(refer('bar')),
        equalsDart('final foo = bar'));
  });

  test('should emit a typed final variable declaration', () {
    expect(declareFinal('foo', type: refer('String')).assign(refer('bar')),
        equalsDart('final String foo = bar'));
  });

  test('should emit a nullable typed final variable declaration', () {
    final emitter = DartEmitter.scoped(useNullSafetySyntax: true);
    expect(
        declareFinal('foo',
            type: TypeReference((b) => b
              ..symbol = 'String'
              ..isNullable = true)).assign(refer('bar')),
        equalsDart('final String? foo = bar', emitter));
  }, skip: 'https://github.com/dart-lang/code_builder/issues/315');

  test('should emit a late final variable declaration', () {
    expect(declareFinal('foo', late: true).assign(refer('bar')),
        equalsDart('late final foo = bar'));
  });

  test('should emit a late typed final variable declaration', () {
    expect(
        declareFinal('foo', type: refer('String'), late: true)
            .assign(refer('bar')),
        equalsDart('late final String foo = bar'));
  });

  test('should emit a variable declaration', () {
    expect(declareVar('foo').assign(refer('bar')), equalsDart('var foo = bar'));
  });

  test('should emit a typed variable declaration', () {
    expect(declareVar('foo', type: refer('String')).assign(refer('bar')),
        equalsDart('String foo = bar'));
  });

  test('should emit a late variable declaration', () {
    expect(declareVar('foo', late: true).assign(refer('bar')),
        equalsDart('late var foo = bar'));
  });

  test('should emit a late typed variable declaration', () {
    expect(
        declareVar('foo', type: refer('String'), late: true)
            .assign(refer('bar')),
        equalsDart('late String foo = bar'));
  });

  test('should emit a perenthesized epression', () {
    expect(
        refer('foo').ifNullThen(refer('FormatException')
            .newInstance([literalString('missing foo')])
            .thrown
            .parenthesized),
        equalsDart('foo ?? (throw FormatException(\'missing foo\'))'));
  });

  test('should emit an addition assigment expression', () {
    expect(
      refer('foo').addAssign(refer('bar')),
      equalsDart('foo += bar'),
    );
  });

  test('should emit a subtraction assigment expression', () {
    expect(
      refer('foo').subtractAssign(refer('bar')),
      equalsDart('foo -= bar'),
    );
  });

  test('should emit a multiplication assigment expression', () {
    expect(
      refer('foo').multiplyAssign(refer('bar')),
      equalsDart('foo *= bar'),
    );
  });

  test('should emit a division assigment expression', () {
    expect(
      refer('foo').divideAssign(refer('bar')),
      equalsDart('foo /= bar'),
    );
  });

  test('should emit an int division assigment expression', () {
    expect(
      refer('foo').intDivideAssign(refer('bar')),
      equalsDart('foo ~/= bar'),
    );
  });

  test('should emit a euclidean modulo assigment expression', () {
    expect(
      refer('foo').euclideanModuloAssign(refer('bar')),
      equalsDart('foo %= bar'),
    );
  });

  test('should emit a shift left assigment expression', () {
    expect(
      refer('foo').shiftLeftAssign(refer('bar')),
      equalsDart('foo <<= bar'),
    );
  });

  test('should emit a shift right assigment expression', () {
    expect(
      refer('foo').shiftRightAssign(refer('bar')),
      equalsDart('foo >>= bar'),
    );
  });

  test('should emit a shift right unsigned assigment expression', () {
    expect(
      refer('foo').shiftRightUnsignedAssign(refer('bar')),
      equalsDart('foo >>>= bar'),
    );
  });

  test('should emit a bitwise AND assigment expression', () {
    expect(
      refer('foo').bitwiseAndAssign(refer('bar')),
      equalsDart('foo &= bar'),
    );
  });

  test('should emit a bitwise XOR assigment expression', () {
    expect(
      refer('foo').bitwiseXorAssign(refer('bar')),
      equalsDart('foo ^= bar'),
    );
  });

  test('should emit a bitwise OR assigment expression', () {
    expect(
      refer('foo').bitwiseOrAssign(refer('bar')),
      equalsDart('foo |= bar'),
    );
  });
}