/// A named channel for efficiently communicating with the host platform using
/// structured messages. The message types supported are non-cyclic structures
/// of the following kinds:
///
/// * `null`
/// * [bool]
/// * [int], will be communicated using 32-bit two's complement binary form
/// * [double], will be communicated using IEEE 754 double-precision binary
///   floating-point format (binary64)
/// * [String]
/// * [ByteData]
/// * [List] of payload values
/// * [Map] from strings to payload values
///
/// Values of these types will be referred to as 'payload values' below.
/// In function signatures, the type of a payload value is `dynamic`.
class PlatformChannel {
  final String channel;

  PlatformChannel(this.channel);

  Future<dynamic> send(dynamic payload) async {
    return _decode(await PlatformMessages.sendBinary(channel, _encode(payload)));
  }

  void setMessageHandler(Future<dynamic> handler(dynamic payload)) {
    PlatformMessages.setBinaryMessageHandler(channel, (ByteData bytes) async {
      return _encode(await handler(_decode(bytes)));
    });
  }

  void setMockMessageHandler(Future<dynamic> handler(dynamic payload)) {
    if (handler == null) {
      PlatformMessages.setMockBinaryMessageHandler(channel, null);
    } else {
      PlatformMessages.setMockBinaryMessageHandler(channel, (ByteData bytes) async {
        return _encode(await handler(_decode(bytes)));
      });
    }
  }

  Future<T> invokeFunction<T>({
    String name,
    Map<String, dynamic> arguments,
    T interpreter(dynamic payload),
  }) async {
    return _interpretPayload(
      send(_encode(<String, dynamic>{
        'name': name,
        'args': arguments,
      })),
      interpreter);
  }

  Stream<T> receiveStream<T>({
    Map<String, dynamic> arguments,
    T interpreter(dynamic payload),
  }) {
    assert(arguments == null || arguments['eventChannel'] is String);
    final String eventChannel = arguments == null ? channel : arguments['eventChannel'];
    StreamController<T> controller;
    controller = new StreamController<T>.broadcast(
      onListen: () async {
        PlatformMessages.setBinaryMessageHandler(
          eventChannel,
          (ByteData reply) async {
            try {
              controller.add(_interpretPayload<T>(_decode(reply), interpreter));
            } catch (e) {
              controller.addError(e);
            }
          }
        );
        try {
          await invokeFunction<Null>(
            name: 'listen',
            arguments: arguments,
          );
        } catch (e) {
          PlatformMessages.setBinaryMessageHandler(eventChannel, null);
          controller.addError(e);
        }
      }, onCancel: () async {
        PlatformMessages.setBinaryMessageHandler(eventChannel, null);
        try {
          await invokeFunction<Null>(
            name: 'cancel',
            arguments: arguments,
          );
        } catch (exception, stack) {
          FlutterError.reportError(new FlutterErrorDetails(
            exception: exception,
            stack: stack,
            library: 'services library',
            context: 'while de-activating platform stream on channel $channel',
          ));
        }
      }
    );
    return controller.stream;
  }

  T _interpretPayload<T>(dynamic payload, T interpreter(dynamic payload)) {
    if (payload is Map) {
      final dynamic status = payload['status'];
      final dynamic message = payload['message'];
      final dynamic data = payload['data'];
      if (status == 'ok')
        return interpreter?.call(data);
      else if (status is String && message is String)
        throw new PlatformException(status: status, message: message, details: data);
      else
        throw new FormatException('Invalid envelope: $payload');
    } else {
      throw new FormatException('Expected envelope Map, got $payload');
    }
  }

  // TODO(mravn): consider replacing this homegrown codec by something existing (protobuf?).
  // TODO(mravn): consider making the codec pluggable.
  ByteData _encode(dynamic payload) { ... }
  dynamic _decode(ByteData bytes) { ... }
}

/// Thrown to indicate that a platform interaction resulted in an error.
class PlatformException implements Exception {
  PlatformException({
    @required this.status,
    @required this.message,
    this.details,
  }) {
    assert(status != null);
    assert(message != null);
  }

  /// A non-`null` status string, such as 'error' or 'not found'.
  final String status;

  /// A non-`null` human-readable error message.
  final String message;

  /// A payload value providing custom details about the error, maybe `null`.
  final dynamic details;

  @override
  String toString() => 'PlatformException($status, $message, $details)';
}