import 'dart:async';

import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_test/flutter_test.dart';

import 'package:dmc_app/domain/telemetry/system_message.dart';
import 'package:dmc_app/transport/connection_type.dart';
import 'package:dmc_app/transport/flight_controller_link.dart';
import 'package:dmc_app/ui/providers/connection_settings_provider.dart';
import 'package:dmc_app/ui/providers/system_message_log_provider.dart';
import 'package:dmc_app/ui/providers/telemetry_provider.dart';

TelemetryFrame _frame({bool hasFix = true, int numSat = 10}) => TelemetryFrame(
      lat: 52.5,
      lon: 13.4,
      hasFix: hasFix,
      numSat: numSat,
      altitudeM: 100,
      speedMs: 15,
      headingDeg: 0,
      armed: false,
      batteryPercent: 80,
      batteryVoltage: 22.0,
      currentA: 10.0,
      linkQuality: 90,
      snrDb: 5,
      hdop: 1.0,
      navMode: 0,
      flightMode: 'Idle',
    );

typedef _ConnectionSettings = ({
  int? activeDroneProfileId,
  int? currentMissionId,
  String? connectionDeviceAddress,
  bool connectionAutoConnect,
  ConnectionType connectionType,
  String? connectionWifiHost,
  int connectionWifiPort,
  String connectionWifiSsidPrefix,
  String? connectionWifiLastSsid,
});

_ConnectionSettings _settings(ConnectionType type) => (
      activeDroneProfileId: null,
      currentMissionId: null,
      connectionDeviceAddress: null,
      connectionAutoConnect: true,
      connectionType: type,
      connectionWifiHost: null,
      connectionWifiPort: 14550,
      connectionWifiSsidPrefix: 'mLRS-',
      connectionWifiLastSsid: null,
    );

void main() {
  test('loggt "Drone connected" beim ersten Telemetrie-Frame und "Drone '
      'disconnected" bei einem anschliessenden Stream-Fehler', () async {
    final controller = StreamController<TelemetryFrame>();
    addTearDown(controller.close);
    final container = ProviderContainer(overrides: [
      telemetryProvider.overrideWith((ref) => controller.stream),
      connectionSettingsProvider
          .overrideWith((ref) async => _settings(ConnectionType.mock)),
    ]);
    addTearDown(container.dispose);
    container.listen(systemMessageAutoLogProvider, (previous, next) {});

    controller.add(_frame());
    await Future<void>.delayed(Duration.zero);

    final afterConnect = container.read(systemMessageLogProvider);
    expect(afterConnect, hasLength(1));
    expect(afterConnect.single.message, 'Drone connected');
    expect(afterConnect.single.severity, SystemMessageSeverity.info);

    controller.addError(StateError('link down'));
    await Future<void>.delayed(Duration.zero);

    final afterLost = container.read(systemMessageLogProvider);
    expect(afterLost.first.message, 'Drone disconnected');
    expect(afterLost.first.severity, SystemMessageSeverity.critical);
  });

  test('loggt "GPS fix acquired" beim Uebergang auf einen Fix, aber nicht '
      'beim ersten Frame selbst', () async {
    final controller = StreamController<TelemetryFrame>();
    addTearDown(controller.close);
    final container = ProviderContainer(overrides: [
      telemetryProvider.overrideWith((ref) => controller.stream),
      connectionSettingsProvider
          .overrideWith((ref) async => _settings(ConnectionType.mock)),
    ]);
    addTearDown(container.dispose);
    container.listen(systemMessageAutoLogProvider, (previous, next) {});

    // Erster Frame ohne Fix: nur "Drone connected", noch kein GPS-Ereignis
    // (detectSystemMessages() braucht einen vorherigen Frame zum Vergleich).
    controller.add(_frame(hasFix: false, numSat: 2));
    await Future<void>.delayed(Duration.zero);
    expect(container.read(systemMessageLogProvider), hasLength(1));

    controller.add(_frame(hasFix: true, numSat: 9));
    await Future<void>.delayed(Duration.zero);

    final log = container.read(systemMessageLogProvider);
    expect(log.first.message, 'GPS fix acquired (9 satellites)');
    expect(log.first.severity, SystemMessageSeverity.info);
  });

  test('loggt keine "Drone connected"-Meldung, solange nie ein Frame ankommt', () async {
    final container = ProviderContainer(overrides: [
      telemetryProvider.overrideWith((ref) => const Stream<TelemetryFrame>.empty()),
      connectionSettingsProvider
          .overrideWith((ref) async => _settings(ConnectionType.mock)),
    ]);
    addTearDown(container.dispose);

    container.listen(systemMessageAutoLogProvider, (previous, next) {});
    await Future<void>.delayed(Duration.zero);

    expect(container.read(systemMessageLogProvider), isEmpty);
  });

  test('loggt "Connection type changed" bei einer Aenderung, nicht beim '
      'initialen Laden der Einstellungen', () async {
    var type = ConnectionType.wifi;
    final container = ProviderContainer(overrides: [
      telemetryProvider.overrideWith((ref) => const Stream<TelemetryFrame>.empty()),
      connectionSettingsProvider.overrideWith((ref) async => _settings(type)),
    ]);
    addTearDown(container.dispose);

    container.listen(systemMessageAutoLogProvider, (previous, next) {});
    await container.read(connectionSettingsProvider.future);
    expect(container.read(systemMessageLogProvider), isEmpty);

    type = ConnectionType.mock;
    container.invalidate(connectionSettingsProvider);
    await container.read(connectionSettingsProvider.future);

    final log = container.read(systemMessageLogProvider);
    expect(log.single.message, 'Connection type changed to Mock (Test)');
    expect(log.single.severity, SystemMessageSeverity.info);
  });

  test('log() fuegt einen Eintrag manuell hinzu (Doku: Wegpunkte uebertragen)', () async {
    final container = ProviderContainer(overrides: [
      telemetryProvider.overrideWith((ref) => const Stream<TelemetryFrame>.empty()),
      connectionSettingsProvider
          .overrideWith((ref) async => _settings(ConnectionType.mock)),
    ]);
    addTearDown(container.dispose);

    container.read(systemMessageLogProvider.notifier).log('Mission sent (3 waypoints)');
    var log = container.read(systemMessageLogProvider);
    expect(log.single.message, 'Mission sent (3 waypoints)');
    expect(log.single.severity, SystemMessageSeverity.info);

    container.read(systemMessageLogProvider.notifier).log(
          'Mission upload failed: timeout',
          severity: SystemMessageSeverity.critical,
        );
    log = container.read(systemMessageLogProvider);
    expect(log.first.message, 'Mission upload failed: timeout');
    expect(log.first.severity, SystemMessageSeverity.critical);
  });
}