// Copyright 2013 The Flutter 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:file/file.dart';
import 'package:file/local.dart';
import 'package:meta/meta.dart';
import 'package:path/path.dart' as path;

import 'command_line.dart';
import 'operation_result.dart';
import 'ssh_key_manager.dart';

/// A wrapper for running Fuchsia images on the Android Emulator (AEMU).
class Emulator {
  /// Creates a new wrapper for the `emu` tool.
  Emulator({
    @required this.aemuPath,
    @required this.fuchsiaImagePath,
    @required this.fuchsiaSdkPath,
    this.fs = const LocalFileSystem(),
    this.cli = const CommandLine(),
    @required this.qemuKernelPath,
    @required this.sshKeyManager,
    @required this.zbiPath,
  })  : assert(cli != null),
        assert(fs != null);

  /// The path to the AEMU executable on disk.
  final String aemuPath;

  /// Fuchsia image to load into the emulator.
  final String fuchsiaImagePath;

  /// The path to the Fuchsia SDK that contains the tools `fvm` and `zbi`.
  final String fuchsiaSdkPath;

  /// The QEMU kernel image to use. This is only bundled in Fuchsia QEMU images.
  final String qemuKernelPath;

  /// The Fuchsia bootloader image.
  final String zbiPath;

  /// Location of `fvm` in [fuchsiaSdkPath].
  @visibleForTesting
  final String fvmToolPath = 'sdk/tools/fvm';

  /// Location of `zbi` in [fuchsiaSdkPath].
  @visibleForTesting
  final String zbiToolPath = 'sdk/tools/zbi';

  /// Default AEMU window size to be launched.
  @visibleForTesting
  final String defaultWindowSize = '1280x800';

  /// Flag to pass to AEMU to run in headless mode.
  @visibleForTesting
  final String aemuHeadlessFlag = '-no-window';

  /// [SshKeyManager] for creating `authorized_keys` to access emulator.
  final SshKeyManager sshKeyManager;

  /// The [FileSystem] to use when running the `emu` tool.
  final FileSystem fs;

  /// The [CommandLine] wrapper for interacting with the current shell.
  final CommandLine cli;

  /// FVM extended image of [fuchsiaImagePath] for running on FEMU.
  @visibleForTesting
  String fvmImagePath;

  /// [zbiPath] that is accessible with SSH using [sshPath] keys.
  @visibleForTesting
  String signedZbiPath;

  /// Update given Fuchsia assets to make them compatible with FEMU.
  ///
  /// 1. Ensure required assets exist.
  /// 2. Create FVM image for running with FEMU.
  /// 3. Sign boot image for host access to the guest FEMU instance.
  Future<void> prepareEnvironment() async {
    assert(fs.isFileSync(fuchsiaImagePath));
    assert(fs.isFileSync(zbiPath));
    assert(fs.isFileSync(qemuKernelPath));

    final String tmpPath = fs.systemTempDirectory.createTempSync().path;
    fvmImagePath = '$tmpPath/fvm.blk';
    signedZbiPath = '$tmpPath/fuchsia-ssh.zbi';

    await _prepareFvmImage(fuchsiaImagePath, fvmImagePath);
    await _signBootImage(zbiPath, signedZbiPath);
  }

  /// Double the size of [fuchsiaImagePath] to make space for the emulator
  /// to write back to it.
  Future<void> _prepareFvmImage(String fuchsiaImagePath, String fvmPath,
      {String fvmExecutable}) async {
    fvmExecutable ??= path.join(fuchsiaSdkPath, fvmToolPath);

    await cli.run(<String>['cp', fuchsiaImagePath, fvmPath]);

    /// [fvmTool] and FEMU need write access to [fvmPath].
    await cli.run(<String>['chmod', 'u+w', fvmPath]);

    // Calculate new size by doubling the current size
    final File fvmFile = fs.file(fvmPath)..createSync();
    final int newSize = fvmFile.lengthSync() * 2;

    await cli.run(
        <String>[fvmExecutable, fvmPath, 'extend', '--length', '$newSize']);
  }

  /// Signed [zbiPath] using [zbiExecutable] with [publicKeyPath] to
  /// create a bootloader image that is accessible from the host.
  Future<void> _signBootImage(String zbiPath, String signedZbiPath,
      {String zbiExecutable}) async {
    zbiExecutable ??= path.join(fuchsiaSdkPath, zbiToolPath);

    await sshKeyManager.createKeys();

    /// Ensure `zbi` is able to find the ssh keys by giving the full path.
    final File authorizedKeysAbsolute =
        fs.file('.ssh/authorized_keys').absolute;

    final List<String> zbiCommand = <String>[
      zbiExecutable,
      '--compressed=zstd',
      '-o',
      signedZbiPath,
      zbiPath,
      '-e',
      'data/ssh/authorized_keys=${authorizedKeysAbsolute.path}'
    ];
    await cli.run(zbiCommand);
  }

  /// Launch AEMU with [fvmImagePath], [signedZbiPath], and [qemuKernelPath].
  ///
  /// [prepareEnvironment] must have been called before starting the emulator.
  ///
  /// If [headless] is true, AEMU will run without a graphical window. Infra
  /// will run AEMU in headless mode.
  ///
  /// [windowSize] is what AEMU will set its window size to. Defaults to
  /// [defaultWindowSize]. Expected to be in the format of "WIDTHxHEIGHT".
  Future<OperationResult> start(
      {bool headless = false, String windowSize}) async {
    assert(fvmImagePath != null && fs.isFileSync(fvmImagePath));
    assert(signedZbiPath != null && fs.isFileSync(signedZbiPath));

    final List<String> aemuCommand = <String>[
      aemuPath,
      '-feature',
      'VirtioInput,RefCountPipe,KVM,GLDirectMem,Vulkan',
      '-window-size',
      windowSize ?? defaultWindowSize,
      '-gpu',
      'swiftshader_indirect',
      if (headless) aemuHeadlessFlag,

      /// Anything after -fuchsia flag will be passed to QEMU
      '-fuchsia',
      '-kernel', qemuKernelPath,
      '-initrd', signedZbiPath,
      '-m', '2048',
      '-serial', 'stdio',
      '-vga', 'none',
      '-device', 'virtio-keyboard-pci',
      '-device', 'virtio_input_multi_touch_pci_1',
      '-smp', '4,threads=2',
      '-machine', 'q35',
      '-device', 'isa-debug-exit,iobase=0xf4,iosize=0x04',
      // TODO(chillers): Add hardware acceleration option to configure this.
      '-enable-kvm',
      '-cpu', 'host,migratable=no,+invtsc',
      '-netdev', 'type=tap,ifname=qemu,script=no,downscript=no,id=net0',
      '-device', 'e1000,netdev=net0,mac=52:54:00:63:5e:7a',
      '-drive', 'file=$fvmImagePath,format=raw,if=none,id=vdisk',
      '-device', 'virtio-blk-pci,drive=vdisk',
      '-append',
      // TODO(chillers): Generate entropy mixin.
      "'TERM=xterm-256color kernel.serial=legacy kernel.entropy-mixin=660486b6b20b4ace3fb5c81b0002abf5271289185c6a5620707606c55b377562 kernel.halt-on-panic=true'",
    ];

    await cli.start(aemuCommand);

    return OperationResult.success();
  }
}