import 'package:eatvio_app/features/auth/entities/auth_result_entity.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:vk_id/vk_id.dart';

void main() {
  group('AuthResultEntity', () {
    test('creates AuthResultEntity with all required parameters', () {
      const entity = AuthResultEntity(
        accessToken: 'access_token_123',
        userId: 'user_123',
        clientId: 'client_123',
      );

      expect(entity.accessToken, 'access_token_123');
      expect(entity.userId, 'user_123');
      expect(entity.clientId, 'client_123');
      expect(entity.refreshToken, null);
      expect(entity.firstName, null);
      expect(entity.lastName, null);
      expect(entity.email, null);
      expect(entity.phone, null);
      expect(entity.gender, null);
      expect(entity.birthDate, null);
    });

    test('creates AuthResultEntity with all optional parameters', () {
      const entity = AuthResultEntity(
        accessToken: 'access_token_456',
        userId: 'user_456',
        clientId: 'client_456',
        refreshToken: 'refresh_token_456',
        firstName: 'John',
        lastName: 'Doe',
        email: 'john.doe@example.com',
        phone: '+1234567890',
        gender: GenderEnum.male,
        birthDate: '1990-01-01',
      );

      expect(entity.accessToken, 'access_token_456');
      expect(entity.userId, 'user_456');
      expect(entity.clientId, 'client_456');
      expect(entity.refreshToken, 'refresh_token_456');
      expect(entity.firstName, 'John');
      expect(entity.lastName, 'Doe');
      expect(entity.email, 'john.doe@example.com');
      expect(entity.phone, '+1234567890');
      expect(entity.gender, GenderEnum.male);
      expect(entity.birthDate, '1990-01-01');
    });

    test('creates AuthResultEntity with different genders', () {
      const maleEntity = AuthResultEntity(
        accessToken: 'token1',
        userId: 'user1',
        clientId: 'client1',
        gender: GenderEnum.male,
      );

      const femaleEntity = AuthResultEntity(
        accessToken: 'token2',
        userId: 'user2',
        clientId: 'client2',
        gender: GenderEnum.female,
      );

      const notSetEntity = AuthResultEntity(
        accessToken: 'token3',
        userId: 'user3',
        clientId: 'client3',
        gender: GenderEnum.notSet,
      );

      expect(maleEntity.gender, GenderEnum.male);
      expect(femaleEntity.gender, GenderEnum.female);
      expect(notSetEntity.gender, GenderEnum.notSet);
    });
  });

  group('GenderEnum', () {
    test('fromString returns correct enum for male', () {
      expect(GenderEnum.fromString('male'), GenderEnum.male);
    });

    test('fromString returns correct enum for female', () {
      expect(GenderEnum.fromString('female'), GenderEnum.female);
    });

    test('fromString returns correct enum for notSet', () {
      expect(GenderEnum.fromString('notSet'), GenderEnum.notSet);
    });

    test('fromString returns null for invalid string', () {
      expect(GenderEnum.fromString('invalid'), null);
      expect(GenderEnum.fromString(''), null);
      expect(GenderEnum.fromString(null), null);
    });

    test('has all expected enum values', () {
      expect(GenderEnum.male, isNotNull);
      expect(GenderEnum.female, isNotNull);
      expect(GenderEnum.notSet, isNotNull);
    });

    test('fromVkGender returns correct enum for VkSex.male', () {
      expect(GenderEnum.fromVkGender(VkSex.male), GenderEnum.male);
    });

    test('fromVkGender returns correct enum for VkSex.female', () {
      expect(GenderEnum.fromVkGender(VkSex.female), GenderEnum.female);
    });

    test('fromVkGender returns correct enum for VkSex.notStated', () {
      expect(GenderEnum.fromVkGender(VkSex.notStated), GenderEnum.notSet);
    });

    test('fromVkGender returns null for null VkSex', () {
      expect(GenderEnum.fromVkGender(null), null);
    });
  });
}