// Copyright (c) 2012, 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:async';
import 'dart:convert';
import 'dart:math';

import "package:charcode/ascii.dart";
import "package:crypto/crypto.dart";
import "package:test/test.dart";

void main() {
  group("encoder", () {
    test("for simple inputs", () {
      expect(BASE64.encode([]), equals(''));
      expect(BASE64.encode([$f]), equals('Zg=='));
      expect(BASE64.encode([$f, $o]), equals('Zm8='));
      expect(BASE64.encode([$f, $o, $o]), equals('Zm9v'));
      expect(BASE64.encode([$f, $o, $o, $b]), equals('Zm9vYg=='));
      expect(BASE64.encode([$f, $o, $o, $b, $a]), equals('Zm9vYmE='));
      expect(BASE64.encode([$f, $o, $o, $b, $a, $r]), equals('Zm9vYmFy'));
    });

    test("for inputs with zeroes", () {
      expect(BASE64.encode([0]), equals('AA=='));
      expect(BASE64.encode([0, 0]), equals('AAA='));
      expect(BASE64.encode([0, 0, 0]), equals('AAAA'));
      expect(BASE64.encode([0, 0, 0, 0]), equals('AAAAAA=='));
    });

    test("for a large input with line separators", () {
      expect(
          BASE64.encode(
              UTF8.encode(
                  "Man is distinguished, not only by his reason, but by this "
                  "singular passion from other animals, which is a lust of the "
                  "mind, that by a perseverance of delight in the continued "
                  "and indefatigable generation of knowledge, exceeds the "
                  "short vehemence of any carnal pleasure."),
              addLineSeparator: true),
          equals(
              "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1"
                  "dCBieSB0aGlz\r\n"
              "IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBh"
                  "IGx1c3Qgb2Yg\r\n"
              "dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0"
                  "aGUgY29udGlu\r\n"
              "dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBl"
                  "eGNlZWRzIHRo\r\n"
              "ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4="));
    });

    test("for a large input without line separators", () {
      expect(
          BASE64.encode(
              UTF8.encode(
                  "Man is distinguished, not only by his reason, but by this "
                  "singular passion from other animals, which is a lust of the "
                  "mind, that by a perseverance of delight in the continued "
                  "and indefatigable generation of knowledge, exceeds the "
                  "short vehemence of any carnal pleasure.")),
          equals(
              "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1"
              "dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3"
              "aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFu"
              "Y2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxl"
              "IGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhl"
              "bWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4="));
    });

    test("for chunked input", () {
      expect(_encodeChunked([
        [102, 102],
        [111, 102],
        [
          111, 111, 102, 111, 111, 98, 102, 111, 111, 98, 97, 102, 111, 111,
          98, 97, 114
        ]
      ]), equals("ZmZvZm9vZm9vYmZvb2JhZm9vYmFy"));

      expect(_encodeChunked([[196, 16], [], [158], [196]]), equals("xBCexA=="));
      expect(_encodeChunked([[196, 16], [158, 196], [], []]),
          equals("xBCexA=="));
      expect(_encodeChunked([[196], [], [16], [], [], [158], [], [196]]),
          equals("xBCexA=="));
      expect(_encodeChunked([[196], [], [16], [158, 196], [], []]),
          equals("xBCexA=="));
      expect(_encodeChunked([[], [196], [], [], [16, 158], [], [196]]),
          equals("xBCexA=="));
      expect(_encodeChunked([[], [196], [16, 158, 196], []]),
          equals("xBCexA=="));
      expect(_encodeChunked([[196, 16, 158], [], [], [196]]),
          equals("xBCexA=="));
      expect(_encodeChunked([[196, 16, 158], [], [196], []]),
          equals("xBCexA=="));
      expect(_encodeChunked([[196, 16, 158, 196], [], [], []]),
          equals("xBCexA=="));
    });

    test('with a URL-safe alphabet', () {
      expect(BASE64.encode(BASE64.decode('+/A='), urlSafe: true),
          equals('-_A='));
    });

    test('with a percent-encoded padding character', () {
      expect(BASE64.encode([2, 8], encodePaddingCharacter: true),
          equals('Agg%3D'));
    });

    test('with the old API', () {
      expect(CryptoUtils.bytesToBase64([]), equals(''));
      expect(CryptoUtils.bytesToBase64([$f]), equals('Zg=='));
      expect(CryptoUtils.bytesToBase64([$f, $o]), equals('Zm8='));
      expect(CryptoUtils.bytesToBase64([$f, $o, $o]), equals('Zm9v'));
      expect(CryptoUtils.bytesToBase64([$f, $o, $o, $b]), equals('Zm9vYg=='));
      expect(CryptoUtils.bytesToBase64([$f, $o, $o, $b, $a]),
          equals('Zm9vYmE='));
      expect(CryptoUtils.bytesToBase64([$f, $o, $o, $b, $a, $r]),
          equals('Zm9vYmFy'));
    });
  });

  group("decoder", () {
    test("for simple inputs", () {
      expect(BASE64.decode(''), equals([]));
      expect(BASE64.decode('Zg=='), equals([$f]));
      expect(BASE64.decode('Zm8='), equals([$f, $o]));
      expect(BASE64.decode('Zm9v'), equals([$f, $o, $o]));
      expect(BASE64.decode('Zm9vYg=='), equals([$f, $o, $o, $b]));
      expect(BASE64.decode('Zm9vYmE='), equals([$f, $o, $o, $b, $a]));
      expect(BASE64.decode('Zm9vYmFy'), equals([$f, $o, $o, $b, $a, $r]));
    });

    test("for inputs with zeroes", () {
      expect(BASE64.decode('AA=='), equals([0]));
      expect(BASE64.decode('AAA='), equals([0, 0]));
      expect(BASE64.decode('AAAA'), equals([0, 0, 0]));
      expect(BASE64.decode('AAAAAA=='), equals([0, 0, 0, 0]));
    });

    test("for a large input with line separators", () {
      expect(
          BASE64.decode(
              "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1"
                  "dCBieSB0aGlz\r\n"
              "IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBh"
                  "IGx1c3Qgb2Yg\r\n"
              "dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0"
                  "aGUgY29udGlu\r\n"
              "dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBl"
                  "eGNlZWRzIHRo\r\n"
              "ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4="),
          equals(UTF8.encode(
              "Man is distinguished, not only by his reason, but by this "
              "singular passion from other animals, which is a lust of the "
              "mind, that by a perseverance of delight in the continued and "
              "indefatigable generation of knowledge, exceeds the short "
              "vehemence of any carnal pleasure.")));
    });

    test("for a large input without line separators", () {
      expect(
          BASE64.decode(
              "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1"
              "dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3"
              "aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFu"
              "Y2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxl"
              "IGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhl"
              "bWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4="),
          equals(UTF8.encode(
              "Man is distinguished, not only by his reason, but by this "
              "singular passion from other animals, which is a lust of the "
              "mind, that by a perseverance of delight in the continued and "
              "indefatigable generation of knowledge, exceeds the short "
              "vehemence of any carnal pleasure.")));
    });

    test("for chunked input", () {
      expect(_decodeChunked(['YmFz', 'ZTY', '0I', 'GRlY29kZXI=']), equals([
        98, 97, 115, 101, 54, 52, 32, 100, 101, 99, 111, 100, 101, 114
      ]));
    });

    test("for chunked input containing zeroes", () {
      expect(_decodeChunked(['AAAA', 'AAA=', 'AA==', '']),
          equals([0, 0, 0, 0, 0, 0]));

      expect(_decodeChunked(["A", "", "BCD"]), equals([0, 16, 131]));
      expect(_decodeChunked(["A", "BCD", "", ""]), equals([0, 16, 131]));
      expect(_decodeChunked(["A", "B", "", "", "CD", ""]),
          equals([0, 16, 131]));
      expect(_decodeChunked(["", "A", "BC", "", "D"]), equals([0, 16, 131]));
      expect(_decodeChunked(["", "AB", "C", "", "", "D"]),
          equals([0, 16, 131]));
      expect(_decodeChunked(["AB", "CD", ""]), equals([0, 16, 131]));
      expect(_decodeChunked(["", "ABC", "", "D"]), equals([0, 16, 131]));
      expect(_decodeChunked(["", "ABC", "D", ""]), equals([0, 16, 131]));
      expect(_decodeChunked(["", "", "ABCD", ""]), equals([0, 16, 131]));
      expect(_decodeChunked(["A", "B", "C", "D"]), equals([0, 16, 131]));
      expect(_decodeChunked(["", "A", "B", "C", "D", ""]),
          equals([0, 16, 131]));
      expect(_decodeChunked(["", "A", "B", "", "", "C", "", "D", ""]),
          equals([0, 16, 131]));
    });

    test("for chunked input with encoded padding", () {
      expect(_decodeChunked(['AA%', '3D', '%', '3', 'DEFGZ']),
          equals(BASE64.decode('AA==EFGZ')));
    });

    test('with a URL-safe alphabet', () {
      expect(BASE64.decode('-_A='), equals(BASE64.decode('+/A=')));
    });

    test('with a percent-encoded padding character', () {
      expect(BASE64.decode('Agg%3D'), equals([2, 8]));
    });

    test("with the old API", () {
      expect(CryptoUtils.base64StringToBytes(''), equals([]));
      expect(CryptoUtils.base64StringToBytes('Zg=='), equals([$f]));
      expect(CryptoUtils.base64StringToBytes('Zm8='), equals([$f, $o]));
      expect(CryptoUtils.base64StringToBytes('Zm9v'), equals([$f, $o, $o]));
      expect(CryptoUtils.base64StringToBytes('Zm9vYg=='),
          equals([$f, $o, $o, $b]));
      expect(CryptoUtils.base64StringToBytes('Zm9vYmE='),
          equals([$f, $o, $o, $b, $a]));
      expect(CryptoUtils.base64StringToBytes('Zm9vYmFy'),
          equals([$f, $o, $o, $b, $a, $r]));
    });

    group("rejects", () {
      test("input of the wrong length", () {
        expect(() => BASE64.decode('A'), throwsFormatException);
        expect(() => BASE64.decode('AB'), throwsFormatException);
        expect(() => BASE64.decode('ABz'), throwsFormatException);
        expect(() => BASE64.decode('ABzdE'), throwsFormatException);
        expect(() => BASE64.decode('ABzdEf'), throwsFormatException);
        expect(() => BASE64.decode('ABzdEfg'), throwsFormatException);
      });

      test("input with invalid characters", () {
        expect(() => BASE64.decode('AB~'), throwsFormatException);
      });

      test("chunked input of the wrong length", () {
        expect(() => _decodeChunked(['ABz']), throwsFormatException);
        expect(() => _decodeChunked(['AB', 'Lx', 'z', 'xx']),
            throwsFormatException);
      });

      test("input with the wrong padding", () {
        expect(() => BASE64.decode('A=='), throwsFormatException);
        expect(() => BASE64.decode('AB='), throwsFormatException);
        expect(() => BASE64.decode('ABz=='), throwsFormatException);
        expect(() => BASE64.decode('ABzdE='), throwsFormatException);
      });

      test("input with the wrong encoded padding", () {
        expect(() => BASE64.decode('A%3D%3D'), throwsFormatException);
        expect(() => BASE64.decode('AB%3D'), throwsFormatException);
        expect(() => BASE64.decode('ABz%3D%3D'), throwsFormatException);
        expect(() => BASE64.decode('ABzdE%3D'), throwsFormatException);
      });
    });
  });

  test('successfully round-trips data', () {
    for (var i = 0; i < 10; i++) {
      for (var j = 0; j < 256 - i; j++) {
        var data = new List.filled(i, j);
        expect(BASE64.decode(BASE64.encode(data)), equals(data));
      }
    }
  });
}

/// Performs chunked Base64 decoding of [chunks] and returns the result as a
/// byte array.
List<int> _decodeChunked(Iterable<String> chunks) {
  var bytes;
  var innerSink = new ByteConversionSink.withCallback(
      (result) => bytes = result);
  var sink = BASE64.decoder.startChunkedConversion(innerSink);

  for (var chunk in chunks) {
    sink.add(chunk);
  }
  sink.close();

  return bytes;
}

/// Performs chunked Base64 encoding of [chunks] and returns the result.
String _encodeChunked(Iterable<List<int>> chunks) {
  var string;
  var innerSink = new StringConversionSink.withCallback(
      (result) => string = result);
  var sink = BASE64.encoder.startChunkedConversion(innerSink);

  for (var chunk in chunks) {
    sink.add(chunk);
  }
  sink.close();

  return string;
}