// Copyright (c) 2020, 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:io';

import 'package:args/args.dart';
import 'package:dds/dds.dart';
import 'package:path/path.dart';

import '../core.dart';
import '../experiments.dart';
import '../sdk.dart';
import '../utils.dart';

class RunCommand extends DartdevCommand<int> {
  @override
  final ArgParser argParser = ArgParser.allowAnything();

  @override
  final bool verbose;

  RunCommand({this.verbose = false}) : super('run', '''
Run a Dart file.''');

  @override
  String get invocation => '${super.invocation} <dart file | package target>';

  @override
  void printUsage() {
    // Override [printUsage] for invocations of 'dart help run' which won't
    // execute [run] below.  Without this, the 'dart help run' reports the
    // command pub with no commands or flags.
    final command = sdk.dart;
    final args = [
      '--disable-dart-dev',
      '--help',
      if (verbose) '--verbose',
    ];

    log.trace('$command ${args.first}');

    // Call 'dart --help'
    // Process.runSync(..) is used since [printUsage] is not an async method,
    // and we want to guarantee that the result (the help text for the console)
    // is printed before command exits.
    final result = Process.runSync(command, args);
    if (result.stderr.isNotEmpty) {
      stderr.write(result.stderr);
    }
    if (result.stdout.isNotEmpty) {
      stdout.write(result.stdout);
    }
  }

  @override
  FutureOr<int> run() async {
    // The command line arguments after 'run'
    var args = argResults.arguments.toList();

    var argsContainFileOrHelp = false;
    for (var arg in args) {
      // The arg.contains('.') matches a file name pattern, i.e. some 'foo.dart'
      if (arg.contains('.') ||
          arg == '--help' ||
          arg == '-h' ||
          arg == 'help') {
        argsContainFileOrHelp = true;
        break;
      }
    }

    final cwd = Directory.current;

    if (!argsContainFileOrHelp && cwd.existsSync()) {
      var foundImplicitFileToRun = false;
      var cwdName = cwd.name;
      for (var entity in cwd.listSync(followLinks: false)) {
        if (entity is Directory && entity.name == 'bin') {
          var filesInBin =
              entity.listSync(followLinks: false).whereType<File>();

          // Search for a dart file in bin/ with the pattern foo/bin/foo.dart
          for (var fileInBin in filesInBin) {
            if (fileInBin.isDartFile && fileInBin.name == '$cwdName.dart') {
              args.add('bin/${fileInBin.name}');
              foundImplicitFileToRun = true;
              break;
            }
          }
          // break here, no actions taken on any entities that are not bin/
          break;
        }
      }

      if (!foundImplicitFileToRun) {
        log.stderr(
          'Could not find the implicit file to run: '
          'bin$separator$cwdName.dart.',
        );
      }
    }

    // Pass any --enable-experiment options along.
    if (args.isNotEmpty && wereExperimentsSpecified) {
      List<String> experimentIds = specifiedExperiments;
      args = [
        '--$experimentFlagName=${experimentIds.join(',')}',
        ...args,
      ];
    }

    // If the user wants to start a debugging session we need to do some extra
    // work and spawn a Dart Development Service (DDS) instance. DDS is a VM
    // service intermediary which implements the VM service protocol and
    // provides non-VM specific extensions (e.g., log caching, client
    // synchronization).
    if (args.any((element) =>
        element.startsWith('--observe') ||
        element.startsWith('--enable-vm-service'))) {
      return await _DebuggingSession(this, args).start();
    } else {
      // Starting in ProcessStartMode.inheritStdio mode means the child process
      // can detect support for ansi chars.
      final process = await Process.start(
          sdk.dart, ['--disable-dart-dev', ...args],
          mode: ProcessStartMode.inheritStdio);
      return process.exitCode;
    }
  }
}

class _DebuggingSession {
  _DebuggingSession(this._runCommand, List<String> args)
      : _args = args.toList() {
    // Process flags that are meant to configure the VM service HTTP server or
    // dump VM service connection information to a file. Since the VM service
    // clients won't actually be connecting directly to the service, we'll make
    // DDS appear as if it is the actual VM service.
    for (final arg in _args) {
      final isObserve = arg.startsWith('--observe');
      if (isObserve || arg.startsWith('--enable-vm-service')) {
        if (isObserve) {
          _observe = true;
        }
        if (arg.contains('=') || arg.contains(':')) {
          // These flags can be provided by the embedder so we need to check for
          // both `=` and `:` separators.
          final observatoryBindInfo =
              (arg.contains('=') ? arg.split('=') : arg.split(':'))[1]
                  .split('/');
          _port = int.tryParse(observatoryBindInfo.first) ?? 0;
          if (observatoryBindInfo.length > 1) {
            try {
              _bindAddress = Uri.http(observatoryBindInfo[1], '');
            } on FormatException {
              // TODO(bkonyi): log invalid parse? The VM service just ignores
              // bad input flags.
              // Ignore.
            }
          }
        }
      } else if (arg.startsWith('--write-service-info=')) {
        try {
          final split = arg.split('=');
          if (split[1].isNotEmpty) {
            _serviceInfoUri = Uri.parse(split[1]);
          } else {
            _runCommand.usageException(
                'Invalid URI argument to --write-service-info: "${split[1]}"');
          }
        } on FormatException {
          // TODO(bkonyi): log invalid parse? The VM service just ignores bad
          // input flags.
          // Ignore.
        }
      } else if (arg == '--disable-service-auth-codes') {
        _disableServiceAuthCodes = true;
      }
    }

    // Strip --observe and --write-service-info from the arguments as we'll be
    // providing our own.
    _args.removeWhere(
      (arg) =>
          arg.startsWith('--observe') ||
          arg.startsWith('--enable-vm-service') ||
          arg.startsWith('--write-service-info'),
    );
  }

  FutureOr<int> start() async {
    // Output the service information for the target process to a temporary
    // file so we can avoid scraping stderr for the service URI.
    final serviceInfoDir =
        await Directory.systemTemp.createTemp('dart_service');
    final serviceInfoUri = serviceInfoDir.uri.resolve('service_info.json');
    final serviceInfoFile = await File.fromUri(serviceInfoUri).create();

    // Start using ProcessStartMode.normal and forward stdio manually as we
    // need to filter the true VM service URI and replace it with the DDS URI.
    _process = await Process.start(
      sdk.dart,
      [
        '--disable-dart-dev',
        // We don't care which port the VM service binds to.
        _observe ? '--observe=0' : '--enable-vm-service=0',
        '--write-service-info=$serviceInfoUri',
        ..._args,
      ],
    );
    _forwardAndFilterStdio(_process);

    // Start DDS once the VM service has finished starting up.
    await Future.any([
      _waitForRemoteServiceUri(serviceInfoFile).then(_startDDS),
      _process.exitCode,
    ]);

    return _process.exitCode.then((exitCode) async {
      // Shutdown DDS if it was started and wait for the process' stdio streams
      // to close so we don't truncate program output.
      await Future.wait([
        if (_dds != null) _dds.shutdown(),
        _stderrDone,
        _stdoutDone,
      ]);
      return exitCode;
    });
  }

  Future<Uri> _waitForRemoteServiceUri(File serviceInfoFile) async {
    // Wait for VM service to write its connection info to disk.
    while (await serviceInfoFile.length() <= 5) {
      await Future.delayed(const Duration(milliseconds: 50));
    }
    final serviceInfoStr = await serviceInfoFile.readAsString();
    return Uri.parse(jsonDecode(serviceInfoStr)['uri']);
  }

  Future<void> _startDDS(Uri remoteVmServiceUri) async {
    _dds = await DartDevelopmentService.startDartDevelopmentService(
      remoteVmServiceUri,
      serviceUri: _bindAddress.replace(port: _port),
      enableAuthCodes: !_disableServiceAuthCodes,
    );
    if (_serviceInfoUri != null) {
      // Output the service connection information.
      await File.fromUri(_serviceInfoUri).writeAsString(
        json.encode({
          'uri': _dds.uri.toString(),
        }),
      );
    }
    _ddsCompleter.complete();
  }

  void _forwardAndFilterStdio(Process process) {
    // Since VM service clients cannot connect to the real VM service once DDS
    // has started, replace all instances of the real VM service's URI with the
    // DDS URI. Clients should only know that they are connected to DDS if they
    // explicitly request that information via the protocol.
    String filterObservatoryUri(String msg) {
      if (_dds == null) {
        return msg;
      }
      if (msg.contains('Observatory listening on') ||
          msg.contains('Connect to Observatory at')) {
        // Search for the VM service URI in the message and replace it.
        msg = msg.replaceFirst(
          RegExp(r'https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.'
              r'[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)'),
          _dds.uri.toString(),
        );
      }
      return msg;
    }

    // Wait for DDS to start before handling any stdio events from the target
    // to ensure we don't let any unfiltered messages slip through.
    // TODO(bkonyi): consider filtering on bytes rather than decoding the UTF8.
    _stderrDone = process.stderr
        .transform(const Utf8Decoder(allowMalformed: true))
        .listen((event) async {
      await _waitForDDS();
      stderr.write(filterObservatoryUri(event));
    }).asFuture();

    _stdoutDone = process.stdout
        .transform(const Utf8Decoder(allowMalformed: true))
        .listen((event) async {
      await _waitForDDS();
      stdout.write(filterObservatoryUri(event));
    }).asFuture();

    stdin.listen(
      (event) async {
        await _waitForDDS();
        process.stdin.add(event);
      },
    );
  }

  Future<void> _waitForDDS() async {
    if (!_ddsCompleter.isCompleted) {
      // No need to wait for DDS if the process has already exited.
      await Future.any([
        _ddsCompleter.future,
        _process.exitCode,
      ]);
    }
  }

  Uri _bindAddress = Uri.http('127.0.0.1', '');
  bool _disableServiceAuthCodes = false;
  DartDevelopmentService _dds;
  bool _observe = false;
  int _port = 8181;
  Process _process;
  Uri _serviceInfoUri;
  Future _stderrDone;
  Future _stdoutDone;

  final List<String> _args;
  final Completer<void> _ddsCompleter = Completer();
  final RunCommand _runCommand;
}