// Copyright 2019 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 'dart:convert';
import 'dart:io';
import 'dart:typed_data';

import 'package:sl4f/sl4f.dart';
import 'package:test/test.dart';

void main(List<String> args) {
  HttpServer fakeServer;
  Sl4f sl4f;

  setUp(() async {
    fakeServer = await HttpServer.bind('127.0.0.1', 18080);
    sl4f = Sl4f('127.0.0.1', null, 18080);
  });

  tearDown(() async {
    await fakeServer.close();
  });

  group(FactoryStore, () {
    test('listFiles makes request and receives file list', () async {
      const expectedAlphaFiles = [
        'alpha_file1',
        'some/dir/alpha_file2',
        'alpha_file3',
        'another/dir/alpha_file4'
      ];
      const expectedCastFiles = ['cast_file1', 'some/dir/cast_file2'];
      const expectedMiscFiles = ['misc_file1', 'some/dir/misc_file2'];
      const expectedPlayreadyFiles = [
        'playready_file1',
        'some/dir/playready_file2'
      ];
      const expectedWeaveFiles = [
        'weave_file1',
        'some/dir/weave_file2',
        'weave_file3',
        'another/dir/weave_file4'
      ];
      const expectedWidevineFiles = [
        'widevine_file1',
        'some/dir/widevine_file2'
      ];

      final returnedFiles = {
        'alpha': expectedAlphaFiles,
        'cast': expectedCastFiles,
        'misc': expectedMiscFiles,
        'playready': expectedPlayreadyFiles,
        'weave': expectedWeaveFiles,
        'widevine': expectedWidevineFiles
      };

      void handler(HttpRequest req) async {
        final body = jsonDecode(await utf8.decoder.bind(req).join());
        expect(body['method'], 'factory_store_facade.ListFiles');
        final params = body['params'];
        final files = returnedFiles[params['provider']];
        req.response.write(
            jsonEncode({'id': body['id'], 'result': files, 'error': null}));
        await req.response.close();
      }

      fakeServer.listen(handler);

      final sl4fFactory = FactoryStore(sl4f);
      final List<String> alphaFiles =
          await sl4fFactory.listFiles(FactoryStoreProvider.alpha);
      final List<String> castFiles =
          await sl4fFactory.listFiles(FactoryStoreProvider.cast);
      final List<String> miscFiles =
          await sl4fFactory.listFiles(FactoryStoreProvider.misc);
      final List<String> playreadyFiles =
          await sl4fFactory.listFiles(FactoryStoreProvider.playready);
      final List<String> weaveFiles =
          await sl4fFactory.listFiles(FactoryStoreProvider.weave);
      final List<String> widevineFiles =
          await sl4fFactory.listFiles(FactoryStoreProvider.widevine);

      expect(alphaFiles, containsAllInOrder(expectedAlphaFiles));
      expect(castFiles, containsAllInOrder(expectedCastFiles));
      expect(miscFiles, containsAllInOrder(expectedMiscFiles));
      expect(playreadyFiles, containsAllInOrder(expectedPlayreadyFiles));
      expect(weaveFiles, containsAllInOrder(expectedWeaveFiles));
      expect(widevineFiles, containsAllInOrder(expectedWidevineFiles));
    });

    test('readFile makes request and receives file contents', () async {
      const alphaFilename = 'alpha_file1';
      final expectedAlphaFileContents =
          base64Encode(utf8.encode('alpha_file1'));
      const castFilename = 'cast_file1';
      final expectedCastFileContents = base64Encode(utf8.encode('cast_file1'));
      const miscFilename = 'misc_file1';
      final expectedMiscFileContents = base64Encode(utf8.encode('misc_file1'));
      const playreadyFilename = 'playready_file1';
      final expectedPlayreadyFileContents =
          base64Encode(utf8.encode('playready_file1'));
      const weaveFilename = 'weave_file1';
      final expectedWeaveFileContents =
          base64Encode(utf8.encode('weave_file1'));
      const widevineFilename = 'widevine_file1';
      final expectedWidevineFileContents =
          base64Encode(utf8.encode('widevine_file1'));

      final returnedFileContents = {
        'alpha': {alphaFilename: expectedAlphaFileContents},
        'cast': {castFilename: expectedCastFileContents},
        'misc': {miscFilename: expectedMiscFileContents},
        'playready': {playreadyFilename: expectedPlayreadyFileContents},
        'weave': {weaveFilename: expectedWeaveFileContents},
        'widevine': {widevineFilename: expectedWidevineFileContents}
      };

      void handler(HttpRequest req) async {
        final body = jsonDecode(await utf8.decoder.bind(req).join());
        expect(body['method'], 'factory_store_facade.ReadFile');

        final params = body['params'];
        final provider = params['provider'];
        final filename = params['filename'];

        final fileContents = returnedFileContents[provider][filename];
        req.response.write(jsonEncode(
            {'id': body['id'], 'result': fileContents, 'error': null}));
        await req.response.close();
      }

      fakeServer.listen(handler);

      final sl4fFactory = FactoryStore(sl4f);
      final Uint8List alphaFiles =
          await sl4fFactory.readFile(FactoryStoreProvider.alpha, alphaFilename);
      final Uint8List castFiles =
          await sl4fFactory.readFile(FactoryStoreProvider.cast, castFilename);
      final Uint8List miscFiles =
          await sl4fFactory.readFile(FactoryStoreProvider.misc, miscFilename);
      final Uint8List playreadyFiles = await sl4fFactory.readFile(
          FactoryStoreProvider.playready, playreadyFilename);
      final Uint8List weaveFiles =
          await sl4fFactory.readFile(FactoryStoreProvider.weave, weaveFilename);
      final Uint8List widevineFiles = await sl4fFactory.readFile(
          FactoryStoreProvider.widevine, widevineFilename);

      expect(alphaFiles, base64Decode(expectedAlphaFileContents));
      expect(castFiles, base64Decode(expectedCastFileContents));
      expect(miscFiles, base64Decode(expectedMiscFileContents));
      expect(playreadyFiles, base64Decode(expectedPlayreadyFileContents));
      expect(weaveFiles, base64Decode(expectedWeaveFileContents));
      expect(widevineFiles, base64Decode(expectedWidevineFileContents));
    });
  });
}