// 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.

/// This library implements [ServerBase], except unlike analysis_server_client's
/// `Server`, [Server] runs the analysis server in an isolate.

import 'dart:async';
import 'dart:convert';
import 'dart:isolate';

import 'package:analysis_server/starter.dart';
import 'package:analysis_server_client/listener/server_listener.dart';
import 'package:analysis_server_client/src/server_base.dart';
import 'package:analysis_server_client/protocol.dart';
import 'package:stream_channel/isolate_channel.dart';

/// Wrap server arguments and communication port into a single parameter
/// for [Isolate.spawn].
class _IsolateParameters {
  final List<String> arguments;
  final SendPort sendPort;

  _IsolateParameters(this.arguments, this.sendPort);
}

/// Manage an analysis_server launched in an isolate.
class Server extends ServerBase {
  /// Server isolate object, or `null` if server hasn't been started yet
  /// or if the server has already been stopped.
  Isolate _isolate;

  /// The [ReceivePort] data subscription via an [IsolateChannel], or `null`
  /// if either [listenToOutput] has not been called or [stop] has been called.
  StreamSubscription<String> _receiveSubscription;

  /// Construct a Server.
  ///
  /// [isolate] and [isolateChannel] are testing-only parameters, allowing
  /// you to bypass start().
  Server(
      {ServerListener listener,
      Isolate isolate,
      IsolateChannel isolateChannel,
      bool stdioPassthrough = false})
      : _isolate = isolate,
        _isolateChannel = isolateChannel,
        super(listener: listener, stdioPassthrough: stdioPassthrough);

  /// Completes when the [_isolate] has exited.
  Completer isolateExited = Completer();

  /// The [IsolateChannel] by which this class communicates with the [_isolate].
  IsolateChannel _isolateChannel;

  /// Force kill the server.  The returned future completes when the isolate
  /// is dead.
  Future<void> kill({String reason = 'none'}) {
    listener?.killingServerProcess(reason);
    final isolate = _isolate;
    final isolateExitedOriginal = isolateExited;
    _isolate = null;
    isolateExited = null;
    isolate.kill(priority: Isolate.immediate);
    return isolateExitedOriginal.future;
  }

  /// Start listening to output from the server,
  /// and deliver notifications to [notificationProcessor].
  void listenToOutput({NotificationProcessor notificationProcessor}) {
    _receiveSubscription = _isolateChannel.stream
        .transform(utf8.decoder)
        .transform(LineSplitter())
        .listen((line) => outputProcessor(line, notificationProcessor));
  }

  /// Send a command to the server. An 'id' will be automatically assigned.
  /// The returned [Future] will be completed when the server acknowledges
  /// the command with a response.
  /// If the server acknowledges the command with a normal (non-error) response,
  /// the future will be completed with the 'result' field from the response.
  /// If the server acknowledges the command with an error response,
  /// the future will be completed with an error.
  Future<Map<String, dynamic>> send(
          String method, Map<String, dynamic> params) =>
      sendCommandWith(method, params, _isolateChannel.sink.add);

  /// Start the server in a new [Isolate].
  Future start({
    String clientId,
    String clientVersion,
    int diagnosticPort,
    String instrumentationLogFile,
    String sdkPath,
    bool suppressAnalytics = true,
    bool useAnalysisHighlight2 = false,
  }) async {
    if (_isolate != null) {
      throw Exception('Isolate already started');
    }

    // Even though this is an isolate, most of the analysis server code
    // can't tell the difference.  So we construct "command line" arguments
    // just the same as analysis_server_client.
    List<String> arguments = [];
    arguments.addAll(getServerArguments(
        clientId: clientId,
        clientVersion: clientVersion,
        suppressAnalytics: suppressAnalytics,
        diagnosticPort: diagnosticPort,
        instrumentationLogFile: instrumentationLogFile,
        sdkPath: sdkPath,
        useAnalysisHighlight2: useAnalysisHighlight2));

    listener?.startingServer('((isolate))', arguments);
    ReceivePort receivePort = ReceivePort();
    ReceivePort onExitReceivePort = ReceivePort();
    ReceivePort onErrorReceivePort = ReceivePort();
    onExitReceivePort.listen((_) {
      isolateExited.complete(0);
    });
    onErrorReceivePort.listen((_) {
      listener?.unexpectedStop(null);
    });
    _isolateChannel = IsolateChannel<List<int>>.connectReceive(receivePort);
    _isolate = await Isolate.spawn(
        _runIsolate, _IsolateParameters(arguments, receivePort.sendPort),
        onExit: onExitReceivePort.sendPort);
  }

  /// This is the function passed to [Isolate.spawn] to actually begin
  /// the server.
  static void _runIsolate(_IsolateParameters parameters) {
    ServerStarter starter = ServerStarter();
    // TODO(jcollins-g): consider a refactor that does not require passing
    // text arguments to start the server.
    starter.start(parameters.arguments, parameters.sendPort);
  }

  /// Attempt to gracefully shutdown the server.
  /// If that fails, then kill the isolate.
  Future<void> stop({Duration timeLimit}) async {
    timeLimit ??= const Duration(seconds: 5);
    if (_isolate == null) {
      // isolate already exited
      return;
    }
    final future = send(SERVER_REQUEST_SHUTDOWN, null);
    final isolate = _isolate;
    _isolate = null;
    await future
        // fall through to wait for exit
        .timeout(timeLimit, onTimeout: () {
      return null;
    }).whenComplete(() async {
      await _receiveSubscription?.cancel();
      _receiveSubscription = null;
    });
    return isolateExited.future.timeout(timeLimit, onTimeout: () {
      listener?.killingServerProcess('server failed to exit');
      isolate.kill(priority: Isolate.immediate);
    });
  }
}