// 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 'dart:io' as io;
import 'dart:typed_data';

import 'package:fake_async/fake_async.dart';
import 'package:file/file.dart';
import 'package:flutter_tools/src/android/android_device.dart';
import 'package:flutter_tools/src/android/android_workflow.dart';
import 'package:flutter_tools/src/application_package.dart';
import 'package:flutter_tools/src/base/dds.dart';
import 'package:flutter_tools/src/base/logger.dart';
import 'package:flutter_tools/src/base/utils.dart';
import 'package:flutter_tools/src/build_info.dart';
import 'package:flutter_tools/src/commands/daemon.dart';
import 'package:flutter_tools/src/daemon.dart';
import 'package:flutter_tools/src/device.dart';
import 'package:flutter_tools/src/features.dart';
import 'package:flutter_tools/src/globals.dart' as globals;
import 'package:flutter_tools/src/ios/ios_workflow.dart';
import 'package:flutter_tools/src/resident_runner.dart';
import 'package:flutter_tools/src/vmservice.dart';
import 'package:flutter_tools/src/windows/windows_workflow.dart';
import 'package:test/fake.dart';

import '../../src/common.dart';
import '../../src/context.dart';
import '../../src/fake_devices.dart';
import '../../src/fakes.dart';

/// Runs a callback using FakeAsync.run while continually pumping the
/// microtask queue. This avoids a deadlock when tests `await` a Future
/// which queues a microtask that will not be processed unless the queue
/// is flushed.
Future<T> _runFakeAsync<T>(Future<T> Function(FakeAsync time) f) async {
  return FakeAsync().run((FakeAsync time) async {
    bool pump = true;
    final Future<T> future = f(time).whenComplete(() => pump = false);
    while (pump) {
      time.flushMicrotasks();
    }
    return future;
  });
}

class FakeDaemonStreams implements DaemonStreams {
  final StreamController<DaemonMessage> inputs = StreamController<DaemonMessage>();
  final StreamController<DaemonMessage> outputs = StreamController<DaemonMessage>();

  @override
  Stream<DaemonMessage> get inputStream {
    return inputs.stream;
  }

  @override
  void send(Map<String, Object?> message, [List<int>? binary]) {
    outputs.add(DaemonMessage(message, binary != null ? Stream<List<int>>.value(binary) : null));
  }

  @override
  Future<void> dispose() async {
    await inputs.close();
    // In some tests, outputs have no listeners. We don't wait for outputs to close.
    unawaited(outputs.close());
  }
}

void main() {
  late Daemon daemon;
  late NotifyingLogger notifyingLogger;

  group('daemon', () {
    late FakeDaemonStreams daemonStreams;
    late DaemonConnection daemonConnection;
    setUp(() {
      BufferLogger bufferLogger;
      bufferLogger = BufferLogger.test();
      notifyingLogger = NotifyingLogger(verbose: false, parent: bufferLogger);
      daemonStreams = FakeDaemonStreams();
      daemonConnection = DaemonConnection(daemonStreams: daemonStreams, logger: bufferLogger);
    });

    tearDown(() async {
      await daemon.shutdown();
      notifyingLogger.dispose();
      await daemonConnection.dispose();
    });

    testUsingContext('daemon.version command should succeed', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{'id': 0, 'method': 'daemon.version'}),
      );
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      expect(response.data['result'], isNotEmpty);
      expect(response.data['result'], isA<String>());
    });

    testUsingContext(
      'daemon.getSupportedPlatforms command should succeed',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
        // Use the flutter_gallery project which has a known set of supported platforms.
        final String projectPath = globals.fs.path.join(
          getFlutterRoot(),
          'dev',
          'integration_tests',
          'flutter_gallery',
        );

        daemonStreams.inputs.add(
          DaemonMessage(<String, Object?>{
            'id': 0,
            'method': 'daemon.getSupportedPlatforms',
            'params': <String, Object>{'projectRoot': projectPath},
          }),
        );
        final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);

        expect(response.data['id'], 0);
        expect(response.data['result'], isNotEmpty);
        expect(response.data['result']! as Map<String, Object?>, const <String, Object>{
          'platforms': <String>['macos', 'windows'],
          'platformTypes': <String, Map<String, Object>>{
            'web': <String, Object>{
              'isSupported': false,
              'reasons': <Map<String, String>>[
                <String, String>{
                  'reasonText': 'the Web feature is not enabled',
                  'fixText': 'Run "flutter config --enable-web"',
                  'fixCode': 'config',
                },
              ],
            },
            'android': <String, Object>{
              'isSupported': false,
              'reasons': <Map<String, String>>[
                <String, String>{
                  'reasonText': 'the Android feature is not enabled',
                  'fixText': 'Run "flutter config --enable-android"',
                  'fixCode': 'config',
                },
              ],
            },
            'ios': <String, Object>{
              'isSupported': false,
              'reasons': <Map<String, String>>[
                <String, String>{
                  'reasonText': 'the iOS feature is not enabled',
                  'fixText': 'Run "flutter config --enable-ios"',
                  'fixCode': 'config',
                },
              ],
            },
            'linux': <String, Object>{
              'isSupported': false,
              'reasons': <Map<String, String>>[
                <String, String>{
                  'reasonText': 'the Linux feature is not enabled',
                  'fixText': 'Run "flutter config --enable-linux-desktop"',
                  'fixCode': 'config',
                },
              ],
            },
            'macos': <String, bool>{'isSupported': true},
            'windows': <String, bool>{'isSupported': true},
            'fuchsia': <String, Object>{
              'isSupported': false,
              'reasons': <Map<String, String>>[
                <String, String>{
                  'reasonText': 'the Fuchsia feature is not enabled',
                  'fixText': 'Run "flutter config --enable-fuchsia"',
                  'fixCode': 'config',
                },
                <String, String>{
                  'reasonText': 'the Fuchsia platform is not enabled for this project',
                  'fixText':
                      'Run "flutter create --platforms=fuchsia ." in your application directory',
                  'fixCode': 'create',
                },
              ],
            },
            'custom': <String, Object>{
              'isSupported': false,
              'reasons': <Map<String, String>>[
                <String, String>{
                  'reasonText': 'the custom devices feature is not enabled',
                  'fixText': 'Run "flutter config --enable-custom-devices"',
                  'fixCode': 'config',
                },
              ],
            },
          },
        });
      },
      overrides: <Type, Generator>{
        // Disable Android/iOS and enable macOS to make sure result is consistent and defaults are tested off.
        FeatureFlags:
            () => TestFeatureFlags(
              isAndroidEnabled: false,
              isIOSEnabled: false,
              isMacOSEnabled: true,
              isWindowsEnabled: true,
            ),
      },
    );

    testUsingContext(
      'printError should send daemon.logMessage event',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
        globals.printError('daemon.logMessage test');
        final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere((
          DaemonMessage message,
        ) {
          return message.data['event'] == 'daemon.logMessage' &&
              (message.data['params']! as Map<String, Object?>)['level'] == 'error';
        });
        expect(response.data['id'], isNull);
        expect(response.data['event'], 'daemon.logMessage');
        final Map<String, String> logMessage =
            castStringKeyedMap(response.data['params'])!.cast<String, String>();
        expect(logMessage['level'], 'error');
        expect(logMessage['message'], 'daemon.logMessage test');
      },
      overrides: <Type, Generator>{Logger: () => notifyingLogger},
    );

    testUsingContext(
      'printWarning should send daemon.logMessage event',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
        globals.printWarning('daemon.logMessage test');
        final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere((
          DaemonMessage message,
        ) {
          return message.data['event'] == 'daemon.logMessage' &&
              (message.data['params']! as Map<String, Object?>)['level'] == 'warning';
        });
        expect(response.data['id'], isNull);
        expect(response.data['event'], 'daemon.logMessage');
        final Map<String, String> logMessage =
            castStringKeyedMap(response.data['params'])!.cast<String, String>();
        expect(logMessage['level'], 'warning');
        expect(logMessage['message'], 'daemon.logMessage test');
      },
      overrides: <Type, Generator>{Logger: () => notifyingLogger},
    );

    testUsingContext(
      'printStatus should log to stdout when logToStdout is enabled',
      () async {
        final StringBuffer buffer = await capturedConsolePrint(() {
          daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger, logToStdout: true);
          globals.printStatus('daemon.logMessage test');
          return Future<void>.value();
        });

        expect(buffer.toString().trim(), 'daemon.logMessage test');
      },
      overrides: <Type, Generator>{Logger: () => notifyingLogger},
    );

    testUsingContext(
      'printBox should log to stdout when logToStdout is enabled',
      () async {
        final StringBuffer buffer = await capturedConsolePrint(() {
          daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger, logToStdout: true);
          globals.printBox('This is the box message', title: 'Sample title');
          return Future<void>.value();
        });

        expect(buffer.toString().trim(), contains('Sample title: This is the box message'));
      },
      overrides: <Type, Generator>{Logger: () => notifyingLogger},
    );

    testUsingContext(
      'printTrace should send daemon.logMessage event when notifyVerbose is enabled',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
        notifyingLogger.notifyVerbose = false;
        globals.printTrace('daemon.logMessage test 1');
        notifyingLogger.notifyVerbose = true;
        globals.printTrace('daemon.logMessage test 2');
        final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere((
          DaemonMessage message,
        ) {
          return message.data['event'] == 'daemon.logMessage' &&
              (message.data['params']! as Map<String, Object?>)['level'] == 'trace';
        });
        expect(response.data['id'], isNull);
        expect(response.data['event'], 'daemon.logMessage');
        final Map<String, String> logMessage =
            castStringKeyedMap(response.data['params'])!.cast<String, String>();
        expect(logMessage['level'], 'trace');
        expect(logMessage['message'], 'daemon.logMessage test 2');
      },
      overrides: <Type, Generator>{Logger: () => notifyingLogger},
    );

    testUsingContext(
      'daemon.setNotifyVerbose command should update the notify verbose status to true',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
        expect(notifyingLogger.notifyVerbose, false);

        daemonStreams.inputs.add(
          DaemonMessage(<String, Object?>{
            'id': 0,
            'method': 'daemon.setNotifyVerbose',
            'params': <String, Object?>{'verbose': true},
          }),
        );
        await daemonStreams.outputs.stream.firstWhere(_notEvent);
        expect(notifyingLogger.notifyVerbose, true);
      },
    );

    testUsingContext(
      'daemon.setNotifyVerbose command should update the notify verbose status to false',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
        notifyingLogger.notifyVerbose = false;

        daemonStreams.inputs.add(
          DaemonMessage(<String, Object?>{
            'id': 0,
            'method': 'daemon.setNotifyVerbose',
            'params': <String, Object?>{'verbose': false},
          }),
        );
        await daemonStreams.outputs.stream.firstWhere(_notEvent);
        expect(notifyingLogger.notifyVerbose, false);
      },
    );

    testUsingContext('daemon.shutdown command should stop daemon', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{'id': 0, 'method': 'daemon.shutdown'}),
      );
      return daemon.onExit.then<void>((int code) async {
        await daemonStreams.inputs.close();
        expect(code, 0);
      });
    });

    testUsingContext('app.restart without an appId should report an error', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);

      daemonStreams.inputs.add(DaemonMessage(<String, Object?>{'id': 0, 'method': 'app.restart'}));
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      expect(response.data['error'], contains('appId is required'));
    });

    testUsingContext(
      'ext.flutter.debugPaint via service extension without an appId should report an error',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);

        daemonStreams.inputs.add(
          DaemonMessage(<String, Object?>{
            'id': 0,
            'method': 'app.callServiceExtension',
            'params': <String, String>{'methodName': 'ext.flutter.debugPaint'},
          }),
        );
        final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
        expect(response.data['id'], 0);
        expect(response.data['error'], contains('appId is required'));
      },
    );

    testUsingContext('app.stop without appId should report an error', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);

      daemonStreams.inputs.add(DaemonMessage(<String, Object?>{'id': 0, 'method': 'app.stop'}));
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      expect(response.data['error'], contains('appId is required'));
    });

    testUsingContext('device.getDevices should respond with list', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{'id': 0, 'method': 'device.getDevices'}),
      );
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      expect(response.data['result'], isList);
    });

    testUsingContext('device.getDevices reports available devices', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      final FakePollingDeviceDiscovery discoverer = FakePollingDeviceDiscovery();
      daemon.deviceDomain.addDeviceDiscoverer(discoverer);
      discoverer.addDevice(FakeAndroidDevice());
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{'id': 0, 'method': 'device.getDevices'}),
      );
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      final Object? result = response.data['result'];
      expect(result, isList);
      expect(result, isNotEmpty);
    });

    testUsingContext(
      'should send device.added event when device is discovered',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);

        final FakePollingDeviceDiscovery discoverer = FakePollingDeviceDiscovery();
        daemon.deviceDomain.addDeviceDiscoverer(discoverer);
        discoverer.addDevice(FakeAndroidDevice());

        final List<Map<String, Object?>> names = <Map<String, Object?>>[];
        await daemonStreams.outputs.stream.skipWhile(_isConnectedEvent).take(1).forEach((
          DaemonMessage response,
        ) async {
          expect(response.data['event'], 'device.added');
          expect(response.data['params'], isMap);

          final Map<String, Object?> params = castStringKeyedMap(response.data['params'])!;
          names.add(params);
        });
        await daemonStreams.outputs.close();
        expect(
          names,
          containsAll(const <Map<String, Object?>>[
            <String, Object?>{
              'id': 'device',
              'name': 'android device',
              'platform': 'android-arm',
              'emulator': false,
              'category': 'mobile',
              'platformType': 'android',
              'ephemeral': false,
              'emulatorId': 'device',
              'sdk': 'Android 12',
              'isConnected': true,
              'connectionInterface': 'attached',
              'capabilities': <String, Object?>{
                'hotReload': true,
                'hotRestart': true,
                'screenshot': true,
                'fastStart': true,
                'flutterExit': true,
                'hardwareRendering': true,
                'startPaused': true,
              },
            },
          ]),
        );
      },
      overrides: <Type, Generator>{
        AndroidWorkflow: () => FakeAndroidWorkflow(),
        IOSWorkflow: () => FakeIOSWorkflow(),
        WindowsWorkflow: () => FakeWindowsWorkflow(),
      },
    );

    testUsingContext('device.discoverDevices should respond with list', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{'id': 0, 'method': 'device.discoverDevices'}),
      );
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      expect(response.data['result'], isList);
    });

    testUsingContext('device.discoverDevices reports available devices', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      final FakePollingDeviceDiscovery discoverer = FakePollingDeviceDiscovery();
      daemon.deviceDomain.addDeviceDiscoverer(discoverer);
      discoverer.addDevice(FakeAndroidDevice());
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{'id': 0, 'method': 'device.discoverDevices'}),
      );
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      final Object? result = response.data['result'];
      expect(result, isList);
      expect(result, isNotEmpty);
      expect(discoverer.discoverDevicesCalled, true);
    });

    testUsingContext('device.supportsRuntimeMode returns correct value', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      final FakePollingDeviceDiscovery discoverer = FakePollingDeviceDiscovery();
      daemon.deviceDomain.addDeviceDiscoverer(discoverer);
      final FakeAndroidDevice device = FakeAndroidDevice();
      discoverer.addDevice(device);
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{
          'id': 0,
          'method': 'device.supportsRuntimeMode',
          'params': <String, Object?>{'deviceId': 'device', 'buildMode': 'profile'},
        }),
      );
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      final Object? result = response.data['result'];
      expect(result, true);
      expect(device.supportsRuntimeModeCalledBuildMode, BuildMode.profile);
    });

    testUsingContext('device.logReader.start and .stop starts and stops log reader', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      final FakePollingDeviceDiscovery discoverer = FakePollingDeviceDiscovery();
      daemon.deviceDomain.addDeviceDiscoverer(discoverer);
      final FakeAndroidDevice device = FakeAndroidDevice();
      discoverer.addDevice(device);
      final FakeDeviceLogReader logReader = FakeDeviceLogReader();
      device.logReader = logReader;
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{
          'id': 0,
          'method': 'device.logReader.start',
          'params': <String, Object?>{'deviceId': 'device'},
        }),
      );
      final Stream<DaemonMessage> broadcastOutput =
          daemonStreams.outputs.stream.asBroadcastStream();
      final DaemonMessage firstResponse = await broadcastOutput.firstWhere(_notEvent);
      expect(firstResponse.data['id'], 0);
      final String? logReaderId = firstResponse.data['result'] as String?;
      expect(logReaderId, isNotNull);

      // Try sending logs.
      logReader.logLinesController.add('Sample log line');
      final DaemonMessage logEvent = await broadcastOutput.firstWhere(
        (DaemonMessage message) =>
            message.data['event'] != null && message.data['event'] != 'device.added',
      );
      expect(logEvent.data['params'], 'Sample log line');

      // Now try to stop the log reader.
      expect(logReader.disposeCalled, false);
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{
          'id': 1,
          'method': 'device.logReader.stop',
          'params': <String, Object?>{'id': logReaderId},
        }),
      );
      final DaemonMessage stopResponse = await broadcastOutput.firstWhere(_notEvent);
      expect(stopResponse.data['id'], 1);
      expect(logReader.disposeCalled, true);
    });

    group('device.startApp and .stopApp', () {
      late FakeApplicationPackageFactory applicationPackageFactory;
      setUp(() {
        applicationPackageFactory = FakeApplicationPackageFactory();
      });

      testUsingContext(
        'device.startApp and .stopApp starts and stops an app',
        () async {
          daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
          final FakePollingDeviceDiscovery discoverer = FakePollingDeviceDiscovery();
          daemon.deviceDomain.addDeviceDiscoverer(discoverer);
          final FakeAndroidDevice device = FakeAndroidDevice();
          discoverer.addDevice(device);
          final Stream<DaemonMessage> broadcastOutput =
              daemonStreams.outputs.stream.asBroadcastStream();

          // First upload the application package.
          final FakeApplicationPackage applicationPackage = FakeApplicationPackage();
          applicationPackageFactory.applicationPackage = applicationPackage;
          daemonStreams.inputs.add(
            DaemonMessage(<String, Object?>{
              'id': 0,
              'method': 'device.uploadApplicationPackage',
              'params': <String, Object?>{
                'targetPlatform': 'android',
                'applicationBinary': 'test_file',
              },
            }),
          );
          final DaemonMessage applicationPackageIdResponse = await broadcastOutput.firstWhere(
            _notEvent,
          );
          expect(applicationPackageIdResponse.data['id'], 0);
          expect(applicationPackageFactory.applicationBinaryRequested!.basename, 'test_file');
          expect(applicationPackageFactory.platformRequested, TargetPlatform.android);
          final String? applicationPackageId =
              applicationPackageIdResponse.data['result'] as String?;

          // Try starting the app.
          final Uri vmServiceUri = Uri.parse('http://127.0.0.1:12345/vmService');
          device.launchResult = LaunchResult.succeeded(vmServiceUri: vmServiceUri);
          daemonStreams.inputs.add(
            DaemonMessage(<String, Object?>{
              'id': 1,
              'method': 'device.startApp',
              'params': <String, Object?>{
                'deviceId': 'device',
                'applicationPackageId': applicationPackageId,
                'debuggingOptions': DebuggingOptions.enabled(BuildInfo.debug).toJson(),
              },
            }),
          );
          final DaemonMessage startAppResponse = await broadcastOutput.firstWhere(_notEvent);
          expect(startAppResponse.data['id'], 1);
          expect(device.startAppPackage, applicationPackage);
          final Map<String, Object?> startAppResult =
              startAppResponse.data['result']! as Map<String, Object?>;
          expect(startAppResult['started'], true);
          expect(startAppResult['vmServiceUri'], vmServiceUri.toString());

          // Try stopping the app.
          daemonStreams.inputs.add(
            DaemonMessage(<String, Object?>{
              'id': 2,
              'method': 'device.stopApp',
              'params': <String, Object?>{
                'deviceId': 'device',
                'applicationPackageId': applicationPackageId,
              },
            }),
          );
          final DaemonMessage stopAppResponse = await broadcastOutput.firstWhere(_notEvent);
          expect(stopAppResponse.data['id'], 2);
          expect(device.stopAppPackage, applicationPackage);
          final bool? stopAppResult = stopAppResponse.data['result'] as bool?;
          expect(stopAppResult, true);
        },
        overrides: <Type, Generator>{ApplicationPackageFactory: () => applicationPackageFactory},
      );
    });

    testUsingContext(
      'device.startDartDevelopmentService and .shutdownDartDevelopmentService starts and stops DDS',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
        final FakePollingDeviceDiscovery discoverer = FakePollingDeviceDiscovery();
        daemon.deviceDomain.addDeviceDiscoverer(discoverer);
        final FakeAndroidDevice device = FakeAndroidDevice();
        discoverer.addDevice(device);

        final Completer<void> ddsDoneCompleter = Completer<void>();
        device.dds.done = ddsDoneCompleter.future;
        final Uri fakeDdsUri = Uri.parse('http://fake_dds_uri');
        device.dds.uri = fakeDdsUri;

        // Try starting DDS.
        expect(device.dds.startCalled, false);
        daemonStreams.inputs.add(
          DaemonMessage(<String, Object?>{
            'id': 0,
            'method': 'device.startDartDevelopmentService',
            'params': <String, Object?>{
              'deviceId': 'device',
              'disableServiceAuthCodes': false,
              'vmServiceUri': 'http://fake_uri/auth_code',
            },
          }),
        );
        final Stream<DaemonMessage> broadcastOutput =
            daemonStreams.outputs.stream.asBroadcastStream();
        final DaemonMessage startResponse = await broadcastOutput.firstWhere(_notEvent);
        expect(startResponse.data['id'], 0);
        expect(startResponse.data['error'], isNull);
        final Map<String, Object?>? result = startResponse.data['result'] as Map<String, Object?>?;
        final String? ddsUri = result!['ddsUri'] as String?;
        expect(ddsUri, fakeDdsUri.toString());
        expect(device.dds.startCalled, true);
        expect(device.dds.startDisableServiceAuthCodes, false);
        expect(device.dds.startVMServiceUri, Uri.parse('http://fake_uri/auth_code'));

        // dds.done event should be sent to the client.
        ddsDoneCompleter.complete();
        final DaemonMessage startEvent = await broadcastOutput.firstWhere(
          (DaemonMessage message) =>
              message.data['event'] != null && message.data['event'] == 'device.dds.done.device',
        );
        expect(startEvent, isNotNull);

        // Try stopping DDS.
        expect(device.dds.shutdownCalled, false);
        daemonStreams.inputs.add(
          DaemonMessage(<String, Object?>{
            'id': 1,
            'method': 'device.shutdownDartDevelopmentService',
            'params': <String, Object?>{'deviceId': 'device'},
          }),
        );
        final DaemonMessage stopResponse = await broadcastOutput.firstWhere(_notEvent);
        expect(stopResponse.data['id'], 1);
        expect(stopResponse.data['error'], isNull);
        expect(device.dds.shutdownCalled, true);
      },
    );

    testUsingContext('device.getDiagnostics returns correct value', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      final FakePollingDeviceDiscovery discoverer1 = FakePollingDeviceDiscovery();
      discoverer1.diagnostics = <String>['fake diagnostic 1', 'fake diagnostic 2'];
      final FakePollingDeviceDiscovery discoverer2 = FakePollingDeviceDiscovery();
      discoverer2.diagnostics = <String>['fake diagnostic 3', 'fake diagnostic 4'];
      daemon.deviceDomain.addDeviceDiscoverer(discoverer1);
      daemon.deviceDomain.addDeviceDiscoverer(discoverer2);
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{'id': 0, 'method': 'device.getDiagnostics'}),
      );
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      expect(response.data['result'], <String>[
        'fake diagnostic 1',
        'fake diagnostic 2',
        'fake diagnostic 3',
        'fake diagnostic 4',
      ]);
    });

    testUsingContext('emulator.launch without an emulatorId should report an error', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);

      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{'id': 0, 'method': 'emulator.launch'}),
      );
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      expect(response.data['error'], contains('emulatorId is required'));
    });

    testUsingContext('emulator.launch coldboot parameter must be boolean', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      final Map<String, Object?> params = <String, Object?>{'emulatorId': 'device', 'coldBoot': 1};
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{'id': 0, 'method': 'emulator.launch', 'params': params}),
      );
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      expect(response.data['error'], contains('coldBoot is not a bool'));
    });

    testUsingContext('emulator.getEmulators should respond with list', () async {
      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
      daemonStreams.inputs.add(
        DaemonMessage(<String, Object?>{'id': 0, 'method': 'emulator.getEmulators'}),
      );
      final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(_notEvent);
      expect(response.data['id'], 0);
      expect(response.data['result'], isList);
    });

    testUsingContext('daemon can send exposeUrl requests to the client', () async {
      const String originalUrl = 'http://localhost:1234/';
      const String mappedUrl = 'https://publichost:4321/';

      daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);

      // Respond to any requests from the daemon to expose a URL.
      unawaited(
        daemonStreams.outputs.stream
            .firstWhere((DaemonMessage request) => request.data['method'] == 'app.exposeUrl')
            .then((DaemonMessage request) {
              expect((request.data['params']! as Map<String, Object?>)['url'], equals(originalUrl));
              daemonStreams.inputs.add(
                DaemonMessage(<String, Object?>{
                  'id': request.data['id'],
                  'result': <String, Object?>{'url': mappedUrl},
                }),
              );
            }),
      );

      final String exposedUrl = await daemon.daemonDomain.exposeUrl(originalUrl);
      expect(exposedUrl, equals(mappedUrl));
    });

    testUsingContext(
      'devtools.serve command should return host and port on success',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);

        daemonStreams.inputs.add(
          DaemonMessage(<String, Object?>{'id': 0, 'method': 'devtools.serve'}),
        );
        final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(
          (DaemonMessage response) => response.data['id'] == 0,
        );
        final Map<String, Object?> result = response.data['result']! as Map<String, Object?>;
        expect(result, isNotEmpty);
        expect(result['host'], '127.0.0.1');
        expect(result['port'], 1234);
      },
      overrides: <Type, Generator>{
        DevtoolsLauncher:
            () => FakeDevtoolsLauncher(serverAddress: DevToolsServerAddress('127.0.0.1', 1234)),
      },
    );

    testUsingContext(
      'devtools.serve command should return null fields if null returned',
      () async {
        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);

        daemonStreams.inputs.add(
          DaemonMessage(<String, Object?>{'id': 0, 'method': 'devtools.serve'}),
        );
        final DaemonMessage response = await daemonStreams.outputs.stream.firstWhere(
          (DaemonMessage response) => response.data['id'] == 0,
        );
        final Map<String, Object?> result = response.data['result']! as Map<String, Object?>;
        expect(result, isNotEmpty);
        expect(result['host'], null);
        expect(result['port'], null);
      },
      overrides: <Type, Generator>{DevtoolsLauncher: () => FakeDevtoolsLauncher()},
    );

    testUsingContext(
      'proxy.connect tries to connect to an ipv4 address and proxies the connection correctly',
      () async {
        final TestIOOverrides ioOverrides = TestIOOverrides();
        await io.IOOverrides.runWithIOOverrides(() async {
          final FakeSocket socket = FakeSocket();
          bool connectCalled = false;
          int? connectPort;
          ioOverrides.connectCallback = (Object? host, int port) async {
            connectCalled = true;
            connectPort = port;
            if (host == io.InternetAddress.loopbackIPv4) {
              return socket;
            }
            throw const io.SocketException('fail');
          };

          daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
          daemonStreams.inputs.add(
            DaemonMessage(<String, Object?>{
              'id': 0,
              'method': 'proxy.connect',
              'params': <String, Object?>{'port': 123},
            }),
          );

          final Stream<DaemonMessage> broadcastOutput =
              daemonStreams.outputs.stream.asBroadcastStream();
          final DaemonMessage firstResponse = await broadcastOutput.firstWhere(_notEvent);
          expect(firstResponse.data['id'], 0);
          expect(firstResponse.data['result'], isNotNull);
          expect(connectCalled, true);
          expect(connectPort, 123);

          final Object? id = firstResponse.data['result'];

          // Can send received data as event.
          socket.controller.add(Uint8List.fromList(<int>[10, 11, 12]));
          final DaemonMessage dataEvent = await broadcastOutput.firstWhere(
            (DaemonMessage message) =>
                message.data['event'] != null && message.data['event'] == 'proxy.data.$id',
          );
          expect(dataEvent.binary, isNotNull);
          final List<List<int>> data = await dataEvent.binary!.toList();
          expect(data[0], <int>[10, 11, 12]);

          // Can proxy data to the socket.
          daemonStreams.inputs.add(
            DaemonMessage(<String, Object?>{
              'id': 0,
              'method': 'proxy.write',
              'params': <String, Object?>{'id': id},
            }, Stream<List<int>>.value(<int>[21, 22, 23])),
          );
          await pumpEventQueue();
          expect(socket.addedData[0], <int>[21, 22, 23]);

          // Closes the connection when disconnect request received.
          expect(socket.closeCalled, false);
          daemonStreams.inputs.add(
            DaemonMessage(<String, Object?>{
              'id': 0,
              'method': 'proxy.disconnect',
              'params': <String, Object?>{'id': id},
            }),
          );
          await pumpEventQueue();
          expect(socket.closeCalled, true);

          // Sends disconnected event when socket.done completer finishes.
          socket.doneCompleter.complete(true);
          final DaemonMessage disconnectEvent = await broadcastOutput.firstWhere(
            (DaemonMessage message) =>
                message.data['event'] != null && message.data['event'] == 'proxy.disconnected.$id',
          );
          expect(disconnectEvent.data, isNotNull);
        }, ioOverrides);
      },
    );

    testUsingContext('proxy.connect connects to ipv6 if ipv4 failed', () async {
      final TestIOOverrides ioOverrides = TestIOOverrides();
      await io.IOOverrides.runWithIOOverrides(() async {
        final FakeSocket socket = FakeSocket();
        bool connectIpv4Called = false;
        int? connectPort;
        ioOverrides.connectCallback = (Object? host, int port) async {
          connectPort = port;
          if (host == io.InternetAddress.loopbackIPv4) {
            connectIpv4Called = true;
          } else if (host == io.InternetAddress.loopbackIPv6) {
            return socket;
          }
          throw const io.SocketException('fail');
        };

        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
        daemonStreams.inputs.add(
          DaemonMessage(<String, Object?>{
            'id': 0,
            'method': 'proxy.connect',
            'params': <String, Object?>{'port': 123},
          }),
        );

        final Stream<DaemonMessage> broadcastOutput =
            daemonStreams.outputs.stream.asBroadcastStream();
        final DaemonMessage firstResponse = await broadcastOutput.firstWhere(_notEvent);
        expect(firstResponse.data['id'], 0);
        expect(firstResponse.data['result'], isNotNull);
        expect(connectIpv4Called, true);
        expect(connectPort, 123);
      }, ioOverrides);
    });

    testUsingContext('proxy.connect fails if both ipv6 and ipv4 failed', () async {
      final TestIOOverrides ioOverrides = TestIOOverrides();
      await io.IOOverrides.runWithIOOverrides(() async {
        ioOverrides.connectCallback =
            (Object? host, int port) => throw const io.SocketException('fail');

        daemon = Daemon(daemonConnection, notifyingLogger: notifyingLogger);
        daemonStreams.inputs.add(
          DaemonMessage(<String, Object?>{
            'id': 0,
            'method': 'proxy.connect',
            'params': <String, Object?>{'port': 123},
          }),
        );

        final Stream<DaemonMessage> broadcastOutput =
            daemonStreams.outputs.stream.asBroadcastStream();
        final DaemonMessage firstResponse = await broadcastOutput.firstWhere(_notEvent);
        expect(firstResponse.data['id'], 0);
        expect(firstResponse.data['result'], isNull);
        expect(firstResponse.data['error'], isNotNull);
      }, ioOverrides);
    });
  });

  group('notifyingLogger', () {
    late BufferLogger bufferLogger;
    setUp(() {
      bufferLogger = BufferLogger.test();
    });

    tearDown(() {
      bufferLogger.clear();
    });

    testUsingContext('outputs trace messages in verbose mode', () async {
      final NotifyingLogger logger = NotifyingLogger(verbose: true, parent: bufferLogger);
      logger.printTrace('test');
      expect(bufferLogger.errorText, contains('test'));
    });

    testUsingContext('ignores trace messages in non-verbose mode', () async {
      final NotifyingLogger logger = NotifyingLogger(verbose: false, parent: bufferLogger);

      final Future<LogMessage> messageResult = logger.onMessage.first;
      logger.printTrace('test');
      logger.printStatus('hello');

      final LogMessage message = await messageResult;

      expect(message.level, 'status');
      expect(message.message, 'hello');
      expect(bufferLogger.errorText, isEmpty);
    });

    testUsingContext('sends trace messages in notify verbose mode', () async {
      final NotifyingLogger logger = NotifyingLogger(
        verbose: false,
        parent: bufferLogger,
        notifyVerbose: true,
      );

      final Future<LogMessage> messageResult = logger.onMessage.first;
      logger.printTrace('hello');

      final LogMessage message = await messageResult;

      expect(message.level, 'trace');
      expect(message.message, 'hello');
      expect(bufferLogger.errorText, isEmpty);
    });

    testUsingContext('buffers messages sent before a subscription', () async {
      final NotifyingLogger logger = NotifyingLogger(verbose: false, parent: bufferLogger);

      logger.printStatus('hello');

      final LogMessage message = await logger.onMessage.first;

      expect(message.level, 'status');
      expect(message.message, 'hello');
    });

    testWithoutContext('responds to .supportsColor', () async {
      final NotifyingLogger logger = NotifyingLogger(verbose: false, parent: bufferLogger);
      expect(logger.supportsColor, isFalse);
    });
  });

  group('daemon queue', () {
    late DebounceOperationQueue<int, String> queue;
    const Duration debounceDuration = Duration(seconds: 1);

    setUp(() {
      queue = DebounceOperationQueue<int, String>();
    });

    testWithoutContext('debounces/merges same operation type and returns same result', () async {
      await _runFakeAsync((FakeAsync time) async {
        final List<Future<int>> operations = <Future<int>>[
          queue.queueAndDebounce('OP1', debounceDuration, () async => 1),
          queue.queueAndDebounce('OP1', debounceDuration, () async => 2),
        ];

        time.elapse(debounceDuration * 5);
        final List<int> results = await Future.wait(operations);

        expect(results, orderedEquals(<int>[1, 1]));
      });
    });

    testWithoutContext('does not merge results outside of the debounce duration', () async {
      await _runFakeAsync((FakeAsync time) async {
        final List<Future<int>> operations = <Future<int>>[
          queue.queueAndDebounce('OP1', debounceDuration, () async => 1),
          Future<void>.delayed(
            debounceDuration * 2,
          ).then((_) => queue.queueAndDebounce('OP1', debounceDuration, () async => 2)),
        ];

        time.elapse(debounceDuration * 5);
        final List<int> results = await Future.wait(operations);

        expect(results, orderedEquals(<int>[1, 2]));
      });
    });

    testWithoutContext('does not merge results of different operations', () async {
      await _runFakeAsync((FakeAsync time) async {
        final List<Future<int>> operations = <Future<int>>[
          queue.queueAndDebounce('OP1', debounceDuration, () async => 1),
          queue.queueAndDebounce('OP2', debounceDuration, () async => 2),
        ];

        time.elapse(debounceDuration * 5);
        final List<int> results = await Future.wait(operations);

        expect(results, orderedEquals(<int>[1, 2]));
      });
    });

    testWithoutContext('does not run any operations concurrently', () async {
      // Crete a function that's slow, but throws if another instance of the
      // function is running.
      bool isRunning = false;
      Future<int> f(int ret) async {
        if (isRunning) {
          throw Exception('Functions ran concurrently!');
        }
        isRunning = true;
        await Future<void>.delayed(debounceDuration * 2);
        isRunning = false;
        return ret;
      }

      await _runFakeAsync((FakeAsync time) async {
        final List<Future<int>> operations = <Future<int>>[
          queue.queueAndDebounce('OP1', debounceDuration, () => f(1)),
          queue.queueAndDebounce('OP2', debounceDuration, () => f(2)),
        ];

        time.elapse(debounceDuration * 5);
        final List<int> results = await Future.wait(operations);

        expect(results, orderedEquals(<int>[1, 2]));
      });
    });
  });
}

bool _notEvent(DaemonMessage message) => message.data['event'] == null;

bool _isConnectedEvent(DaemonMessage message) => message.data['event'] == 'daemon.connected';

class FakeWindowsWorkflow extends Fake implements WindowsWorkflow {
  FakeWindowsWorkflow({this.canListDevices = true});

  @override
  final bool canListDevices;
}

class FakeAndroidWorkflow extends Fake implements AndroidWorkflow {
  FakeAndroidWorkflow({this.canListDevices = true});

  @override
  final bool canListDevices;
}

class FakeIOSWorkflow extends Fake implements IOSWorkflow {
  FakeIOSWorkflow({this.canListDevices = true});

  @override
  final bool canListDevices;
}

class FakeAndroidDevice extends Fake implements AndroidDevice {
  @override
  final String id = 'device';

  @override
  final String name = 'android device';

  @override
  String get displayName => name;

  @override
  Future<String> get emulatorId async => 'device';

  @override
  Future<TargetPlatform> get targetPlatform async => TargetPlatform.android_arm;

  @override
  Future<bool> get isLocalEmulator async => false;

  @override
  final Category category = Category.mobile;

  @override
  final PlatformType platformType = PlatformType.android;

  @override
  final bool ephemeral = false;

  @override
  final bool isConnected = true;

  @override
  final DeviceConnectionInterface connectionInterface = DeviceConnectionInterface.attached;

  @override
  Future<String> get sdkNameAndVersion async => 'Android 12';

  @override
  bool get supportsHotReload => true;

  @override
  bool get supportsHotRestart => true;

  @override
  bool get supportsScreenshot => true;

  @override
  bool get supportsFastStart => true;

  @override
  bool get supportsFlutterExit => true;

  @override
  Future<bool> get supportsHardwareRendering async => true;

  @override
  bool get supportsStartPaused => true;

  @override
  final FakeDartDevelopmentService dds = FakeDartDevelopmentService();

  BuildMode? supportsRuntimeModeCalledBuildMode;
  @override
  Future<bool> supportsRuntimeMode(BuildMode buildMode) async {
    supportsRuntimeModeCalledBuildMode = buildMode;
    return true;
  }

  late DeviceLogReader logReader;
  @override
  FutureOr<DeviceLogReader> getLogReader({ApplicationPackage? app, bool includePastLogs = false}) =>
      logReader;

  ApplicationPackage? startAppPackage;
  late LaunchResult launchResult;

  @override
  Future<LaunchResult> startApp(
    ApplicationPackage? package, {
    String? mainPath,
    String? route,
    DebuggingOptions? debuggingOptions,
    Map<String, Object?> platformArgs = const <String, Object>{},
    bool prebuiltApplication = false,
    bool ipv6 = false,
    String? userIdentifier,
  }) async {
    startAppPackage = package;
    return launchResult;
  }

  ApplicationPackage? stopAppPackage;
  @override
  Future<bool> stopApp(ApplicationPackage? app, {String? userIdentifier}) async {
    stopAppPackage = app;
    return true;
  }
}

class FakeDartDevelopmentService extends Fake implements DartDevelopmentService {
  bool startCalled = false;
  late Uri startVMServiceUri;
  bool? startDisableServiceAuthCodes;

  bool shutdownCalled = false;

  @override
  late Future<void> done;

  @override
  Uri? uri;

  @override
  Future<void> startDartDevelopmentService(
    Uri vmServiceUri, {
    int? ddsPort,
    FlutterDevice? device,
    bool? ipv6,
    bool? disableServiceAuthCodes,
    bool enableDevTools = false,
    bool cacheStartupProfile = false,
    String? google3WorkspaceRoot,
    Uri? devToolsServerAddress,
  }) async {
    startCalled = true;
    startVMServiceUri = vmServiceUri;
    startDisableServiceAuthCodes = disableServiceAuthCodes;
  }

  @override
  Future<void> shutdown() async {
    shutdownCalled = true;
  }
}

class FakeDeviceLogReader implements DeviceLogReader {
  final StreamController<String> logLinesController = StreamController<String>();
  bool disposeCalled = false;

  @override
  void dispose() {
    disposeCalled = true;
  }

  @override
  Stream<String> get logLines => logLinesController.stream;

  @override
  String get name => 'device';

  @override
  Future<void> provideVmService(FlutterVmService? connectedVmService) async {}
}

class FakeApplicationPackageFactory implements ApplicationPackageFactory {
  TargetPlatform? platformRequested;
  File? applicationBinaryRequested;
  ApplicationPackage? applicationPackage;

  @override
  Future<ApplicationPackage?> getPackageForPlatform(
    TargetPlatform platform, {
    BuildInfo? buildInfo,
    File? applicationBinary,
  }) async {
    platformRequested = platform;
    applicationBinaryRequested = applicationBinary;
    return applicationPackage;
  }
}

class FakeApplicationPackage extends Fake implements ApplicationPackage {}

class TestIOOverrides extends io.IOOverrides {
  late Future<io.Socket> Function(Object? host, int port) connectCallback;

  @override
  Future<io.Socket> socketConnect(
    Object? host,
    int port, {
    Object? sourceAddress,
    int sourcePort = 0,
    Duration? timeout,
  }) {
    return connectCallback(host, port);
  }
}

class FakeSocket extends Fake implements io.Socket {
  bool closeCalled = false;
  final StreamController<Uint8List> controller = StreamController<Uint8List>();
  final List<List<int>> addedData = <List<int>>[];
  final Completer<bool> doneCompleter = Completer<bool>();

  @override
  StreamSubscription<Uint8List> listen(
    void Function(Uint8List event)? onData, {
    Function? onError,
    void Function()? onDone,
    bool? cancelOnError,
  }) {
    return controller.stream.listen(
      onData,
      onError: onError,
      onDone: onDone,
      cancelOnError: cancelOnError,
    );
  }

  @override
  void add(List<int> data) {
    addedData.add(data);
  }

  @override
  Future<void> close() async {
    closeCalled = true;
  }

  @override
  Future<bool> get done => doneCompleter.future;

  @override
  void destroy() {}
}