flutter_app/lib/model.dart

import 'dart:convert';

import 'package:flutter/cupertino.dart';
import 'package:flutter_app/models/servers.dart';
import 'package:provider/provider.dart';
import 'dart:async';
import 'dart:collection';

import 'cwtch/cwtch.dart';
import 'main.dart';

////////////////////
///   UI State   ///
////////////////////

//todo: delete
class ProfileModel {
  String onion;
  String nickname;
  String creationDate;
  String imagePath;
  HashMap<String, ContactModel> contacts;
}

//todo: delete
class ContactModel {
  String onion;
  String nickname;
  bool isGroup;
  bool isInvitation;
  bool isBlocked;
  String status;
  String imagePath;

  ContactModel({this.onion, this.nickname, this.status, this.isInvitation, this.isBlocked, this.imagePath});
}

class ChatMessage {
  final int o;
  final String d;

  ChatMessage({this.o, this.d});

  ChatMessage.fromJson(Map<String, dynamic> json)
      : o = json['o'],
        d = json['d'];

  Map<String, dynamic> toJson() => {
        'o': o,
        'd': d,
      };
}

///////////////////
///  Providers  ///
///////////////////

class ProfileListState extends ChangeNotifier {
  List<ProfileInfoState> _profiles = [];
  int get num => _profiles.length;

  void addAll(Iterable<ProfileInfoState> newProfiles) {
    _profiles.addAll(newProfiles);
    notifyListeners();
  }

  void add(ProfileInfoState newProfile) {
    _profiles.add(newProfile);
    notifyListeners();
  }

  List<ProfileInfoState> get profiles => _profiles.sublist(0); //todo: copy?? dont want caller able to bypass changenotifier

  ProfileInfoState getProfile(String onion) {
    int idx = _profiles.indexWhere((element) => element.onion == onion);
    return idx >= 0 ? _profiles[idx] : null;
  }
}

class ContactListState extends ChangeNotifier {
  List<ContactInfoState> _contacts = [];
  int get num => _contacts.length;

  void addAll(Iterable<ContactInfoState> newContacts) {
    _contacts.addAll(newContacts);
    notifyListeners();
  }

  void add(ContactInfoState newContact) {
    _contacts.add(newContact);
    notifyListeners();
  }

  void updateLastMessageTime(String forOnion, DateTime newVal) {
    getContact(forOnion).lastMessageTime = newVal;
    _contacts.sort((ContactInfoState a, ContactInfoState b) {
      if (a.lastMessageTime == null && b.lastMessageTime == null) return 0;
      if (a.lastMessageTime == null) return 1;
      if (b.lastMessageTime == null) return -1;
      return b.lastMessageTime.compareTo(a.lastMessageTime);
    });
    //<todo> if(changed) {
    notifyListeners();
    //} </todo>
  }

  List<ContactInfoState> get contacts => _contacts.sublist(0); //todo: copy?? dont want caller able to bypass changenotifier

  ContactInfoState getContact(String onion) {
    int idx = _contacts.indexWhere((element) => element.onion == onion);
    return idx >= 0 ? _contacts[idx] : null;
  }
}

class ProfileInfoState extends ChangeNotifier {
  ContactListState _contacts = ContactListState();
  ServerListState _servers = ServerListState();
  final String onion;
  String _nickname = "";
  String _imagePath = "";
  int _unreadMessages = 0;
  bool _online = false;

  ProfileInfoState({
    this.onion,
    nickname = "",
    imagePath = "",
    unreadMessages = 0,
    contactsJson = "",
    serversJson = "",
    online = false,
  }) {
    this._nickname = nickname;
    this._imagePath = imagePath;
    this._unreadMessages = unreadMessages;
    this._online = online;

    if (contactsJson != null && contactsJson != "" && contactsJson != "null") {
      List<dynamic> contacts = jsonDecode(contactsJson);
      this._contacts.addAll(contacts.map((contact) {
        return ContactInfoState(
            profileOnion: this.onion,
            onion: contact["onion"],
            nickname: contact["name"],
            status: contact["status"],
            imagePath: contact["picture"],
            isBlocked: contact["authorization"] == "blocked",
            isInvitation: contact["authorization"] == "unknown",
            savePeerHistory: contact["saveConversationHistory"],
            numMessages: contact["numMessages"],
            numUnread: contact["numUnread"],
            isGroup: contact["isGroup"],
            server: contact["groupServer"],
            lastMessageTime: DateTime.fromMillisecondsSinceEpoch(1000 * int.parse(contact["lastMsgTime"])));
      }));

      // dummy set to invoke sort-on-load
      if (this._contacts.num > 0) {
        this._contacts.updateLastMessageTime(this._contacts._contacts.first.onion, this._contacts._contacts.first.lastMessageTime);
      }
    }

    this.replaceServers(serversJson);
  }

  // Parse out the server list json into our server info state struct...
  void replaceServers(String serversJson) {
    if (serversJson != null && serversJson != "" && serversJson != "null") {
      print("got servers $serversJson");
      List<dynamic> servers = jsonDecode(serversJson);
      this._servers.replace(servers.map((server) {
        // TODO Keys...
        return ServerInfoState(onion: server["onion"], status: server["status"]);
      }));
    }
  }

  //  Getters and Setters for Online Status
  bool get isOnline => this._online;
  set isOnline(bool newValue) {
    this._online = newValue;
    notifyListeners();
  }

  String get nickname => this._nickname;
  set nickname(String newValue) {
    this._nickname = newValue;
    notifyListeners();
  }

  String get imagePath => this._imagePath;
  set imagePath(String newVal) {
    this._imagePath = newVal;
    notifyListeners();
  }

  int get unreadMessages => this._unreadMessages;
  set unreadMessages(int newVal) {
    this._unreadMessages = newVal;
    notifyListeners();
  }

  ContactListState get contactList => this._contacts;
  ServerListState get serverList => this._servers;

  @override
  void dispose() {
    super.dispose();
    print("profileinfostate.dispose()");
  }
}

class ContactInfoState extends ChangeNotifier {
  final String profileOnion;
  final String onion;
  String _nickname;

  bool _isInvitation;
  bool _isBlocked;
  String _status;
  String _imagePath;
  String _savePeerHistory;
  int _unreadMessages = 0;
  int _totalMessages = 0;
  DateTime _lastMessageTime;

  // todo: a nicer way to mdoel contats, groups and other "entities"
  bool _isGroup;
  String _server;

  ContactInfoState({
    this.profileOnion,
    this.onion,
    nickname = "",
    isGroup = false,
    isInvitation = false,
    isBlocked = false,
    status = "",
    imagePath = "",
    savePeerHistory = "DeleteHistoryConfirmed",
    numMessages = 0,
    numUnread = 0,
    lastMessageTime = null,
    server = "",
  }) {
    this._nickname = nickname;
    this._isGroup = isGroup;
    this._isInvitation = isInvitation;
    this._isBlocked = isBlocked;
    this._status = status;
    this._imagePath = imagePath;
    this._totalMessages = numMessages;
    this._unreadMessages = numUnread;
    this._savePeerHistory = savePeerHistory;
    this._lastMessageTime = lastMessageTime;
    this._server = server;
  }

  get nickname => this._nickname;

  get savePeerHistory => this._savePeerHistory;
  set savePeerHistory(String newVal) {
    this._savePeerHistory = newVal;
    notifyListeners();
  }

  set nickname(String newVal) {
    this._nickname = newVal;
    notifyListeners();
  }

  get isGroup => this._isGroup;
  set isGroup(bool newVal) {
    this._isGroup = newVal;
    notifyListeners();
  }

  get isBlocked => this._isBlocked;
  set isBlocked(bool newVal) {
    this._isBlocked = newVal;
    notifyListeners();
  }

  get isInvitation => this._isInvitation;
  set isInvitation(bool newVal) {
    this._isInvitation = newVal;
    notifyListeners();
  }

  get status => this._status;
  set status(String newVal) {
    this._status = newVal;
    notifyListeners();
  }

  get unreadMessages => this._unreadMessages;
  set unreadMessages(int newVal) {
    this._unreadMessages = newVal;
    notifyListeners();
  }

  get totalMessages => this._totalMessages;
  set totalMessages(int newVal) {
    this._totalMessages = newVal;
    notifyListeners();
  }

  get imagePath => this._imagePath;
  set imagePath(String newVal) {
    this._imagePath = newVal;
    notifyListeners();
  }

  get lastMessageTime => this._lastMessageTime;
  set lastMessageTime(DateTime newVal) {
    this._lastMessageTime = newVal;
    notifyListeners();
  }

  // we only allow callers to fetch the server
  get server => this._server;

  bool isOnline() {
    if (this.isGroup) {
      return this.status == "Synced";
    } else {
      return this.status == "Authenticated";
    }
  }
}

class MessageState extends ChangeNotifier {
  final String profileOnion;
  final String contactHandle;
  final int messageIndex;
  String _message;
  DateTime _timestamp;
  String _senderOnion;
  bool _ackd = false;

  MessageState({
    BuildContext context,
    this.profileOnion,
    this.contactHandle,
    this.messageIndex,
  }) {
    Provider.of<FlwtchState>(context, listen: false).cwtch.GetMessage(profileOnion, contactHandle, messageIndex).then((jsonMessage) {
      dynamic messageWrapper = jsonDecode(jsonMessage);
      dynamic message = jsonDecode(messageWrapper['Message']);
      this._message = message['d'];
      this._timestamp = DateTime.tryParse(messageWrapper['Timestamp']);
      this._senderOnion = messageWrapper['PeerID'];
      //update ackd last as it's changenotified
      this._ackd = messageWrapper['Acknowledged'];
    });
  }

  get message => this._message;
  get timestamp => this._timestamp;
  get ackd => this._ackd;
  get senderOnion => this._senderOnion;

  set ackd(bool newVal) {
    this._ackd = newVal;
    notifyListeners();
  }
}

/////////////
///  ACN  ///
/////////////

class AppModel {
  final Cwtch cwtch;
  AppModel({this.cwtch});

  Stream<String> contactEvents() async* {
    while (true) {
      String event = await cwtch.ContactEvents();
      if (event != "") {
        print(event);
        yield event;
      } else {
        print("TEST TEST FAIL TEST FAIL 123");
        await Future.delayed(Duration(seconds: 1));
      }
    }
  }

  Stream<String> torStatus() async* {
    while (true) {
      String event = await cwtch.ACNEvents();
      if (event != "") {
        yield event;
      } else {
        print("TOR TEST TEST FAIL TEST FAIL 123");
        await Future.delayed(Duration(seconds: 1));
      }
    }
  }
}