mnemo_cards/games/packages/payloads_app1/test/payloads_app1_test.dart

import 'package:flutter_test/flutter_test.dart';
import 'package:payloads_app1/payloads_app1.dart';
import 'package:bridge_core/bridge_core.dart';

void main() {
  group('LoginRequestPayload', () {
    test('should create login request payload', () {
      final payload = LoginRequestPayload(
        username: 'testuser',
        password: 'password123',
        rememberMe: true,
        additionalData: {'device': 'mobile'},
      );
      
      expect(payload.username, equals('testuser'));
      expect(payload.password, equals('password123'));
      expect(payload.rememberMe, isTrue);
      expect(payload.additionalData, equals({'device': 'mobile'}));
      expect(payload.type, equals('login_request'));
    });

    test('should serialize and deserialize correctly', () {
      final original = LoginRequestPayload(
        username: 'testuser',
        password: 'password123',
        rememberMe: true,
        additionalData: {'device': 'mobile'},
      );
      final json = original.toJson();
      final deserialized = LoginRequestPayload.fromJson(json);
      
      expect(deserialized.username, equals(original.username));
      expect(deserialized.password, equals(original.password));
      expect(deserialized.rememberMe, equals(original.rememberMe));
      expect(deserialized.additionalData, equals(original.additionalData));
    });
  });

  group('LoginResponsePayload', () {
    test('should create login response payload', () {
      final payload = LoginResponsePayload(
        success: true,
        token: 'jwt_token_123',
        refreshToken: 'refresh_token_456',
        userData: {'name': 'John', 'email': 'john@example.com'},
        expiresAt: DateTime(2024, 12, 31),
      );
      
      expect(payload.success, isTrue);
      expect(payload.token, equals('jwt_token_123'));
      expect(payload.refreshToken, equals('refresh_token_456'));
      expect(payload.userData, equals({'name': 'John', 'email': 'john@example.com'}));
      expect(payload.type, equals('login_response'));
    });

    test('should serialize and deserialize correctly', () {
      final original = LoginResponsePayload(
        success: true,
        token: 'jwt_token_123',
        refreshToken: 'refresh_token_456',
        error: null,
        userData: {'name': 'John'},
        expiresAt: DateTime(2024, 12, 31),
      );
      final json = original.toJson();
      final deserialized = LoginResponsePayload.fromJson(json);
      
      expect(deserialized.success, equals(original.success));
      expect(deserialized.token, equals(original.token));
      expect(deserialized.refreshToken, equals(original.refreshToken));
      expect(deserialized.error, equals(original.error));
      expect(deserialized.userData, equals(original.userData));
      expect(deserialized.expiresAt?.year, equals(original.expiresAt?.year));
    });
  });

  group('SubmitQuizPayload', () {
    test('should create quiz submission payload', () {
      final answers = [
        QuizAnswer(questionId: 'q1', selectedAnswer: 'A', isCorrect: true, timeSpent: 30),
        QuizAnswer(questionId: 'q2', selectedAnswer: 'B', isCorrect: false, timeSpent: 45),
      ];
      
      final payload = SubmitQuizPayload(
        quizId: 'quiz_123',
        answers: answers,
        timeSpent: 120,
        metadata: {'difficulty': 'hard'},
      );
      
      expect(payload.quizId, equals('quiz_123'));
      expect(payload.answers.length, equals(2));
      expect(payload.timeSpent, equals(120));
      expect(payload.metadata, equals({'difficulty': 'hard'}));
      expect(payload.type, equals('submit_quiz'));
    });

    test('should serialize and deserialize correctly', () {
      final answers = [
        QuizAnswer(questionId: 'q1', selectedAnswer: 'A', isCorrect: true, timeSpent: 30),
        QuizAnswer(questionId: 'q2', selectedAnswer: 'B', isCorrect: false, timeSpent: 45),
      ];
      
      final original = SubmitQuizPayload(
        quizId: 'quiz_123',
        answers: answers,
        timeSpent: 120,
        metadata: {'difficulty': 'hard'},
      );
      final json = original.toJson();
      final deserialized = SubmitQuizPayload.fromJson(json);
      
      expect(deserialized.quizId, equals(original.quizId));
      expect(deserialized.answers.length, equals(original.answers.length));
      expect(deserialized.timeSpent, equals(original.timeSpent));
      expect(deserialized.metadata, equals(original.metadata));
    });
  });

  group('QuizSubmissionResponsePayload', () {
    test('should create quiz submission response', () {
      final payload = QuizSubmissionResponsePayload(
        success: true,
        score: 85,
        totalQuestions: 10,
        correctAnswers: 8,
        certificateUrl: 'https://example.com/cert.pdf',
        detailedResults: {'category1': 5, 'category2': 3},
      );
      
      expect(payload.success, isTrue);
      expect(payload.score, equals(85));
      expect(payload.totalQuestions, equals(10));
      expect(payload.correctAnswers, equals(8));
      expect(payload.certificateUrl, equals('https://example.com/cert.pdf'));
      expect(payload.type, equals('quiz_submission_response'));
    });

    test('should serialize and deserialize correctly', () {
      final original = QuizSubmissionResponsePayload(
        success: true,
        score: 85,
        totalQuestions: 10,
        correctAnswers: 8,
        certificateUrl: 'https://example.com/cert.pdf',
        error: null,
        detailedResults: {'category1': 5, 'category2': 3},
      );
      final json = original.toJson();
      final deserialized = QuizSubmissionResponsePayload.fromJson(json);
      
      expect(deserialized.success, equals(original.success));
      expect(deserialized.score, equals(original.score));
      expect(deserialized.totalQuestions, equals(original.totalQuestions));
      expect(deserialized.correctAnswers, equals(original.correctAnswers));
      expect(deserialized.certificateUrl, equals(original.certificateUrl));
      expect(deserialized.error, equals(original.error));
      expect(deserialized.detailedResults, equals(original.detailedResults));
    });
  });

  group('QuizAnswer', () {
    test('should create quiz answer', () {
      final answer = QuizAnswer(
        questionId: 'q1',
        selectedAnswer: 'A',
        isCorrect: true,
        timeSpent: 30,
      );
      
      expect(answer.questionId, equals('q1'));
      expect(answer.selectedAnswer, equals('A'));
      expect(answer.isCorrect, isTrue);
      expect(answer.timeSpent, equals(30));
    });

    test('should serialize and deserialize correctly', () {
      final original = QuizAnswer(
        questionId: 'q1',
        selectedAnswer: 'A',
        isCorrect: true,
        timeSpent: 30,
      );
      final json = original.toJson();
      final deserialized = QuizAnswer.fromJson(json);
      
      expect(deserialized.questionId, equals(original.questionId));
      expect(deserialized.selectedAnswer, equals(original.selectedAnswer));
      expect(deserialized.isCorrect, equals(original.isCorrect));
      expect(deserialized.timeSpent, equals(original.timeSpent));
    });
  });

  group('Payload Registration', () {
    test('should register all app1 payloads', () {
      registerApp1Payloads();
      
      expect(PayloadRegistry.isRegistered('login_request'), isTrue);
      expect(PayloadRegistry.isRegistered('login_response'), isTrue);
      expect(PayloadRegistry.isRegistered('submit_quiz'), isTrue);
      expect(PayloadRegistry.isRegistered('quiz_submission_response'), isTrue);
    });
  });
}