E2EEChat/lib/presenter/user_chat.dart

import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:dash_chat/dash_chat.dart';
import 'package:e2ee_chat/common/api.dart';
import 'package:e2ee_chat/common/global.dart';
import 'package:e2ee_chat/model/message.dart';
import 'package:e2ee_chat/model/user.dart';
import 'package:e2ee_chat/presenter/login.dart';

import 'chat_list.dart';

class UserChatPresenter extends ChatListPresenter {
  UserChatPresenter({this.to}) {
    _listener = _listenUserChat();
  }

  User? get from => LoginPresenter().user;
  User? to;

  List<ChatMessage>? _chatMessages;
  List<ChatMessage> get chatMessages => _chatMessages ?? [];

  bool _disposed = false;
  Future<void>? _listener;

  @override
  void dispose() {
    _disposed = true;
    _listener?.then((e) => super.dispose()) ?? super.dispose();
  }

  Future<void> _listenUserChat() async {
    while (!_disposed) {
      if (to != null) {
        if (_chatMessages == null) {
          debug("init chatMessages");
          _chatMessages = await retrieveAllChatMessages();
          notifyListeners();
        } else {
          await flushChatMessages();
        }
      }
      await Future.delayed(Duration(seconds: 1));
    }
  }

  Future<void> flushChatMessages() async {
    final _user = LoginPresenter().user;
    if (_user != null) {
      List<String>? _list = await Api().getLastMessages(_user.username);
      if (_list != null) {
        debug("flush chat message");
        for (final i in _list) {
          final _chatMessage = await chatMessageFromMessage(i);
          if (_chatMessage != null) {
            chatMessages.add(_chatMessage);
          }
        }
        notifyListeners();
      }
    }
    // messages.forEach((message) => list.add(message.chatMessage));
  }

  Future<ChatMessage?> chatMessageFromMessage(String json) async {
    String? username = from?.username;
    ChatMessage? _chatMessage;
    try {
      _chatMessage = ChatMessage.fromJson(jsonDecode(json));
    } catch (e) {
      try {
        final _message = Message.fromJson(jsonDecode(json));
        _chatMessage = await _message.chatMessage;
      } catch (e) {
        debug('chatMessageFromMessagePackage error: e');
      }
    }
    return _chatMessage;
  }

  Future<List<ChatMessage>> retrieveAllChatMessages() async {
    final list = <ChatMessage>[];
    final _user = LoginPresenter().user;
    final _to = to;
    if (_user != null && _to != null) {
      List<String>? _list = await Api().getFilterMessages(_to.username);
      if (_list != null) {
        for (final i in _list) {
          final _chatMessage = await chatMessageFromMessage(i);
          if (_chatMessage != null) {
            list.add(_chatMessage);
          }
        }
      }
    }
    return list;
    // messages.forEach((message) => list.add(message.chatMessage));
  }

  Future<bool> sendMessage(ChatMessage chatMessage) async {
    debug('user chat presenter send msg begin');
    bool _result = true;
    chatMessages.add(chatMessage);
    notifyListeners();
    if (from != null && to != null) {
      try {
        String plaintext = jsonEncode(chatMessage.toJson());
        // TODO: encrypt
        String publicKey = "";
        final message = Message.encrypt(from!.username, to!.username, plaintext, publicKey);
        _result = await Api().sendMessage(to!.username, jsonEncode(message.toJson()));
      } catch (e) {
        debug(e);
        _result = false;
      }
    }
    if (!_result) {
      debug('user chat presenter send msg failed');
    }
    return _result;
  }
}