import 'dart:convert';
import 'dart:io';
import 'dart:typed_data';
import 'package:archive/archive.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:sm_mobile/services/editor/inspect.dart';

const certificate = '''
-----BEGIN CERTIFICATE-----
MIIBoDCCAUegAwIBAgIUCsiMZ6pteLpL9u3ZNNGzcZRCYAUwCgYIKoZIzj0EAwIw
JjEQMA4GA1UEAwwHc20udGVzdDESMBAGA1UECgwJQ0gtSiBUZXN0MB4XDTI2MTAx
NjE4NTAxN1oXDTM2MTAxMzE4NTAxN1owJjEQMA4GA1UEAwwHc20udGVzdDESMBAG
A1UECgwJQ0gtSiBUZXN0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE96mUBHiX
k7KFksidjIQFJtUBr7HcqXByj4zNwIOo47YBmhqN82FrKlbO36xEHXQCAioa7h1c
ug3z3gGbz/urwqNTMFEwHQYDVR0OBBYEFHYRtuJAiNKJdsI/2t9y3n0tFC5ZMB8G
A1UdIwQYMBaAFHYRtuJAiNKJdsI/2t9y3n0tFC5ZMA8GA1UdEwEB/wQFMAMBAf8w
CgYIKoZIzj0EAwIDRwAwRAIgKu6R8/+wr47TXoybyKVJr4cFsN0XrS0EK0ck9nRZ
+RMCIAbzv9d1fkFBne3y8pyB1o11qR3dje9chc5S+0szDmuF
-----END CERTIFICATE-----
''';

void main() {
  test('ZIP, TAR.GZ and GZIP are listed without extracting', () {
    final a = Archive()
      ..addFile(ArchiveFile.bytes('etc/app.conf', utf8.encode('x=1\n')))
      ..addFile(ArchiveFile.bytes('README', utf8.encode('hello')));
    final zip = Uint8List.fromList(ZipEncoder().encodeBytes(a));
    final listing = listArchive('a.zip', zip);
    expect(listing.format, 'ZIP');
    expect(listing.entries.map((e) => e.name), ['etc/app.conf', 'README']);
    expect(listing.entries.first.size, 4);
    final tgz = Uint8List.fromList(gzip.encode(TarEncoder().encodeBytes(a)));
    final t = listArchive('a.tar.gz', tgz);
    expect(t.format, 'TAR.GZ');
    expect(t.entries.map((e) => e.name), contains('README'));
    final gz = listArchive(
      'log.txt.gz',
      Uint8List.fromList(gzip.encode(utf8.encode('abc'))),
    );
    expect(
      (gz.format, gz.entries.single.name, gz.entries.single.size),
      ('GZIP', 'log.txt', 3),
    );
    expect(
      () => listArchive(
        'x.7z',
        Uint8List.fromList([0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c]),
      ),
      throwsA(isA<ArchiveUnsupported>()),
    );
  });

  test('certificate details; private keys are only reported', () async {
    final items = await inspectCrypto(
      Uint8List.fromList(
        utf8.encode(
          '$certificate\n-----BEGIN PRIVATE KEY-----\nAAAA\n-----END PRIVATE KEY-----\n',
        ),
      ),
    );
    final cert = items.firstWhere((i) => i.type == 'X.509 certificate');
    expect(cert.fields['subject'], 'CN=sm.test, O=CH-J Test');
    expect(cert.fields['publicKey'], 'EC');
    expect(
      cert.fields['sha256'],
      'FD:9F:7B:E3:2A:9A:F1:CC:E9:B7:92:18:36:5A:50:1A:53:59:3F:55:89:2F:63:10:F9:76:5E:DC:8C:A4:2F:30',
    );
    expect(cert.fields['expired'], 'no');
    final key = items.firstWhere((i) => i.secret);
    expect(key.type, 'PRIVATE KEY');
    expect(key.fields, isEmpty);
  });

  test('OpenSSH public key fingerprint matches ssh-keygen', () async {
    final dir = await Directory.systemTemp.createTemp('sm-key-');
    try {
      await Process.run('ssh-keygen', [
        '-q',
        '-t',
        'ed25519',
        '-N',
        '',
        '-C',
        'me@test',
        '-f',
        '${dir.path}/k',
      ]);
      final pub = File('${dir.path}/k.pub').readAsBytesSync();
      final expected = (await Process.run('ssh-keygen', [
        '-lf',
        '${dir.path}/k.pub',
      ])).stdout.toString().split(' ')[1];
      final item = (await inspectCrypto(pub)).single;
      expect(item.fields['sha256'], expected);
      expect(item.fields['comment'], 'me@test');
    } finally {
      await dir.delete(recursive: true);
    }
  });

  test('notebook cells with text output', () {
    final cells = parseNotebook(
      jsonEncode({
        'cells': [
          {
            'cell_type': 'markdown',
            'source': ['# Title'],
          },
          {
            'cell_type': 'code',
            'source': 'print(1)',
            'outputs': [
              {
                'output_type': 'stream',
                'text': ['1\n'],
              },
            ],
          },
        ],
      }),
    );
    expect(cells.map((c) => c.type), ['markdown', 'code']);
    expect(cells[1].outputs.single, '1\n');
  });
}