import 'package:flutter_test/flutter_test.dart';
import 'package:motorcycle_dash/services/social/friendship_service.dart';
import 'package:motorcycle_dash/services/social/rider_profile_models.dart';
import 'package:motorcycle_dash/services/social/rider_search_service.dart';

void main() {
  group('FriendshipService offline & validation contracts', () {
    test('cannot send friend request to self', () async {
      final service = FriendshipService();
      final profile = RiderProfile(
        uid: 'user_self',
        handle: 'self_pilot',
        displayName: 'Self Pilot',
        createdAt: DateTime.now(),
        updatedAt: DateTime.now(),
      );

      expect(
        () => service.sendFriendRequest(
          sender: profile,
          receiverUid: 'user_self',
        ),
        throwsA(isA<ArgumentError>()),
      );
    });

    test('determines relationship self for identical UIDs', () async {
      final service = FriendshipService();
      final status = await service.getRelationshipStatus('user_a', 'user_a');
      expect(status, equals(FriendshipStatus.self));
    });

    test('falls back gracefully when offline', () async {
      final service = FriendshipService();
      final status = await service.getRelationshipStatus('user_a', 'user_b');
      expect(status, equals(FriendshipStatus.none));

      final friendsStream = service.friendsStream('user_a');
      expect(await friendsStream.first, isEmpty);

      final incomingStream = service.incomingRequestsStream('user_a');
      expect(await incomingStream.first, isEmpty);

      final outgoingStream = service.outgoingRequestsStream('user_a');
      expect(await outgoingStream.first, isEmpty);

      final blockedStream = service.blockedRidersStream('user_a');
      expect(await blockedStream.first, isEmpty);
    });
  });

  group('RiderSearchService validation contracts', () {
    test('rejects invalid handles before network call', () async {
      final service = RiderSearchService();
      final result = await service.searchByHandle(
        rawHandle: 'no', // too short
        callerUid: 'caller_1',
      );
      expect(result, isNull);

      final reservedResult = await service.searchByHandle(
        rawHandle: 'admin',
        callerUid: 'caller_1',
      );
      expect(reservedResult, isNull);
    });

    test('returns self status when searching own handle while offline', () async {
      final service = RiderSearchService();
      // When offline, profile service returns null for unmocked UID, gracefully returning null
      final result = await service.searchByHandle(
        rawHandle: 'my_handle',
        callerUid: 'my_uid',
      );
      expect(result, isNull);
    });
  });
}