// Copyright 2020 The Fuchsia Authors. 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:fxtest/fxtest.dart';
import 'package:test/test.dart';

void main() {
  group('fuchsia-package URLs are correctly parsed', () {
    test('when all components are present', () {
      PackageUrl packageUrl = PackageUrl.fromString(
          'fuchsia-pkg://myroot.com/pkg-name/VARIANT?hash=asdf#OMG.cmx');
      expect(packageUrl.host, 'myroot.com');
      expect(packageUrl.packageName, 'pkg-name');
      expect(packageUrl.packageVariant, 'VARIANT');
      expect(packageUrl.hash, 'asdf');
      expect(packageUrl.fullComponentName, 'OMG.cmx');
      expect(packageUrl.componentName, 'OMG');
    });

    test('when all components are present plus meta', () {
      PackageUrl packageUrl = PackageUrl.fromString(
          'fuchsia-pkg://myroot.com/pkg-name/VARIANT?hash=asdf#meta/OMG.cmx');
      expect(packageUrl.host, 'myroot.com');
      expect(packageUrl.packageName, 'pkg-name');
      expect(packageUrl.packageVariant, 'VARIANT');
      expect(packageUrl.hash, 'asdf');
      expect(packageUrl.fullComponentName, 'OMG.cmx');
      expect(packageUrl.componentName, 'OMG');
    });

    test('when the variant is missing', () {
      PackageUrl packageUrl = PackageUrl.fromString(
          'fuchsia-pkg://myroot.com/pkg-name?hash=asdf#OMG.cmx');
      expect(packageUrl.host, 'myroot.com');
      expect(packageUrl.packageName, 'pkg-name');
      expect(packageUrl.packageVariant, null);
      expect(packageUrl.hash, 'asdf');
      expect(packageUrl.fullComponentName, 'OMG.cmx');
      expect(packageUrl.componentName, 'OMG');
    });

    test('when the hash is missing', () {
      PackageUrl packageUrl = PackageUrl.fromString(
          'fuchsia-pkg://myroot.com/pkg-name/VARIANT#OMG.cmx');
      expect(packageUrl.host, 'myroot.com');
      expect(packageUrl.packageName, 'pkg-name');
      expect(packageUrl.packageVariant, 'VARIANT');
      expect(packageUrl.hash, null);
      expect(packageUrl.fullComponentName, 'OMG.cmx');
      expect(packageUrl.componentName, 'OMG');
    });

    test('when the resource path is missing', () {
      PackageUrl packageUrl = PackageUrl.fromString(
          'fuchsia-pkg://myroot.com/pkg-name/VARIANT?hash=asdf');
      expect(packageUrl.host, 'myroot.com');
      expect(packageUrl.packageName, 'pkg-name');
      expect(packageUrl.packageVariant, 'VARIANT');
      expect(packageUrl.hash, 'asdf');
      expect(packageUrl.fullComponentName, '');
      expect(packageUrl.componentName, '');
    });

    test('when the variant and hash are missing', () {
      PackageUrl packageUrl =
          PackageUrl.fromString('fuchsia-pkg://myroot.com/pkg-name#OMG.cmx');
      expect(packageUrl.host, 'myroot.com');
      expect(packageUrl.packageName, 'pkg-name');
      expect(packageUrl.packageVariant, null);
      expect(packageUrl.hash, null);
      expect(packageUrl.fullComponentName, 'OMG.cmx');
      expect(packageUrl.componentName, 'OMG');
    });
    test('when the variant and resource path are missing', () {
      PackageUrl packageUrl =
          PackageUrl.fromString('fuchsia-pkg://myroot.com/pkg-name?hash=asdf');
      expect(packageUrl.host, 'myroot.com');
      expect(packageUrl.packageName, 'pkg-name');
      expect(packageUrl.packageVariant, null);
      expect(packageUrl.hash, 'asdf');
      expect(packageUrl.fullComponentName, '');
      expect(packageUrl.componentName, '');
    });

    test('when the hash and resource path are missing', () {
      PackageUrl packageUrl =
          PackageUrl.fromString('fuchsia-pkg://myroot.com/pkg-name/VARIANT');
      expect(packageUrl.host, 'myroot.com');
      expect(packageUrl.packageName, 'pkg-name');
      expect(packageUrl.packageVariant, 'VARIANT');
      expect(packageUrl.hash, null);
      expect(packageUrl.fullComponentName, '');
      expect(packageUrl.componentName, '');
    });

    test('when the variant, hash, and resource path are missing', () {
      PackageUrl packageUrl =
          PackageUrl.fromString('fuchsia-pkg://myroot.com/pkg-name');
      expect(packageUrl.host, 'myroot.com');
      expect(packageUrl.packageName, 'pkg-name');
      expect(packageUrl.packageVariant, null);
      expect(packageUrl.hash, null);
      expect(packageUrl.fullComponentName, '');
      expect(packageUrl.componentName, '');
    });
  });

  group('Levenshtein distance', () {
    var levenshtein = Levenshtein();
    test('is correct when one string is empty', () {
      expect(levenshtein.distance('', ''), 0);
      expect(levenshtein.distance('', 'a'), 1);
      expect(levenshtein.distance('a', ''), 1);
    });

    test('handles deletion correctly', () {
      expect(levenshtein.distance('abc', 'ab'), 1);
      expect(levenshtein.distance('abc', 'ac'), 1);
      expect(levenshtein.distance('abc', 'bc'), 1);
    });

    test('handles insertion correctly', () {
      expect(levenshtein.distance('abc', 'abcd'), 1);
      expect(levenshtein.distance('abc', 'abdc'), 1);
      expect(levenshtein.distance('abc', 'adbc'), 1);
      expect(levenshtein.distance('abc', 'dabc'), 1);
    });

    test('handles substitution correctly', () {
      expect(levenshtein.distance('abc', 'abd'), 1);
      expect(levenshtein.distance('abc', 'adc'), 1);
      expect(levenshtein.distance('abc', 'dbc'), 1);
    });

    test('handles combination of all three correctly', () {
      expect(levenshtein.distance('kitten', 'sitting'), 3);
    });
  });

  group('slash splitter', () {
    var sep = '/';
    test('correctly handles null', () {
      expect(chunkOnSlashes(null, null, sep: sep), <String>[]);
      expect(chunkOnSlashes('asdf', null, sep: sep), <String>['asdf']);
      expect(chunkOnSlashes(null, 'asdf', sep: sep), <String>[]);
    });

    test('correctly handles empty strings', () {
      expect(chunkOnSlashes('', '', sep: sep), <String>['']);
      expect(chunkOnSlashes('', 'asdf', sep: sep), <String>['']);
      expect(chunkOnSlashes('asdf', '', sep: sep), <String>['asdf']);

      expect(chunkOnSlashes('', 'asdf/asdf', sep: sep), <String>['']);
      expect(chunkOnSlashes('asdf/asdf', '', sep: sep), <String>['asdf']);
      expect(
          chunkOnSlashes('asdf/ASDF', '', sep: sep), <String>['asdf', 'ASDF']);
    });

    test('correctly handles one slash in needle', () {
      expect(chunkOnSlashes('', 'asdf/asdf', sep: sep), <String>['']);
      expect(chunkOnSlashes('TEST', 'asdf/asdf', sep: sep), <String>['TEST']);
      expect(chunkOnSlashes('abc/abc', 'asdf/asdf', sep: sep),
          <String>['abc/abc']);
      expect(chunkOnSlashes('abc/ABC/xyz', 'asdf/asdf', sep: sep), <String>[
        'abc/ABC',
        'ABC/xyz',
      ]);
      expect(chunkOnSlashes('abc/ABC/xyz/abc', 'asdf/asdf', sep: sep), <String>[
        'abc/ABC',
        'ABC/xyz',
        'xyz/abc',
      ]);
    });

    test('correctly handles more than one slash in needle', () {
      expect(chunkOnSlashes('', 'asdf/asdf/asdf', sep: sep), <String>['']);
      expect(
          chunkOnSlashes('TEST', 'asdf/asdf/asdf', sep: sep), <String>['TEST']);
      expect(chunkOnSlashes('abc/abc', 'asdf/asdf/asdf', sep: sep),
          <String>['abc/abc']);
      expect(
          chunkOnSlashes('abc/ABC/xyz', 'asdf/asdf/asdf', sep: sep), <String>[
        'abc/ABC/xyz',
      ]);
      expect(
          chunkOnSlashes('abc/ABC/xyz/abc', 'asdf/asdf/asdf', sep: sep),
          <String>[
            'abc/ABC/xyz',
            'ABC/xyz/abc',
          ]);
    });

    test('correctly handles leading slashes', () {
      expect(
        chunkOnSlashes('//some/test', 'a/a'),
        <String>['/', '/some', 'some/test'],
      );
    });
  });

  group('fuzzy comparer correctly evaluates', () {
    var fuzzy = FuzzyComparer(threshold: 4);
    test('equals with no slashes', () {
      expect(fuzzy.equals('asdf', 'asdF').isMatch, true);
      expect(fuzzy.equals('asdf', 'asDF').isMatch, true);
      expect(fuzzy.equals('asdf', 'aSDF').isMatch, true);
      expect(fuzzy.equals('asdf', 'ASDF').isMatch, false);
    });
    test('equals with one slash in haystack', () {
      expect(fuzzy.equals('ASDF/asdf', 'asdf').isMatch, false);
      expect(fuzzy.equals('/asdf', 'asdf').isMatch, true);
      expect(fuzzy.equals('/asdf', 'asdF').isMatch, true);
    });
    test('equals with one slash in needle', () {
      expect(fuzzy.equals('asdf', 'asdf/ASDF').isMatch, false);
      expect(fuzzy.equals('asdf/asdF', 'asdf/ASDF').isMatch, true);
      expect(fuzzy.equals('asdf/asdf', 'asdf/ASDF').isMatch, false);
    });
    test('contains with zero slashes in the needle', () {
      expect(fuzzy.contains('xyz/ASDF/XYZ', 'asdf').isMatch, false);
      expect(fuzzy.contains('xyz/ASDF/abc', 'asdf').isMatch,
          true); // abc -> asdf == 3
      expect(fuzzy.contains('xyz/aSDF/abc', 'asdf').isMatch, true);
      expect(fuzzy.contains('xyz/asDF/abc', 'asdf').isMatch, true);
      expect(fuzzy.contains('xyz/asdF/abc', 'asdf').isMatch, true);
      expect(fuzzy.contains('xyz/asdf/abc', 'asdf').isMatch, true);
    });
    test('contains with one slash in the needle', () {
      expect(fuzzy.contains('abc/asdf/ASDF', 'asdf/ASDF').isMatch, true);
      expect(fuzzy.contains('abc/asdf/aSDF', 'asdf/ASDF').isMatch, true);
      expect(fuzzy.contains('abc/asdf/asDF', 'asdf/ASDF').isMatch, true);
      expect(fuzzy.contains('abc/asdf/asdF', 'asdf/ASDF').isMatch, true);
      expect(fuzzy.contains('abc/asdf/asdf', 'asdf/ASDF').isMatch, false);
    });
    test('contains with two slashes in the needle', () {
      expect(
          fuzzy.contains('abc/asdf/ASDF/xyz', 'asdf/ASDF/xyz').isMatch, true);
      expect(
          fuzzy.contains('abc/asdf/aSDF/xyZ', 'asdf/ASDF/xyz').isMatch, true);
      expect(fuzzy.contains('abc/asdf/asdf', 'asdf/ASDF/xyz').isMatch, false);
      expect(fuzzy.contains('abc/asdf', 'asdf/ASDF/xyz').isMatch, false);
      expect(fuzzy.contains('abc', 'asdf/ASDF/xyz').isMatch, false);
      expect(fuzzy.contains('abc/abc/abc', 'asdf/ASDF/xyz').isMatch, false);
      expect(fuzzy.contains('asdf/ASDF/xyz', 'asdf/ASDF/xyz').isMatch, true);
      expect(fuzzy.contains('asdf/ASDF/XYZ', 'asdf/ASDF/xyz').isMatch, true);
    });
    test('endsWith with zero slashes in the needle', () {
      expect(fuzzy.endsWith('asdf/ABC', 'asdf').isMatch, false);
      expect(fuzzy.endsWith('xyz/asdf', 'asdf').isMatch, true);
      expect(fuzzy.endsWith('xyz/aSDF', 'asdf').isMatch, true);
      expect(fuzzy.endsWith('xyz/asdf', 'asdf').isMatch, true);
    });
    test('endsWith with more than 1 slash in the needle', () {
      expect(fuzzy.endsWith('asdf/ABC', 'asdf/ABC').isMatch, true);
      expect(fuzzy.endsWith('asdf/aaabc', 'asdf/ABC').isMatch, false);
      expect(fuzzy.endsWith('asdf/abc', 'asdf/ABC').isMatch, true);
      expect(fuzzy.endsWith('asdf/aBC', 'asdf/ABC').isMatch, true);
      expect(fuzzy.endsWith('xyz/asdf/ABC', 'asdf/ABC').isMatch, true);
      expect(fuzzy.endsWith('xyz/asdf/aaabc', 'asdf/ABC').isMatch, false);
      expect(fuzzy.endsWith('xyz/asdf/abc', 'asdf/ABC').isMatch, true);
      expect(fuzzy.endsWith('xyz/asdf/aBC', 'asdf/ABC').isMatch, true);
      expect(fuzzy.endsWith('asdf/ABC/xyz', 'asdf/ABC').isMatch, false);
      expect(fuzzy.endsWith('asdf/aaabc/xyz', 'asdf/ABC').isMatch, false);
      expect(fuzzy.endsWith('asdf/abc/xyz', 'asdf/ABC').isMatch, false);
      expect(fuzzy.endsWith('asdf/aBC/xyz', 'asdf/ABC').isMatch, false);
    });
    test('startsWith with zero slashes in the needle', () {
      expect(fuzzy.startsWith('asdf/ABC', 'asdf').isMatch, true);
      expect(fuzzy.startsWith('xyz/asdf', 'asdf').isMatch, false);
      expect(fuzzy.startsWith('aSDF/xyz', 'asdf').isMatch, true);
      expect(fuzzy.startsWith('asdf/xyz', 'asdf').isMatch, true);
    });
    test('startsWith with more than 1 slash in the needle', () {
      expect(fuzzy.startsWith('asdf/ABC', 'asdf/ABC').isMatch, true);
      expect(fuzzy.startsWith('asdf/aaabc', 'asdf/ABC').isMatch, false);
      expect(fuzzy.startsWith('asdf/abc', 'asdf/ABC').isMatch, true);
      expect(fuzzy.startsWith('asdf/aBC', 'asdf/ABC').isMatch, true);
      expect(fuzzy.startsWith('xyz/asdf/ABC', 'asdf/ABC').isMatch, false);
      expect(fuzzy.startsWith('xyz/asdf/aaabc', 'asdf/ABC').isMatch, false);
      expect(fuzzy.startsWith('xyz/asdf/abc', 'asdf/ABC').isMatch, false);
      expect(fuzzy.startsWith('xyz/asdf/aBC', 'asdf/ABC').isMatch, false);
      expect(fuzzy.startsWith('asdf/ABC/xyz', 'asdf/ABC').isMatch, true);
      expect(fuzzy.startsWith('asdf/aaabc/xyz', 'asdf/ABC').isMatch, false);
      expect(fuzzy.startsWith('asdf/abc/xyz', 'asdf/ABC').isMatch, true);
      expect(fuzzy.startsWith('asdf/aBC/xyz', 'asdf/ABC').isMatch, true);
    });

    test('when needle has bookend slashes', () {
      // The Levenshtein distance of abc -> ABC is 3, which is the maximum
      // allowed given our threshold of 4. This tests verifies that the
      // trailing slash in our needle does not ruin results.
      expect(fuzzy.endsWith('abc/asdf/ABC', 'asdf/abc/').isMatch, true);
      expect(fuzzy.startsWith('asdf/ABC', '/asdf/abc/').isMatch, true);
    });
  });

  group('confidence computed correctly', () {
    test('with threshold of 5', () {
      var comparer = FuzzyComparer(threshold: 5);
      expect(comparer.computeConfidence(1), 0.8);
      expect(comparer.computeConfidence(2), 0.6);
      expect(comparer.computeConfidence(3), 0.4);
      expect(comparer.computeConfidence(4), 0.2);
      expect(comparer.computeConfidence(5), 0);
    });
  });
  group('getMapPath works with', () {
    Map<String, dynamic> data = {
      'top': 'level',
      'nested': {
        'data': 'is cool too',
      },
      'numbers': {
        'one': 1,
        'two': '2',
      },
      'true': true,
      'false': false,
      'list': [
        {'key': 'value'},
        {'KEY': 'VALUE'},
      ],
      'listWithLists': [
        1,
        [2, 3],
      ],
    };
    test('too many keys', () {
      expect(
        // `top` key exists, but `extra` and `keys` cannot be satisfied
        () => getMapPath(data, ['top', 'extra', 'keys']),
        throwsA(TypeMatcher<BadMapPathException>()),
      );
    });
    test('lists', () {
      expect(getMapPath(data, ['list', 1, 'KEY']), 'VALUE');
    });
    test('listsWithLists', () {
      expect(getMapPath(data, ['listWithLists', 1, 1]), 3);
    });
    test('listsWithLists that ends before terminal node', () {
      expect(getMapPath<List<int>>(data, ['listWithLists', 1]), <int>[2, 3]);
    });
    test('returning whole lists', () {
      expect(getMapPath(data, ['list']), [
        {'key': 'value'},
        {'KEY': 'VALUE'},
      ]);
    });
    test(
      'top-level children',
      () => expect(getMapPath<String>(data, ['top']), 'level'),
    );
    test(
      'nested children',
      () => expect(getMapPath<String>(data, ['nested', 'data']), 'is cool too'),
    );
    test(
      'missing children',
      () => expect(getMapPath<String>(data, ['missing key']), null),
    );
    test(
      'partially correct paths',
      () => expect(getMapPath<String>(data, ['nested', 'missing key']), null),
    );
    test(
      'return types honored',
      () {
        expect(getMapPath<int>(data, ['numbers', 'one']), 1);
        expect(
            getMapPath<int>(data, ['numbers', 'two'],
                // (this lambda is actually necessary because `parse` takes other
                //  optional parameters which break type safety if applied to
                //  `caster`)
                // ignore: unnecessary_lambdas
                caster: (val) => int.parse(val)),
            2);
      },
    );
    test(
      'when T is redundant',
      () {
        expect(
            getMapPath<int>(data, ['numbers', 'one'],
                // (this lambda is actually necessary because `parse` takes other
                //  optional parameters which break type safety if applied to
                //  `caster`)
                // ignore: unnecessary_lambdas
                caster: (val) => int.parse(val)),
            1);
      },
    );
    test(
        'when T == bool', () => expect(getMapPath<bool>(data, ['true']), true));
    test('no input', () => expect(getMapPath(null, ['asdf']), null));
  });
}