/// L'IU de configuration, **sur l'appareil, contre la vraie box**.
///
/// ## Pourquoi ce test existe sous cette forme
///
/// `adb shell input tap` est refusé sur le Redmi Note 9S :
/// `SecurityException: Injecting to another application requires INJECT_EVENTS
/// permission` — verrou MIUI qui demande un compte Xiaomi pour se lever. Un test
/// `integration_test` ne passe pas par là : il s'exécute **dans le processus de l'app** et
/// tape sur les widgets depuis l'intérieur. C'est donc bien l'application réelle, sur le
/// téléphone réel, parlant à `.75` par le réseau.
///
/// ## Ce qu'il exerce, et ce qu'il rend au banc
///
/// Il se connecte, ouvre l'écran fusionné, lit les charges **réelles**, puis écrit deux
/// fois : un renommage (mise à jour en place — aucun verrou réarmé) et sa restauration.
/// Rien de matériel n'est touché : le test ne réordonne aucun contacteur et ne désactive
/// aucune charge, parce que ces gestes ouvrent des contacts et réarment des verrous sur
/// une installation qui n'est pas la sienne.
///
/// Lancement :
/// ```sh
/// flutter test integration_test/config_on_device_test.dart -d dee659e2
/// ```
library;

import 'package:etm_powersync_app/main.dart' as app;
import 'package:etm_powersync_app/providers/energy_setup_provider.dart';
import 'package:etm_powersync_app/providers/installer_mode_provider.dart';
import 'package:etm_powersync_app/providers/load_config_provider.dart';
import 'package:etm_powersync_app/providers/load_telemetry_provider.dart';
import 'package:etm_powersync_app/providers/schema_provider.dart';
import 'package:etm_powersync_app/screens/energy/roles_devices_screen.dart';
import 'package:etm_powersync_app/services/connection_manager.dart';
import 'package:etm_powersync_app/services/nymea_service.dart';
import 'package:etm_powersync_app/services/rpc_schema.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:go_router/go_router.dart';
import 'package:integration_test/integration_test.dart';
import 'package:provider/provider.dart';

/// La box de banc. `nymea-dev-rpi` doit être déjà enregistrée sur l'appareil.
const _hote = '192.168.1.75';

/// PIN installateur par défaut, posé au premier démarrage tant qu'aucun n'a été choisi.
const _pinInstallateur = '1234';

/// Pompe jusqu'à ce que [cond] soit vraie, ou échoue en le disant.
///
/// `pumpAndSettle` ne convient pas ici : l'app garde des animations et un flux de
/// notifications vivants tant qu'elle est connectée, si bien qu'elle ne « se pose »
/// jamais. On pompe donc par pas fixes.
Future<void> _attendre(
  WidgetTester tester,
  bool Function() cond, {
  Duration limite = const Duration(seconds: 30),
  String quoi = 'condition',
}) async {
  final fin = DateTime.now().add(limite);
  while (DateTime.now().isBefore(fin)) {
    await tester.pump(const Duration(milliseconds: 250));
    if (cond()) return;
  }
  fail('délai dépassé en attendant : $quoi');
}

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  testWidgets('configuration des charges, sur appareil, contre .75',
      (tester) async {
    app.main();
    await tester.pump(const Duration(seconds: 3));

    // ── 1. Connexion à la box de banc ────────────────────────────────────────
    //
    // Le test ENREGISTRE lui-même la box au lieu de compter sur une installation déjà
    // stockée. Ce n'est pas du confort : `flutter test integration_test` **réinstalle**
    // l'app, ce qui vide `shared_preferences` et le stockage sécurisé — donc efface les
    // installations. Un test qui suppose l'état du téléphone échouerait dès le premier
    // run et, pire, laisserait l'appareil sans aucune box enregistrée.
    //
    // `connectNew()` se connecte ET persiste : la box est donc rendue au téléphone.
    final ctx = tester.element(find.byType(MaterialApp).first);
    final svc = Provider.of<NymeaService>(ctx, listen: false);
    final cnx = Provider.of<ConnectionManager>(ctx, listen: false);

    if (!svc.isConnected) {
      // ignore: unawaited_futures
      cnx.connectNew(host: _hote);
    }
    await _attendre(tester, () => svc.isConnected,
        limite: const Duration(seconds: 60), quoi: 'la connexion à $_hote');

    // ── 2. Le schéma est lu à la connexion, pas à l'ouverture d'un écran ─────
    final schema = Provider.of<SchemaProvider>(ctx, listen: false);
    await _attendre(tester, () => schema.schema.loaded,
        limite: const Duration(seconds: 30), quoi: 'la lecture du schéma');
    expect(schema.schema.hasMethod('NymeaEnergy.SetLoadConfig'), isTrue);
    expect(schema.schema.experienceVersions['NymeaEnergy'], isNotNull);
    debugPrint('[appareil] schéma lu — ${schema.versionLine()}');

    // ── 3. L'écran fusionné, et les charges RÉELLES de la box ────────────────
    //
    // Le contexte du MaterialApp est AU-DESSUS du Router : `GoRouter.of` n'y trouve
    // rien. On prend donc un contexte pris sous lui — celui d'un Scaffold affiché.
    // `/energy/setup` est une route RÉSERVÉE AU MODE INSTALLATEUR : le routeur la renvoie
    // vers `/` tant qu'il est verrouillé (`_isInstallerRoute`). Ce n'est pas un défaut —
    // c'est le même verrou qui masque l'ajout d'installation. Sans déverrouillage, la
    // navigation « réussit » sans rien monter, et le symptôme observé est « aucune
    // charge » : un diagnostic parfaitement trompeur, d'où le contrôle de montage plus bas.
    final installateur = Provider.of<InstallerModeProvider>(ctx, listen: false);
    if (!installateur.isUnlocked) {
      await installateur.unlock(_pinInstallateur);
      await tester.pump(const Duration(milliseconds: 500));
    }
    expect(installateur.isUnlocked, isTrue,
        reason: 'le PIN installateur par défaut doit ouvrir les écrans de configuration');
    debugPrint('[appareil] mode installateur déverrouillé');

    final ctxSousRouteur = tester.element(find.byType(Scaffold).first);
    GoRouter.of(ctxSousRouteur).go('/energy/setup');
    await tester.pump(const Duration(seconds: 3));

    // L'écran DOIT être monté : c'est son initState qui branche LoadConfigProvider sur le
    // service et déclenche la lecture. Si la navigation n'a pas eu lieu, le symptôme
    // serait « aucune charge » — un diagnostic trompeur. On vérifie donc d'abord.
    await _attendre(
      tester,
      () => find.byType(RolesDevicesScreen).evaluate().isNotEmpty,
      quoi: 'le montage de l\'écran « Rôles & appareils »',
    );
    debugPrint('[appareil] écran de configuration monté');

    final config = Provider.of<LoadConfigProvider>(ctx, listen: false);
    await _attendre(tester, () => config.entries.isNotEmpty,
        limite: const Duration(seconds: 40),
        quoi: 'les charges de GetLoadConfig '
            '(erreur du provider : ${config.error ?? "aucune"})');

    final ids = config.entries.map((e) => e.id).toList()..sort();
    debugPrint('[appareil] charges lues : $ids');
    expect(ids, contains('chauffe-eau'));
    expect(ids, contains('pac-terrain'));

    // Les deux charges s'affichent, avec un bouton de détail chacune.
    await _attendre(
      tester,
      () => find.text('Configurer').evaluate().length >= 2,
      quoi: 'les cartes de charge à l\'écran',
    );
    expect(find.text('chauffe-eau'), findsWidgets);

    // La PAC vient du lot B-bis : avant lui, elle était arbitrée sans être
    // configurable. Sa présence ICI est la preuve visible du contrat.
    expect(find.text('PAC banc'), findsWidgets);

    // ── 4. Une écriture RÉELLE, non matérielle, et sa confirmation ───────────
    final avant = config.entries.firstWhere((e) => e.id == 'chauffe-eau');
    const nouveau = 'chauffe-eau (sonde appareil)';

    config.setLabel('chauffe-eau', nouveau);
    await tester.pump(const Duration(milliseconds: 400));
    expect(config.hasPendingChanges, isTrue);
    // Un renommage ne touche à aucun matériel : rien à annoncer.
    expect(config.pendingNeedsWarning, isFalse);

    await config.save();
    // La confirmation est `LoadConfigChanged`, PAS l'accusé du RPC — mesuré sur le banc,
    // la notification arrive la première.
    await _attendre(
      tester,
      () => config.saveState == LoadSaveState.confirmed ||
          config.saveState == LoadSaveState.diverged ||
          config.saveState == LoadSaveState.rejected,
      limite: const Duration(seconds: 20),
      quoi: 'la confirmation par LoadConfigChanged',
    );
    debugPrint('[appareil] écriture → ${config.saveState}');
    expect(config.saveState, LoadSaveState.confirmed);
    expect(
      config.entries.firstWhere((e) => e.id == 'chauffe-eau').label,
      nouveau,
    );

    // ── 5. Restauration — le banc n'appartient pas au test ──────────────────
    config.setLabel('chauffe-eau', avant.label);
    await tester.pump(const Duration(milliseconds: 400));
    await config.save();
    await _attendre(
      tester,
      () => config.saveState == LoadSaveState.confirmed &&
          config.entries.firstWhere((e) => e.id == 'chauffe-eau').label ==
              avant.label,
      limite: const Duration(seconds: 20),
      quoi: 'la restauration du libellé',
    );
    debugPrint('[appareil] libellé restauré : ${avant.label}');

    // ── 5-bis. LE GLISSEMENT, sur l'appareil, contre la vraie box ───────────
    //
    // Le test décisif. Il n'a de sens que si les deux charges partagent un domaine —
    // sinon il n'y a rien à réordonner, et c'est précisément ce qui donnait l'impression
    // que « rien ne fonctionne ». Poser le classement se fait hors de ce test
    // (`tools/rpc/domain_assign.dart --set chauffe-eau=ecs --set pac-terrain=ecs`) ; ici
    // on constate, et on saute proprement si la condition n'est pas réunie.
    final parDomaine = <String, int>{};
    for (final e in config.entries) {
      parDomaine.update(e.domain ?? '', (v) => v + 1, ifAbsent: () => 1);
    }
    final memeDomaine = parDomaine.values.any((n) => n > 1);
    debugPrint('[appareil] charges par domaine : $parDomaine');

    if (!memeDomaine) {
      debugPrint('[appareil] GLISSEMENT NON EXERCÉ — une seule charge par domaine, '
          'il n\'y a rien à réordonner. Poser deux charges dans un même domaine, '
          'puis relancer.');
    } else {
      final ordreAvant = [
        for (final g in config.groups) ...g.loads.map((e) => e.id)
      ];
      final premier = ordreAvant.first;
      final poignee = find.byKey(ValueKey('poignee-charge-$premier'));
      final cible = find.byKey(ValueKey('load-${ordreAvant[1]}'));
      expect(poignee, findsOneWidget, reason: 'poignée de $premier absente');

      final dy = tester.getSize(cible).height * 2;
      final g = await tester.startGesture(tester.getCenter(poignee));
      await tester.pump(const Duration(milliseconds: 60));
      for (var i = 0; i < 12; i++) {
        await g.moveBy(Offset(0, dy / 12));
        await tester.pump(const Duration(milliseconds: 16));
      }
      await g.up();
      await tester.pump(const Duration(milliseconds: 400));

      final ordreApres = [
        for (final g in config.groups) ...g.loads.map((e) => e.id)
      ];
      debugPrint('[appareil] glissement : $ordreAvant → $ordreApres');
      expect(ordreApres.first, isNot(premier),
          reason: 'le glissement doit réordonner sur l\'appareil aussi');

      // Le brouillon ne part PAS : le rang du banc n'appartient pas au test.
      config.discardDraft();
      await tester.pump(const Duration(milliseconds: 200));
      debugPrint('[appareil] brouillon abandonné — rien n\'est écrit sur la box');
    }

    // ── 5-bis-bis. Le compteur racine est RELU, pas redemandé ───────────────
    //
    // Il vivait sur la box sans que l'app le lise jamais : le rôle repartait « à
    // configurer » à chaque démarrage. Une configuration jamais lue se présente comme une
    // configuration perdue — et pousse à refaire un geste inutile.
    final racine = await svc.getRootMeter();
    debugPrint('[appareil] compteur racine lu sur la box : ${racine ?? 'AUCUN'}');
    expect(racine, isNotNull,
        reason: '.75 déclare un compteur racine : l\'app doit pouvoir le lire');

    final setup = Provider.of<EnergySetupProvider>(ctx, listen: false);
    await setup.syncRootMeter(svc);
    await tester.pump(const Duration(milliseconds: 300));
    expect(setup.toConfigureRoles.map((r) => r.name), isNot(contains('gridMeter')),
        reason: 'le compteur racine ne doit plus être réclamé une fois lu');
    // Et les CHARGES n'ont plus rien à faire dans ce décompte : elles viennent de
    // GetLoadConfig depuis la fusion.
    for (final charge in ['dhw', 'heatPump', 'battery', 'evCharger']) {
      expect(setup.toConfigureRoles.map((r) => r.name), isNot(contains(charge)),
          reason: '« $charge » est une charge : elle ne se configure plus par un rôle');
    }
    debugPrint('[appareil] « à configurer » : '
        '${setup.toConfigureRoles.map((r) => r.name).toList()}');

    // ── 5-septies. Les bornes de recharge, toutes, et sans rang ─────────────
    //
    // Elles ne sont pas des LoadConfig : elles n'ont ni adapter, ni priority, ni domain,
    // et n'apparaissent dans aucun domaine. Sans leur section, une borne configurée serait
    // simplement invisible. La liste vient de l'interface nymea `evcharger`, donc toute
    // borne appairée y entre — y compris une seconde.
    final classesBorne = {
      for (final c in svc.thingClasses)
        if (c.interfaces.contains('evcharger')) c.id
    };
    final bornes = [
      for (final t in svc.things)
        if (classesBorne.contains(t.thingClassId)) t.name
    ];
    debugPrint('[appareil] bornes vues : $bornes');
    expect(bornes, isNotEmpty, reason: '.75 en déclare au moins une');

    // ── 5-ter. Le chip de domaine PORTE son libellé ─────────────────────────
    //
    // Il ne rendait qu'une étiquette dessinée : le domaine d'une charge était illisible
    // sur sa carte, alors que c'est lui qui décide de son groupe et de son rang.
    final chip = find.byKey(const ValueKey('chip-domaine-chauffe-eau'));
    await _attendre(tester, () => chip.evaluate().isNotEmpty,
        quoi: 'le chip de domaine de chauffe-eau');
    final texteChip = find
        .descendant(of: chip, matching: find.byType(Text))
        .evaluate()
        .map((e) => (e.widget as Text).data)
        .whereType<String>()
        .toList();
    debugPrint('[appareil] chip de domaine : $texteChip');
    expect(texteChip.any((t) => t.trim().isNotEmpty), isTrue,
        reason: 'le chip doit porter un libellé, pas seulement une icône');

    // ── 5-quinquies. Les paliers viennent de la BOX, pas d'un calcul de l'app ──
    //
    // `+etm16` publie `mechanism.stagesW`. Une seule fonction moteur sert la construction
    // du routeur, la comparaison matérielle et cette publication : l'app n'a plus de
    // combinatoire à refaire, donc plus de divergence possible.
    final live = Provider.of<LoadTelemetryProvider>(ctx, listen: false)
        .entryFor('chauffe-eau');
    final stages = live?.mechanism?.stagesW;
    debugPrint('[appareil] paliers publiés par la box : $stages');
    expect(stages, isNotNull,
        reason: '.75 est en +etm16 : stagesW doit être publié');
    expect(stages, [0, 500, 1000, 1500, 2000, 2500, 3000, 3500]);

    // ── 5-sexies. Les deux champs de mesure sont ARRIVÉS au schéma ──────────
    //
    // Ils étaient grisés « pas encore supporté ». `+etm16` les porte : le grisage dérivé
    // du schéma les a donc activés SEUL, sans nouvelle version de l'app.
    for (final champ in ['meterThingId', 'sensorThingId']) {
      final sup = schema.schema.paramSupport(
          'NymeaEnergy.SetLoadConfig', ['loadConfigs', '[]', champ]);
      debugPrint('[appareil] $champ → $sup');
      expect(sup, FieldSupport.writable,
          reason: '.75 est en +etm16 : « $champ » doit être écrivable');
    }

    // ── 5-quater. L'écran de mécanisme, et son sélecteur ACTIF ──────────────
    // Le bouton est sous la ligne de flottaison : il faut l'amener à l'écran avant de
    // taper, sinon le geste ne porte sur rien.
    final boutons = find.text('Configurer');
    await tester.ensureVisible(boutons.first);
    await tester.pump(const Duration(milliseconds: 400));
    await tester.tap(boutons.first);
    await tester.pump(const Duration(milliseconds: 600));
    await _attendre(tester, () => find.text('Mécanisme').evaluate().isNotEmpty,
        quoi: 'l\'ouverture de l\'écran de mécanisme');

    for (final m in ['Routeur de relais', 'Modulable', 'SG-Ready']) {
      expect(find.text(m), findsWidgets,
          reason: 'le sélecteur de mécanisme doit proposer « $m »');
    }
    // Les sections attendues DÉPENDENT du mécanisme ouvert — c'est tout l'objet de ces
    // écrans : ils ne se ressemblent pas. « Configurer » ouvre la première carte, et
    // l'ordre des domaines n'est pas fixe ; on regarde donc ce qui s'est ouvert.
    final estRelais = find.text('Relais commandés').evaluate().isNotEmpty ||
        find.text('Contacts SG-Ready').evaluate().isEmpty;
    final attendues = estRelais
        ? <String>['Relais commandés', 'Temporisations', 'Compteur dédié',
            'Sonde de température', 'Arbitrage']
        : <String>['Contacts SG-Ready', 'Table d\'états', 'Compteur dédié',
            'Sonde de température', 'Arbitrage'];

    final vues = <String>{};
    for (var pas = 0; pas < 30 && vues.length < attendues.length; pas++) {
      for (final t in attendues) {
        if (find.text(t).evaluate().isNotEmpty) vues.add(t);
      }
      if (vues.length == attendues.length) break;
      await tester.drag(
          find.byKey(const ValueKey('liste-mecanisme')), const Offset(0, -150));
      await tester.pump(const Duration(milliseconds: 250));
    }
    debugPrint('[appareil] écran de mécanisme (${estRelais ? "relais" : "SG-Ready"}) — '
        'sélecteur : Routeur de relais / Modulable / SG-Ready ; sections vues : '
        '${vues.join(' · ')} (${vues.length}/${attendues.length})');
    for (final t in attendues) {
      expect(vues, contains(t), reason: 'section « $t » jamais atteinte');
    }

    // On repart sans rien changer.
    Navigator.of(tester.element(find.text('Arbitrage').first)).pop();
    await tester.pump(const Duration(seconds: 1));

    // ── 6. On laisse l'écran affiché ────────────────────────────────────────
    //
    // `flutter test integration_test` referme l'app dès la dernière assertion. Sans
    // cette pause, il n'y a matériellement rien à voir sur le téléphone : d'où
    // l'impression que « rien ne tourne » alors que tout s'est exécuté. On tient donc
    // l'écran ouvert le temps de le regarder et d'en prendre une capture.
    // ORDRE IMPORTANT : on tient l'écran D'ABORD, on reverrouille APRÈS.
    //
    // Reverrouiller avant la pause renvoie immédiatement vers `/` — `/energy/setup` est
    // une route installateur et le `redirect` du routeur s'applique en continu. La
    // première version faisait l'inverse : le test passait, mais la capture montrait le
    // tableau de bord. Le verrou marchait trop bien.
    debugPrint('[appareil] écran maintenu 90 s — regardez le téléphone');
    for (var i = 0; i < 360; i++) {
      await tester.pump(const Duration(milliseconds: 250));
    }

    // Le mode installateur ne reste pas ouvert derrière le test.
    installateur.lock();
    await tester.pump(const Duration(milliseconds: 500));
    debugPrint('[appareil] mode installateur reverrouillé');
  });
}