// Copyright 2014 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 'dart:async';

import 'package:async/async.dart';

import 'base/logger.dart';
import 'device.dart';
import 'device_port_forwarder.dart';
import 'mdns_discovery.dart';
import 'protocol_discovery.dart';

/// Discovers the VM service uri on a device, and forwards the port to the host.
///
/// This is mainly used during a `flutter attach`.
abstract class VMServiceDiscoveryForAttach {
  VMServiceDiscoveryForAttach();

  /// The discovered VM service URis.
  ///
  /// Port forwarding is only attempted when this is invoked, for each VM
  /// Service URI in the stream.
  Stream<Uri> get uris;
}

/// An implementation of [VMServiceDiscoveryForAttach] that uses log scanning
/// for the discovery.
class LogScanningVMServiceDiscoveryForAttach extends VMServiceDiscoveryForAttach {
  LogScanningVMServiceDiscoveryForAttach(
    Future<DeviceLogReader> logReader, {
    DevicePortForwarder? portForwarder,
    int? hostPort,
    int? devicePort,
    required bool ipv6,
    required Logger logger,
  }) {
    _protocolDiscovery = (() async => ProtocolDiscovery.vmService(
      await logReader,
      portForwarder: portForwarder,
      ipv6: ipv6,
      devicePort: devicePort,
      hostPort: hostPort,
      logger: logger,
    ))();
  }

  late final Future<ProtocolDiscovery> _protocolDiscovery;

  @override
  Stream<Uri> get uris {
    final StreamController<Uri> controller = StreamController<Uri>();
    _protocolDiscovery.then(
      (ProtocolDiscovery protocolDiscovery) async {
        await controller.addStream(protocolDiscovery.uris);
        await controller.close();
      },
      onError: (Object error) => controller.addError(error),
    );
    return controller.stream;
  }
}

/// An implementation of [VMServiceDiscoveryForAttach] that uses mdns for the
/// discovery.
class MdnsVMServiceDiscoveryForAttach extends VMServiceDiscoveryForAttach {
  MdnsVMServiceDiscoveryForAttach({
    required this.device,
    this.appId,
    required this.usesIpv6,
    required this.useDeviceIPAsHost,
    this.deviceVmservicePort,
    this.hostVmservicePort,
  });

  final Device device;
  final String? appId;
  final bool usesIpv6;
  final bool useDeviceIPAsHost;
  final int? deviceVmservicePort;
  final int? hostVmservicePort;

  @override
  Stream<Uri> get uris {
    final Future<Uri?> mDNSDiscoveryFuture = MDnsVmServiceDiscovery.instance!.getVMServiceUriForAttach(
      appId,
      device,
      usesIpv6: usesIpv6,
      useDeviceIPAsHost: useDeviceIPAsHost,
      deviceVmservicePort: deviceVmservicePort,
      hostVmservicePort: hostVmservicePort,
    );

    return Stream<Uri?>.fromFuture(mDNSDiscoveryFuture).where((Uri? uri) => uri != null).cast<Uri>().asBroadcastStream();
  }
}

/// An implementation of [VMServiceDiscoveryForAttach] that delegates to other
/// [VMServiceDiscoveryForAttach] instances for discovery.
class DelegateVMServiceDiscoveryForAttach extends VMServiceDiscoveryForAttach {
  DelegateVMServiceDiscoveryForAttach(this.delegates);

  final List<VMServiceDiscoveryForAttach> delegates;

  @override
  Stream<Uri> get uris =>
      StreamGroup.merge<Uri>(
        delegates.map((VMServiceDiscoveryForAttach delegate) => delegate.uris));
}