import 'package:commons_core/commons_core.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:tane/state/trust_cubit.dart';

/// In-memory [TrustTransport]: certify/revoke act as this device's identity.
class FakeTrustTransport implements TrustTransport {
  FakeTrustTransport(this.selfId);
  final String selfId;
  final Map<String, Set<String>> _certs = {};

  @override
  Future<Set<String>> certifiersOf(String subjectPubkey) async =>
      _certs[subjectPubkey] ?? <String>{};

  @override
  Future<void> certify({
    required String subjectPubkey,
    Duration validity = const Duration(days: 365),
    String note = '',
  }) async =>
      (_certs[subjectPubkey] ??= {}).add(selfId);

  @override
  Future<void> revoke({required String subjectPubkey}) async =>
      _certs[subjectPubkey]?.remove(selfId);

  @override
  Future<List<Certification>> allCertifications() async => const [];

  @override
  Future<void> close() async {}
}

void main() {
  const me = 'me';
  const peer = 'peer';

  test('loads certifier count and whether I vouch', () async {
    final transport = FakeTrustTransport(me);
    await transport.certify(subjectPubkey: peer); // I already vouch
    final cubit = TrustCubit(transport, peerPubkey: peer, selfPubkey: me);
    await cubit.load();
    expect(cubit.state.certifierCount, 1);
    expect(cubit.state.iVouch, isTrue);
    expect(cubit.state.loading, isFalse);
    await cubit.close();
  });

  test('toggleVouch certifies then revokes', () async {
    final cubit =
        TrustCubit(FakeTrustTransport(me), peerPubkey: peer, selfPubkey: me);
    await cubit.load();
    expect(cubit.state.iVouch, isFalse);

    await cubit.toggleVouch();
    expect(cubit.state.iVouch, isTrue);
    expect(cubit.state.certifierCount, 1);

    await cubit.toggleVouch();
    expect(cubit.state.iVouch, isFalse);
    expect(cubit.state.certifierCount, 0);
    await cubit.close();
  });

  test('never vouches for self', () async {
    final cubit =
        TrustCubit(FakeTrustTransport(me), peerPubkey: me, selfPubkey: me);
    await cubit.load();
    await cubit.toggleVouch();
    expect(cubit.state.iVouch, isFalse);
    await cubit.close();
  });

  test('offline (no transport) never throws', () async {
    final cubit = TrustCubit(null, peerPubkey: peer, selfPubkey: me);
    expect(cubit.isOnline, isFalse);
    await cubit.load();
    await cubit.toggleVouch();
    expect(cubit.state.loading, isFalse);
    await cubit.close();
  });
}