import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';
import 'package:dio/dio.dart';
import 'package:quiz_app/core/endpoint/api_endpoint.dart';
import 'package:quiz_app/data/models/login/login_request_model.dart';
import 'package:quiz_app/data/models/register/register_request.dart';
import 'package:quiz_app/data/services/auth_service.dart';

class MockDio extends Mock implements Dio {}

void main() {
  late MockDio mockDio;
  late AuthService authService;

  setUp(() {
    mockDio = MockDio();
    authService = AuthService();
    authService.dio = mockDio;
  });

  group('AuthService with Mocktail (Using Real Data)', () {
    test('Register Success', () async {
      final request = RegisterRequestModel(
        email: 'danakhdan@gmail.com',
        password: '123456',
        name: 'Akhdan Robbani',
        birthDate: '12-07-2002',
      );

      when(() => mockDio.post(APIEndpoint.register, data: request.toJson())).thenAnswer((_) async => Response(
            statusCode: 200,
            data: {},
            requestOptions: RequestOptions(path: APIEndpoint.register),
          ));

      final result = await authService.register(request);

      expect(result, true);
      verify(() => mockDio.post(APIEndpoint.register, data: request.toJson())).called(1);
    });

    test('Register Failure', () async {
      final request = RegisterRequestModel(
        email: 'danakhdan@gmail.com',
        password: '123456',
        name: 'Akhdan Robbani',
        birthDate: '12-07-2002',
      );

      when(() => mockDio.post(APIEndpoint.register, data: request.toJson())).thenAnswer((_) async => Response(
            statusCode: 400,
            data: {'message': 'Registration failed'},
            requestOptions: RequestOptions(path: APIEndpoint.register),
          ));

      expect(() => authService.register(request), throwsException);
      verify(() => mockDio.post(APIEndpoint.register, data: request.toJson())).called(1);
    });

    test('Login With Email Success', () async {
      final request = LoginRequestModel(email: 'danakhdan@gmail.com', password: '123456');
      final responseData = {
        'message': 'Login success',
        'data': {
          'id': 'lkasjd93093j4oi234n1234',
          'email': 'danakhdan@gmail.com',
          'name': 'Akhdan Robbani',
          'birth_date': '2002-08-13 07:00:00',
          'pic_url': 'https://example.com/akhdan.png',
          'phone': '081234567890',
          'locale': 'id-ID',
        },
        'meta': null,
      };

      when(() => mockDio.post(APIEndpoint.login, data: request.toJson())).thenAnswer((_) async => Response(
            statusCode: 200,
            data: responseData,
            requestOptions: RequestOptions(path: APIEndpoint.login),
          ));

      final result = await authService.loginWithEmail(request);

      expect(result.name, 'Akhdan Robbani');
      expect(result.email, 'danakhdan@gmail.com');
      expect(result.birthDate, DateTime.parse('2002-08-13 07:00:00'));
      expect(result.phone, '081234567890');
      expect(result.locale, 'id-ID');
      verify(() => mockDio.post(APIEndpoint.login, data: request.toJson())).called(1);
    });

    test('Login With Email Failure - Invalid Credentials', () async {
      final request = LoginRequestModel(email: 'danakhdan@gmail.com', password: 'wrongpassword');

      when(() => mockDio.post(APIEndpoint.login, data: request.toJson())).thenAnswer((_) async => Response(
            statusCode: 401,
            data: {'message': 'Invalid credentials'},
            requestOptions: RequestOptions(path: APIEndpoint.login),
          ));

      expect(() => authService.loginWithEmail(request), throwsException);
      verify(() => mockDio.post(APIEndpoint.login, data: request.toJson())).called(1);
    });

    test('Login With Google Success', () async {
      final idToken = 'valid_google_token';
      final responseData = {
        'message': 'Login success',
        'data': {
          'id': '680e5a6d2f480bd75db17a09',
          'email': 'danakhdan@gmail.com',
          'name': 'Akhdan Robbani',
          'birth_date': '2002-08-13 07:00:00',
          'pic_url': null,
          'phone': '081234567890',
          'locale': 'id-ID'
        },
        'meta': null
      };

      when(() => mockDio.post(APIEndpoint.loginGoogle, data: {"token_id": idToken})).thenAnswer((_) async => Response(
            statusCode: 200,
            data: responseData,
            requestOptions: RequestOptions(path: APIEndpoint.loginGoogle),
          ));

      final result = await authService.loginWithGoogle(idToken);

      expect(result.name, 'Akhdan Robbani');
      expect(result.email, 'danakhdan@gmail.com');
      expect(result.birthDate, DateTime.parse('2002-08-13 07:00:00'));
      expect(result.phone, '081234567890');
      expect(result.locale, 'id-ID');
      verify(() => mockDio.post(APIEndpoint.loginGoogle, data: {"token_id": idToken})).called(1);
    });

    test('Login With Google Failure - Invalid Token', () async {
      final idToken = 'invalid_google_token';

      when(() => mockDio.post(APIEndpoint.loginGoogle, data: {"token_id": idToken})).thenAnswer((_) async => Response(
            statusCode: 401,
            data: {'message': 'Invalid Google token'},
            requestOptions: RequestOptions(path: APIEndpoint.loginGoogle),
          ));

      expect(() => authService.loginWithGoogle(idToken), throwsException);
      verify(() => mockDio.post(APIEndpoint.loginGoogle, data: {"token_id": idToken})).called(1);
    });
  });
}