AiKeyboard2025/lib/plugins/keyboard_method_handler.dart

import 'dart:convert';

import 'package:collection/collection.dart';
import 'package:flutter/services.dart';
import 'package:keyboard/data/repository/account_repository.dart';
import 'package:keyboard/data/repository/characters_repository.dart';
import 'package:keyboard/data/repository/chat_repository.dart';
import 'package:keyboard/data/repository/keyboard_repository.dart';
import 'package:keyboard/utils/atmob_log.dart';
import 'package:get/get.dart';

import '../data/api/response/chat_prologue_response.dart';
import '../data/api/response/chat_super_speak_response.dart';
import '../data/api/response/keyboard_list_response.dart';
import '../utils/http_handler.dart';
import '../utils/mmkv_util.dart';
import '../utils/toast_util.dart';

class KeyboardMethodHandler {
  final tag = "KeyboardMethodHandler";
  final KeyboardRepository keyboardRepository;
  final CharactersRepository charactersRepository;
  final AccountRepository accountRepository;
  final ChatRepository chatRepository;

  // 用处存储选中的键盘id
  static const String keyboardSelect = 'keyboard_select';

  bool get isLogin => accountRepository.isLogin.value;

  bool get isMember => accountRepository.isMember.value;
  late KeyboardListResponse keyboardListResponse;

  KeyboardMethodHandler(
    this.keyboardRepository,
    this.charactersRepository,
    this.accountRepository,
    this.chatRepository,
  );

  Future<dynamic> handleMethodCall(MethodCall call) async {
    switch (call.method) {
      case 'getKeyboardList':
        return _handleGetKeyboardList(call);
      case 'selectedKeyboard':
        return _handleSelectedKeyboard(call);
      case 'getCharacterList':
        return _handleGetCharacterList(call);
      case 'getCurrentKeyboardInfo':
        return _handleGetCurrentKeyboardInfo(call);
      case 'getPrologueList':
        return _handleGetPrologueList(call);
      case 'isLogin':
        return isLogin;
      case 'isMember':
        return isMember;
      case 'chatSuperReply':
        return _handleChatSuperReply(call);
      case 'chatSuperSpeak':
        return _handleChatSuperSpeak(call);
      case 'chatPrologue':
        return _handleChatPrologue(call);
      case 'jumpAppPage':
        return _handleJumpAppPage(call);

      default:
        throw MissingPluginException('Not implemented: ${call.method}');
    }
  }

  Future<String> _handleGetKeyboardList(MethodCall call) async {
    String? type = call.arguments?['type'] as String?;

    final keyboardList = await keyboardRepository.getKeyboardList(type: type);
    final selectedKeyboardJson = KVUtil.getString(keyboardSelect, null);
    if (selectedKeyboardJson != null) {
      try {
        final Map<String, dynamic> keyboardMap = jsonDecode(
          selectedKeyboardJson,
        );
        final String? keyboardId = keyboardMap['id'] as String?;
        if (keyboardId != null) {
          for (var element in keyboardList.keyboardInfos) {
            if (element.id == keyboardId) {
              element.isSelect = true;
              break;
            }
          }
        }
      } catch (e) {
        AtmobLog.e(tag, "解析本地选中键盘失败: $e");
      }
    }
    keyboardListResponse = keyboardList;
    return jsonEncode(keyboardList.toJson());
  }

  Future<String> _handleSelectedKeyboard(MethodCall call) async {
    final String keyboardId = call.arguments['keyboardId'];

    if (keyboardListResponse.keyboardInfos.isEmpty) {
      keyboardListResponse = await keyboardRepository.getKeyboardList();
    }
    final selectedKeyboard = keyboardListResponse.keyboardInfos
        .firstWhereOrNull((element) => element.id == keyboardId);
    if (selectedKeyboard != null) {
      KVUtil.putString(keyboardSelect, jsonEncode(selectedKeyboard.toJson()));
    }
    return "{}";
  }

  Future<String> _handleGetCurrentKeyboardInfo(MethodCall call) async {
    final String? keyboardJsonStr = KVUtil.getString(keyboardSelect, null);
    if (keyboardJsonStr != null) {
      try {
        final jsonMap = jsonDecode(keyboardJsonStr);
        return jsonEncode(jsonMap);
      } catch (e) {
        AtmobLog.e(tag, "Failed to decode keyboard JSON: $e");
      }
    }
    return "{}";
  }

  Future<String> _handleGetCharacterList(MethodCall call) async {
    final String keyboardId = call.arguments['keyboardId'];
    final characterList = await keyboardRepository.getKeyboardCharacterList(
      keyboardId: keyboardId,
    );
    return jsonEncode(characterList.toJson());
  }

  //   获取开场白列表
  Future<String> _handleGetPrologueList(MethodCall call) async {
    final prologueList = await keyboardRepository.getPrologueList();
    return jsonEncode(prologueList.toJson());
  }

  // 超会回
  Future<String> _handleChatSuperReply(MethodCall call) async {
    final String content = call.arguments['content'];
    final String keyboardId = call.arguments['keyboardId'];
    final String characterId = call.arguments['characterId'];
    try {
      final chatSuperReplyResponse = await chatRepository.chatSuperReply(
        content: content,
        keyboardId: keyboardId,
        characterId: characterId,
      );

      return jsonEncode(chatSuperReplyResponse.toJson());
    } catch (error) {
      if (error is ServerErrorException) {
        AtmobLog.d(tag, "超会回失败: ${error.message}");
        ToastUtil.show(error.message);
      } else {
        AtmobLog.d(tag, "超会回失败: $error");
      }
      return '{}';
    }
  }

  // 超会说
  Future<String> _handleChatSuperSpeak(MethodCall call) async {
    final String content = call.arguments['content'];
    final String keyboardId = call.arguments['keyboardId'];
    final String characterId = call.arguments['characterId'];
    final ChatSuperSpeakResponse chatSuperSpeakResponse;
    try {
      chatSuperSpeakResponse = await chatRepository.chatSuperSpeak(
        content: content,
        keyboardId: keyboardId,
        characterId: characterId,
      );
      return jsonEncode(chatSuperSpeakResponse.toJson());
    } catch (error) {
      if (error is ServerErrorException) {
        AtmobLog.d(tag, "超会说失败: ${error.message}");
        ToastUtil.show(error.message);
      } else {
        AtmobLog.d(tag, "超会说失败: $error");
      }
      return '{}';
    }
  }

  // 开场白
  Future<String> _handleChatPrologue(MethodCall call) async {
    final String name = call.arguments['name'];
    final ChatPrologueResponse chatPrologueResponse;
    try {
      chatPrologueResponse = await chatRepository.chatPrologue(name: name);
      return jsonEncode(chatPrologueResponse.toJson());
    } catch (error) {
      if (error is ServerErrorException) {
        ToastUtil.show(error.message);
        AtmobLog.i(tag, "开场白失败: ${error.message}");
      } else {
        AtmobLog.i(tag, "开场白失败: $error");
      }
      return '{}';
    }
  }

  Future<String> _handleJumpAppPage(MethodCall call) async {
    try {
      final String path = call.arguments['path'];
      final dynamic args = call.arguments['args'];

      Map<String, dynamic> parsedArgs = {};
      if (args is String && args.isNotEmpty) {
        try {
          parsedArgs = Map<String, dynamic>.from(json.decode(args));
        } catch (e) {

          return '{}';
        }
      } else if (args is Map) {
        parsedArgs = Map<String, dynamic>.from(args);
      }
      Get.toNamed(
        path,
        parameters: parsedArgs.map((k, v) => MapEntry(k, v.toString())),
      );

      return '{}';
    } catch (e) {
      print("跳转失败: $e");

      return '{}';
    }
  }
}