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

void main() {
  group('RiderProfile Models', () {
    test('PresetAvatar contains valid presets and resolves default', () {
      expect(PresetAvatar.availablePresets.isNotEmpty, isTrue);
      final first = PresetAvatar.availablePresets.first;
      expect(PresetAvatar.byId(first.id).id, equals(first.id));
      expect(PresetAvatar.byId('unknown_nonexistent').id, equals(first.id));
    });

    test('ProfilePrivacySettings serialization and defaults', () {
      const defaults = ProfilePrivacySettings();
      expect(defaults.isSearchableByHandle, isTrue);
      expect(defaults.isProfilePublic, isTrue);
      expect(defaults.allowFriendRequests, isTrue);

      final json = defaults.toJson();
      final restored = ProfilePrivacySettings.fromJson(json);
      expect(restored, equals(defaults));

      final modified = defaults.copyWith(isProfilePublic: false);
      expect(modified.isProfilePublic, isFalse);
      expect(modified.isSearchableByHandle, isTrue);
      expect(modified.allowFriendRequests, isTrue);
    });

    test('RiderProfile serialization round-trip', () {
      final now = DateTime(2026, 9, 3, 12, 0, 0);
      final profile = RiderProfile(
        uid: 'user_123',
        handle: 'apex_pilot',
        displayName: 'Apex Pilot',
        bio: 'Weekend track and mountain rider.',
        region: 'North Georgia Mountains',
        avatarPreset: 'helmet_cyan',
        avatarUrl: null,
        privacySettings: const ProfilePrivacySettings(
          isSearchableByHandle: true,
          isProfilePublic: false,
          allowFriendRequests: true,
        ),
        createdAt: now,
        updatedAt: now,
      );

      final json = profile.toJson();
      expect(json['id'], equals('user_123'));
      expect(json['username'], equals('apex_pilot'));
      expect(json['displayName'], equals('Apex Pilot'));
      expect(json['bio'], equals('Weekend track and mountain rider.'));
      expect(json['location'], equals('North Georgia Mountains'));
      expect(json['avatarPreset'], equals('helmet_cyan'));

      final restored = RiderProfile.fromJson(json);
      expect(restored.uid, equals(profile.uid));
      expect(restored.handle, equals(profile.handle));
      expect(restored.displayName, equals(profile.displayName));
      expect(restored.bio, equals(profile.bio));
      expect(restored.region, equals(profile.region));
      expect(restored.avatarPreset, equals(profile.avatarPreset));
      expect(restored.privacySettings.isProfilePublic, isFalse);
      expect(restored.displayHandle, equals('@apex_pilot'));
    });

    test('FriendSummary serialization round-trip', () {
      final now = DateTime(2026, 9, 3, 14, 30);
      final summary = FriendSummary(
        uid: 'user_456',
        handle: 'track_demon',
        displayName: 'Track Demon',
        avatarPreset: 'tach_neon',
        friendedAt: now,
      );

      final json = summary.toJson();
      final restored = FriendSummary.fromJson(json);
      expect(restored.uid, equals('user_456'));
      expect(restored.handle, equals('track_demon'));
      expect(restored.displayHandle, equals('@track_demon'));
      expect(restored.avatarPreset, equals('tach_neon'));
    });

    test('FriendRequest serialization round-trip', () {
      final now = DateTime(2026, 9, 3, 15, 0);
      final request = FriendRequest(
        requestId: 'req_001',
        senderUid: 'sender_01',
        senderHandle: 'sender_pilot',
        senderDisplayName: 'Sender Pilot',
        senderAvatarPreset: 'helmet_amber',
        receiverUid: 'receiver_02',
        sentAt: now,
      );

      final json = request.toJson();
      final restored = FriendRequest.fromJson(json);
      expect(restored.requestId, equals('req_001'));
      expect(restored.senderUid, equals('sender_01'));
      expect(restored.receiverUid, equals('receiver_02'));
    });

    test('BlockedRider serialization round-trip', () {
      final now = DateTime(2026, 9, 3, 16, 0);
      final block = BlockedRider(
        blockedUid: 'spammer_99',
        blockedHandle: 'spammer',
        blockedDisplayName: 'Bad Actor',
        blockedAt: now,
      );

      final json = block.toJson();
      final restored = BlockedRider.fromJson(json);
      expect(restored.blockedUid, equals('spammer_99'));
      expect(restored.blockedHandle, equals('spammer'));
    });
  });

  group('RiderProfileService validation and offline fallback', () {
    test('rejects invalid handles on saveProfile', () async {
      final service = RiderProfileService();

      expect(
        () => service.saveProfile(
          uid: 'uid_1',
          handle: 'no', // too short
          displayName: 'Rider',
        ),
        throwsA(isA<ArgumentError>()),
      );

      expect(
        () => service.saveProfile(
          uid: 'uid_1',
          handle: 'admin', // reserved
          displayName: 'Admin User',
        ),
        throwsA(isA<ArgumentError>()),
      );
    });

    test('creates offline profile when Firestore is unconfigured', () async {
      final service = RiderProfileService();
      final profile = await service.saveProfile(
        uid: 'uid_local',
        handle: 'local_pilot',
        displayName: 'Local Pilot',
        bio: 'Local solo rider',
      );

      expect(profile.uid, equals('uid_local'));
      expect(profile.handle, equals('local_pilot'));
      expect(profile.displayName, equals('Local Pilot'));
      expect(profile.bio, equals('Local solo rider'));
    });
  });
}