mnemo_cards/games/apps/web_app1/lib/src/payload_handlers.dart

import 'package:flutter/foundation.dart';
import 'package:payloads_shared/payloads_shared.dart';
import 'package:payloads_app1/payloads_app1.dart';

/// Handler for incoming pings from Flutter Host (sends pong back)
class PingHandler implements PayloadHandler {
  final Function(BridgePayload) _sendPayload;

  PingHandler(this._sendPayload);

  @override
  Future<BridgePayload?> handle(BridgePayload payload) async {
    debugPrint('📥 [PingHandler] Получен payload: ${payload.runtimeType}');

    if (payload is PingPayload) {
      debugPrint('🏓 [PingHandler] Обработка ping: "${payload.message}"');

      // Handle incoming ping and send pong back
      debugPrint('📤 [PingHandler] Отправка pong ответа...');

      // Send pong response using the toPong method
      final pongPayload = payload.toPong();
      debugPrint(
        '🔄 [PingHandler] Создан pong payload: "${pongPayload.message}"',
      );
      await Future.delayed(const Duration(seconds: 1));
      _sendPayload(pongPayload);
      debugPrint('✅ [PingHandler] Pong ответ отправлен');
    } else {
      debugPrint(
        '⚠️ [PingHandler] Неожиданный тип payload: ${payload.runtimeType}',
      );
    }
    return null;
  }
}

/// Handler for ping responses from Flutter Host
class PingResponseHandler implements PayloadHandler {
  @override
  Future<BridgePayload?> handle(BridgePayload payload) async {
    debugPrint(
      '📥 [PingResponseHandler] Получен payload: ${payload.runtimeType}',
    );

    if (payload is PingPayload) {
      debugPrint(
        '🏓 [PingResponseHandler] Получен pong ответ: "${payload.message}"',
      );
      debugPrint('✅ [PingResponseHandler] Ping-pong цикл завершен');
    } else {
      debugPrint(
        '⚠️ [PingResponseHandler] Неожиданный тип payload: ${payload.runtimeType}',
      );
    }
    return null;
  }
}

/// Handler for user info responses from Flutter Host
class UserInfoResponseHandler implements PayloadHandler {
  @override
  Future<BridgePayload?> handle(BridgePayload payload) async {
    debugPrint(
      '📥 [UserInfoResponseHandler] Получен payload: ${payload.runtimeType}',
    );

    if (payload is UserInfoResponsePayload) {
      debugPrint(
        '👤 [UserInfoResponseHandler] Обработка ответа с информацией о пользователе',
      );
      debugPrint('📊 [UserInfoResponseHandler] Успех: ${payload.success}');

      if (payload.userInfo.isNotEmpty) {
        debugPrint('📋 [UserInfoResponseHandler] Данные пользователя:');
        payload.userInfo.forEach((key, value) {
          debugPrint('   $key: $value');
        });
      } else {
        debugPrint('⚠️ [UserInfoResponseHandler] Данные пользователя пусты');
      }

      if (payload.error != null) {
        debugPrint('❌ [UserInfoResponseHandler] Ошибка: ${payload.error}');
      }
    } else {
      debugPrint(
        '⚠️ [UserInfoResponseHandler] Неожиданный тип payload: ${payload.runtimeType}',
      );
    }
    return null;
  }
}

/// Handler for login responses from Flutter Host
class LoginResponseHandler implements PayloadHandler {
  @override
  Future<BridgePayload?> handle(BridgePayload payload) async {
    debugPrint(
      '📥 [LoginResponseHandler] Получен payload: ${payload.runtimeType}',
    );

    if (payload is LoginResponsePayload) {
      debugPrint('🔐 [LoginResponseHandler] Обработка ответа на логин');
      debugPrint('📊 [LoginResponseHandler] Успех: ${payload.success}');

      if (payload.success) {
        debugPrint('✅ [LoginResponseHandler] Логин успешен');
        debugPrint('🎫 [LoginResponseHandler] Токен: ${payload.token}');

        if (payload.userData != null) {
          debugPrint('👤 [LoginResponseHandler] Данные пользователя:');
          payload.userData!.forEach((key, value) {
            debugPrint('   $key: $value');
          });
        } else {
          debugPrint(
            '⚠️ [LoginResponseHandler] Данные пользователя отсутствуют',
          );
        }
      } else {
        debugPrint('❌ [LoginResponseHandler] Логин неудачен');
        debugPrint('💬 [LoginResponseHandler] Ошибка: ${payload.error}');
      }
    } else {
      debugPrint(
        '⚠️ [LoginResponseHandler] Неожиданный тип payload: ${payload.runtimeType}',
      );
    }
    return null;
  }
}

/// Handler for quiz submission responses from Flutter Host
class QuizResponseHandler implements PayloadHandler {
  @override
  Future<BridgePayload?> handle(BridgePayload payload) async {
    debugPrint(
      '📥 [QuizResponseHandler] Получен payload: ${payload.runtimeType}',
    );

    if (payload is QuizSubmissionResponsePayload) {
      debugPrint('📝 [QuizResponseHandler] Обработка ответа на отправку теста');
      debugPrint('📊 [QuizResponseHandler] Успех: ${payload.success}');
      debugPrint(
        '📈 [QuizResponseHandler] Результат: ${payload.score}/${payload.totalQuestions}',
      );
      debugPrint(
        '✅ [QuizResponseHandler] Правильных ответов: ${payload.correctAnswers}',
      );

      if (payload.detailedResults != null) {
        debugPrint('📋 [QuizResponseHandler] Детальные результаты:');
        payload.detailedResults!.forEach((key, value) {
          debugPrint('   $key: $value');
        });
      } else {
        debugPrint('⚠️ [QuizResponseHandler] Детальные результаты отсутствуют');
      }
    } else {
      debugPrint(
        '⚠️ [QuizResponseHandler] Неожиданный тип payload: ${payload.runtimeType}',
      );
    }
    return null;
  }
}