import 'package:flutter_test/flutter_test.dart';
import 'package:mockito/annotations.dart';
import 'package:mockito/mockito.dart';
import 'package:dio/dio.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:superport/data/datasources/remote/api_client.dart';
import 'package:superport/data/datasources/remote/auth_remote_datasource.dart';
import 'package:superport/data/models/auth/login_request.dart';
import 'package:superport/data/models/auth/login_response.dart';
import 'package:superport/data/models/auth/auth_user.dart';
import 'package:superport/services/auth_service.dart';
import 'package:superport/core/errors/failures.dart';
import 'package:dartz/dartz.dart';

import 'login_integration_test.mocks.dart';

@GenerateMocks([ApiClient, FlutterSecureStorage, Dio])
void main() {
  group('로그인 통합 테스트', () {
    late MockApiClient mockApiClient;
    late MockFlutterSecureStorage mockSecureStorage;
    late AuthRemoteDataSource authRemoteDataSource;
    late AuthService authService;

    setUp(() {
      mockApiClient = MockApiClient();
      mockSecureStorage = MockFlutterSecureStorage();
      authRemoteDataSource = AuthRemoteDataSourceImpl(mockApiClient);
      authService = AuthServiceImpl(authRemoteDataSource, mockSecureStorage);
    });

    group('로그인 프로세스 전체 테스트', () {
      test('성공적인 로그인 - 이메일 사용', () async {
        // Arrange
        final request = LoginRequest(
          email: 'admin@superport.com',
          password: 'admin123',
        );

        final mockResponse = Response(
          data: {
            'success': true,
            'data': {
              'access_token': 'test_access_token',
              'refresh_token': 'test_refresh_token',
              'token_type': 'Bearer',
              'expires_in': 3600,
              'user': {
                'id': 1,
                'username': 'admin',
                'email': 'admin@superport.com',
                'name': '관리자',
                'role': 'ADMIN',
              },
            },
          },
          statusCode: 200,
          requestOptions: RequestOptions(path: '/auth/login'),
        );

        when(mockApiClient.post('/auth/login', data: request.toJson()))
            .thenAnswer((_) async => mockResponse);

        when(mockSecureStorage.write(key: anyNamed('key'), value: anyNamed('value')))
            .thenAnswer((_) async => Future.value());

        // Act
        final result = await authService.login(request);

        // Assert
        expect(result.isRight(), true);
        result.fold(
          (failure) => fail('로그인이 실패하면 안됩니다'),
          (loginResponse) {
            expect(loginResponse.accessToken, 'test_access_token');
            expect(loginResponse.refreshToken, 'test_refresh_token');
            expect(loginResponse.user.email, 'admin@superport.com');
            expect(loginResponse.user.role, 'ADMIN');
          },
        );

        // 토큰이 올바르게 저장되었는지 확인
        verify(mockSecureStorage.write(key: 'access_token', value: 'test_access_token')).called(1);
        verify(mockSecureStorage.write(key: 'refresh_token', value: 'test_refresh_token')).called(1);
        verify(mockSecureStorage.write(key: 'user', value: anyNamed('value'))).called(1);
      });

      test('성공적인 로그인 - 직접 LoginResponse 형태', () async {
        // Arrange
        final request = LoginRequest(
          email: 'admin@superport.com',
          password: 'admin123',
        );

        final mockResponse = Response(
          data: {
            'access_token': 'test_access_token',
            'refresh_token': 'test_refresh_token',
            'token_type': 'Bearer',
            'expires_in': 3600,
            'user': {
              'id': 1,
              'username': 'admin',
              'email': 'admin@superport.com',
              'name': '관리자',
              'role': 'ADMIN',
            },
          },
          statusCode: 200,
          requestOptions: RequestOptions(path: '/auth/login'),
        );

        when(mockApiClient.post('/auth/login', data: request.toJson()))
            .thenAnswer((_) async => mockResponse);

        when(mockSecureStorage.write(key: anyNamed('key'), value: anyNamed('value')))
            .thenAnswer((_) async => Future.value());

        // Act
        final result = await authService.login(request);

        // Assert
        expect(result.isRight(), true);
        result.fold(
          (failure) => fail('로그인이 실패하면 안됩니다'),
          (loginResponse) {
            expect(loginResponse.accessToken, 'test_access_token');
            expect(loginResponse.user.email, 'admin@superport.com');
          },
        );
      });

      test('로그인 실패 - 잘못된 인증 정보', () async {
        // Arrange
        final request = LoginRequest(
          email: 'admin@superport.com',
          password: 'wrongpassword',
        );

        when(mockApiClient.post('/auth/login', data: request.toJson()))
            .thenThrow(DioException(
          response: Response(
            statusCode: 401,
            statusMessage: 'Unauthorized',
            requestOptions: RequestOptions(path: '/auth/login'),
          ),
          requestOptions: RequestOptions(path: '/auth/login'),
        ));

        // Act
        final result = await authService.login(request);

        // Assert
        expect(result.isLeft(), true);
        result.fold(
          (failure) {
            expect(failure, isA<AuthenticationFailure>());
            expect(failure.message, contains('올바르지 않습니다'));
          },
          (_) => fail('로그인이 성공하면 안됩니다'),
        );
      });

      test('로그인 실패 - 네트워크 오류', () async {
        // Arrange
        final request = LoginRequest(
          email: 'admin@superport.com',
          password: 'admin123',
        );

        when(mockApiClient.post('/auth/login', data: request.toJson()))
            .thenThrow(DioException(
          type: DioExceptionType.connectionTimeout,
          message: 'Connection timeout',
          requestOptions: RequestOptions(path: '/auth/login'),
        ));

        // Act
        final result = await authService.login(request);

        // Assert
        expect(result.isLeft(), true);
        result.fold(
          (failure) {
            expect(failure, isA<ServerFailure>());
          },
          (_) => fail('로그인이 성공하면 안됩니다'),
        );
      });

      test('로그인 실패 - 잘못된 응답 형식', () async {
        // Arrange
        final request = LoginRequest(
          email: 'admin@superport.com',
          password: 'admin123',
        );

        final mockResponse = Response(
          data: {
            'wrongFormat': true,
          },
          statusCode: 200,
          requestOptions: RequestOptions(path: '/auth/login'),
        );

        when(mockApiClient.post('/auth/login', data: request.toJson()))
            .thenAnswer((_) async => mockResponse);

        // Act
        final result = await authService.login(request);

        // Assert
        expect(result.isLeft(), true);
        result.fold(
          (failure) {
            expect(failure, isA<ServerFailure>());
            expect(failure.message, contains('잘못된 응답 형식'));
          },
          (_) => fail('로그인이 성공하면 안됩니다'),
        );
      });
    });

    group('JSON 파싱 테스트', () {
      test('LoginResponse fromJson 테스트', () {
        // Arrange
        final json = {
          'access_token': 'test_token',
          'refresh_token': 'refresh_token',
          'token_type': 'Bearer',
          'expires_in': 3600,
          'user': {
            'id': 1,
            'username': 'testuser',
            'email': 'test@example.com',
            'name': '테스트 사용자',
            'role': 'USER',
          },
        };

        // Act
        final loginResponse = LoginResponse.fromJson(json);

        // Assert
        expect(loginResponse.accessToken, 'test_token');
        expect(loginResponse.refreshToken, 'refresh_token');
        expect(loginResponse.tokenType, 'Bearer');
        expect(loginResponse.expiresIn, 3600);
        expect(loginResponse.user.id, 1);
        expect(loginResponse.user.username, 'testuser');
        expect(loginResponse.user.email, 'test@example.com');
        expect(loginResponse.user.name, '테스트 사용자');
        expect(loginResponse.user.role, 'USER');
      });

      test('AuthUser fromJson 테스트', () {
        // Arrange
        final json = {
          'id': 1,
          'username': 'testuser',
          'email': 'test@example.com',
          'name': '테스트 사용자',
          'role': 'USER',
        };

        // Act
        final authUser = AuthUser.fromJson(json);

        // Assert
        expect(authUser.id, 1);
        expect(authUser.username, 'testuser');
        expect(authUser.email, 'test@example.com');
        expect(authUser.name, '테스트 사용자');
        expect(authUser.role, 'USER');
      });
    });

    group('토큰 저장 및 검색 테스트', () {
      test('액세스 토큰 저장 및 검색', () async {
        // Arrange
        const testToken = 'test_access_token';
        when(mockSecureStorage.read(key: 'access_token'))
            .thenAnswer((_) async => testToken);

        // Act
        final token = await authService.getAccessToken();

        // Assert
        expect(token, testToken);
        verify(mockSecureStorage.read(key: 'access_token')).called(1);
      });

      test('현재 사용자 정보 저장 및 검색', () async {
        // Arrange
        final testUser = AuthUser(
          id: 1,
          username: 'testuser',
          email: 'test@example.com',
          name: '테스트 사용자',
          role: 'USER',
        );
        
        when(mockSecureStorage.read(key: 'user'))
            .thenAnswer((_) async => '{"id":1,"username":"testuser","email":"test@example.com","name":"테스트 사용자","role":"USER"}');

        // Act
        final user = await authService.getCurrentUser();

        // Assert
        expect(user, isNotNull);
        expect(user!.id, testUser.id);
        expect(user.email, testUser.email);
        expect(user.name, testUser.name);
      });
    });
  });
}