// Copyright (c) 2020, 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' show jsonDecode;

import 'package:package_config/package_config_types.dart';
import 'package:test/test.dart';
import 'src/util.dart';

void main() {
  var unique = Object();
  var root = Uri.file('/tmp/root/');

  group('LanguageVersion', () {
    test('minimal', () {
      var version = LanguageVersion(3, 5);
      expect(version.major, 3);
      expect(version.minor, 5);
    });

    test('negative major', () {
      expect(() => LanguageVersion(-1, 1), throwsArgumentError);
    });

    test('negative minor', () {
      expect(() => LanguageVersion(1, -1), throwsArgumentError);
    });

    test('minimal parse', () {
      var version = LanguageVersion.parse('3.5');
      expect(version.major, 3);
      expect(version.minor, 5);
    });

    void failParse(String name, String input) {
      test('$name - error', () {
        expect(() => LanguageVersion.parse(input),
            throwsA(isA<PackageConfigError>()));
        expect(() => LanguageVersion.parse(input), throwsFormatException);
        var failed = false;
        var actual = LanguageVersion.parse(input, onError: (_) {
          failed = true;
        });
        expect(failed, true);
        expect(actual, isA<LanguageVersion>());
      });
    }

    failParse('Leading zero major', '01.1');
    failParse('Leading zero minor', '1.01');
    failParse('Sign+ major', '+1.1');
    failParse('Sign- major', '-1.1');
    failParse('Sign+ minor', '1.+1');
    failParse('Sign- minor', '1.-1');
    failParse('WhiteSpace 1', ' 1.1');
    failParse('WhiteSpace 2', '1 .1');
    failParse('WhiteSpace 3', '1. 1');
    failParse('WhiteSpace 4', '1.1 ');
  });

  group('Package', () {
    test('minimal', () {
      var package = Package('name', root, extraData: unique);
      expect(package.name, 'name');
      expect(package.root, root);
      expect(package.packageUriRoot, root);
      expect(package.languageVersion, null);
      expect(package.extraData, same(unique));
    });

    test('absolute package root', () {
      var version = LanguageVersion(1, 1);
      var absolute = root.resolve('foo/bar/');
      var package = Package('name', root,
          packageUriRoot: absolute,
          relativeRoot: false,
          languageVersion: version,
          extraData: unique);
      expect(package.name, 'name');
      expect(package.root, root);
      expect(package.packageUriRoot, absolute);
      expect(package.languageVersion, version);
      expect(package.extraData, same(unique));
      expect(package.relativeRoot, false);
    });

    test('relative package root', () {
      var relative = Uri.parse('foo/bar/');
      var absolute = root.resolveUri(relative);
      var package = Package('name', root,
          packageUriRoot: relative, relativeRoot: true, extraData: unique);
      expect(package.name, 'name');
      expect(package.root, root);
      expect(package.packageUriRoot, absolute);
      expect(package.relativeRoot, true);
      expect(package.languageVersion, null);
      expect(package.extraData, same(unique));
    });

    for (var badName in ['a/z', 'a:z', '', '...']) {
      test("Invalid name '$badName'", () {
        expect(() => Package(badName, root), throwsPackageConfigError);
      });
    }

    test('Invalid root, not absolute', () {
      expect(
          () => Package('name', Uri.parse('/foo/')), throwsPackageConfigError);
    });

    test('Invalid root, not ending in slash', () {
      expect(() => Package('name', Uri.parse('file:///foo')),
          throwsPackageConfigError);
    });

    test('invalid package root, not ending in slash', () {
      expect(() => Package('name', root, packageUriRoot: Uri.parse('foo')),
          throwsPackageConfigError);
    });

    test('invalid package root, not inside root', () {
      expect(() => Package('name', root, packageUriRoot: Uri.parse('../baz/')),
          throwsPackageConfigError);
    });
  });

  group('package config', () {
    test('empty', () {
      var empty = PackageConfig([], extraData: unique);
      expect(empty.version, 2);
      expect(empty.packages, isEmpty);
      expect(empty.extraData, same(unique));
      expect(empty.resolve(pkg('a', 'b')), isNull);
    });

    test('single', () {
      var package = Package('name', root);
      var single = PackageConfig([package], extraData: unique);
      expect(single.version, 2);
      expect(single.packages, hasLength(1));
      expect(single.extraData, same(unique));
      expect(single.resolve(pkg('a', 'b')), isNull);
      var resolved = single.resolve(pkg('name', 'a/b'));
      expect(resolved, root.resolve('a/b'));
    });
  });
  test('writeString', () {
    var config = PackageConfig([
      Package('foo', Uri.parse('file:///pkg/foo/'),
          packageUriRoot: Uri.parse('file:///pkg/foo/lib/'),
          relativeRoot: false,
          languageVersion: LanguageVersion(2, 4),
          extraData: {'foo': 'foo!'}),
      Package('bar', Uri.parse('file:///pkg/bar/'),
          packageUriRoot: Uri.parse('file:///pkg/bar/lib/'),
          relativeRoot: true,
          extraData: {'bar': 'bar!'}),
    ], extraData: {
      'extra': 'data'
    });
    var buffer = StringBuffer();
    PackageConfig.writeString(config, buffer, Uri.parse('file:///pkg/'));
    var text = buffer.toString();
    var json = jsonDecode(text); // Is valid JSON.
    expect(json, {
      'configVersion': 2,
      'packages': unorderedEquals([
        {
          'name': 'foo',
          'rootUri': 'file:///pkg/foo/',
          'packageUri': 'lib/',
          'languageVersion': '2.4',
          'foo': 'foo!',
        },
        {
          'name': 'bar',
          'rootUri': 'bar/',
          'packageUri': 'lib/',
          'bar': 'bar!',
        },
      ]),
      'extra': 'data',
    });
  });
}

final Matcher throwsPackageConfigError = throwsA(isA<PackageConfigError>());