fluffychat/lib/widgets/matrix.dart

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

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';

import 'package:app_links/app_links.dart';
import 'package:collection/collection.dart';
import 'package:desktop_notifications/desktop_notifications.dart';
import 'package:image_picker/image_picker.dart';
import 'package:intl/intl.dart';
import 'package:just_audio/just_audio.dart';
import 'package:matrix/encryption.dart';
import 'package:matrix/matrix.dart';
import 'package:provider/provider.dart';
import 'package:sentry_flutter/sentry_flutter.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:universal_html/html.dart' as html;
import 'package:url_launcher/url_launcher_string.dart';

import 'package:fluffychat/config/app_config.dart';
import 'package:fluffychat/l10n/l10n.dart';
import 'package:fluffychat/pangea/analytics_data/analytics_data_service.dart';
import 'package:fluffychat/pangea/common/controllers/pangea_controller.dart';
import 'package:fluffychat/pangea/common/utils/any_state_holder.dart';
import 'package:fluffychat/pangea/common/utils/error_handler.dart';
import 'package:fluffychat/pangea/languages/locale_provider.dart';
import 'package:fluffychat/utils/client_manager.dart';
import 'package:fluffychat/utils/matrix_sdk_extensions/matrix_file_extension.dart';
import 'package:fluffychat/utils/platform_infos.dart';
import 'package:fluffychat/utils/uia_request_manager.dart';
import 'package:fluffychat/utils/voip_plugin.dart';
import 'package:fluffychat/widgets/adaptive_dialogs/show_ok_cancel_alert_dialog.dart';
import 'package:fluffychat/widgets/fluffy_chat_app.dart';
import 'package:fluffychat/widgets/future_loading_dialog.dart';
import '../config/setting_keys.dart';
import '../pages/key_verification/key_verification_dialog.dart';
import '../utils/account_bundles.dart';
import '../utils/background_push.dart';
import 'local_notifications_extension.dart';

// import 'package:flutter_secure_storage/flutter_secure_storage.dart';

class Matrix extends StatefulWidget {
  final Widget? child;

  final List<Client> clients;

  final Map<String, String>? queryParameters;

  final SharedPreferences store;

  const Matrix({
    this.child,
    required this.clients,
    required this.store,
    this.queryParameters,
    super.key,
  });

  @override
  MatrixState createState() => MatrixState();

  /// Returns the (nearest) Client instance of your application.
  static MatrixState of(BuildContext context) =>
      Provider.of<MatrixState>(context, listen: false);
}

class MatrixState extends State<Matrix> with WidgetsBindingObserver {
  int _activeClient = -1;
  String? activeBundle;
  // #Pangea
  static late PangeaController pangeaController;
  static PangeaAnyState pAnyState = PangeaAnyState();
  late StreamSubscription? _uriListener;

  final Map<String, AnalyticsDataService> _analyticsServices = {};
  // Pangea#
  SharedPreferences get store => widget.store;

  XFile? loginAvatar;
  String? loginUsername;
  bool? loginRegistrationSupported;

  BackgroundPush? backgroundPush;
  // #Pangea
  ValueNotifier<int> notifPermissionNotifier = ValueNotifier(0);
  // Pangea#

  Client get client {
    if (_activeClient < 0 || _activeClient >= widget.clients.length) {
      // #Pangea
      currentBundle!.first!.homeserver = Uri.parse(
        "https://${AppConfig.defaultHomeserver}",
      );
      // Pangea#
      return currentBundle!.first!;
    }

    // #Pangea
    widget.clients[_activeClient].homeserver = Uri.parse(
      "https://${AppConfig.defaultHomeserver}",
    );
    // Pangea#
    return widget.clients[_activeClient];
  }

  // #Pangea
  AnalyticsDataService get analyticsDataService {
    if (_analyticsServices[client.clientName] == null) {
      Logs().w(
        'Tried to access AnalyticsDataService for client ${client.clientName}, but it does not exist.',
      );
      _analyticsServices[client.clientName] = AnalyticsDataService(client);
    }
    return _analyticsServices[client.clientName]!;
  }
  // Pangea#

  VoipPlugin? voipPlugin;

  bool get isMultiAccount => widget.clients.length > 1;

  int getClientIndexByMatrixId(String matrixId) =>
      widget.clients.indexWhere((client) => client.userID == matrixId);

  late String currentClientSecret;
  RequestTokenResponse? currentThreepidCreds;

  void setActiveClient(Client? cl) {
    final i = widget.clients.indexWhere((c) => c == cl);
    if (i != -1) {
      _activeClient = i;
      // TODO: Multi-client VoiP support
      createVoipPlugin();
    } else {
      Logs().w('Tried to set an unknown client ${cl!.userID} as active');
    }
  }

  List<Client?>? get currentBundle {
    if (!hasComplexBundles) {
      return List.from(widget.clients);
    }
    final bundles = accountBundles;
    if (bundles.containsKey(activeBundle)) {
      return bundles[activeBundle];
    }
    return bundles.values.first;
  }

  Map<String?, List<Client?>> get accountBundles {
    final resBundles = <String?, List<_AccountBundleWithClient>>{};
    for (var i = 0; i < widget.clients.length; i++) {
      final bundles = widget.clients[i].accountBundles;
      for (final bundle in bundles) {
        if (bundle.name == null) {
          continue;
        }
        resBundles[bundle.name] ??= [];
        resBundles[bundle.name]!.add(
          _AccountBundleWithClient(client: widget.clients[i], bundle: bundle),
        );
      }
    }
    for (final b in resBundles.values) {
      b.sort(
        (a, b) => a.bundle!.priority == null
            ? 1
            : b.bundle!.priority == null
            ? -1
            : a.bundle!.priority!.compareTo(b.bundle!.priority!),
      );
    }
    return resBundles.map(
      (k, v) => MapEntry(k, v.map((vv) => vv.client).toList()),
    );
  }

  bool get hasComplexBundles => accountBundles.values.any((v) => v.length > 1);

  Client? _loginClientCandidate;

  AudioPlayer? audioPlayer;
  final ValueNotifier<String?> voiceMessageEventId = ValueNotifier(null);

  Future<Client> getLoginClient() async {
    if (widget.clients.isNotEmpty && !client.isLogged()) {
      return client;
    }
    final candidate = _loginClientCandidate ??=
        await ClientManager.createClient(
            '${AppSettings.applicationName.value}-${DateTime.now().millisecondsSinceEpoch}',
            store,
          )
          ..onLoginStateChanged.stream
              .where((l) => l == LoginState.loggedIn)
              .first
              .then((_) async {
                // #Pangea
                MatrixState.pangeaController.handleLoginStateChange(
                  LoginState.loggedIn,
                  _loginClientCandidate!.userID,
                  context,
                );
                // Pangea#
                if (!widget.clients.contains(_loginClientCandidate)) {
                  widget.clients.add(_loginClientCandidate!);
                }
                ClientManager.addClientNameToStore(
                  _loginClientCandidate!.clientName,
                  store,
                );
                _registerSubs(_loginClientCandidate!.clientName);
                _loginClientCandidate = null;
                // #Pangea
                // FluffyChatApp.router.go('/backup');
                final isL2Set =
                    await pangeaController.userController.isUserL2Set;
                FluffyChatApp.router.go(
                  isL2Set ? '/rooms' : '/registration/create',
                );
                // Pangea#
              });
    // #Pangea
    candidate.homeserver = Uri.parse("https://${AppConfig.defaultHomeserver}");

    // This listener is not set for the new login client until the user is logged in,
    // but if the user tries to sign up without this listener set, the signup UIA request
    // will hang. So set the listener here.
    onUiaRequest[candidate.clientName] ??= candidate.onUiaRequest.stream.listen(
      uiaRequestHandler,
    );
    // Pangea#
    if (widget.clients.isEmpty) widget.clients.add(candidate);
    return candidate;
  }

  Client? getClientByName(String name) =>
      widget.clients.firstWhereOrNull((c) => c.clientName == name);

  final onRoomKeyRequestSub = <String, StreamSubscription>{};
  final onKeyVerificationRequestSub = <String, StreamSubscription>{};
  final onNotification = <String, StreamSubscription>{};
  final onLoginStateChanged = <String, StreamSubscription<LoginState>>{};
  final onUiaRequest = <String, StreamSubscription<UiaRequest>>{};

  String? _cachedPassword;
  Timer? _cachedPasswordClearTimer;

  String? get cachedPassword => _cachedPassword;

  set cachedPassword(String? p) {
    Logs().d('Password cached');
    _cachedPasswordClearTimer?.cancel();
    _cachedPassword = p;
    _cachedPasswordClearTimer = Timer(const Duration(minutes: 10), () {
      _cachedPassword = null;
      Logs().d('Cached Password cleared');
    });
  }

  String? get activeRoomId {
    final route = FluffyChatApp.router.routeInformationProvider.value.uri.path;
    if (!route.startsWith('/rooms/')) return null;
    // #Pangea
    // return route.split('/')[2];
    return FluffyChatApp.router.state.pathParameters['roomid'];
    // Pangea#
  }

  final linuxNotifications = PlatformInfos.isLinux
      ? NotificationsClient()
      : null;
  final Map<String, int> linuxNotificationIds = {};

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
    initMatrix();
    // #Pangea
    Sentry.configureScope(
      (scope) =>
          scope.setUser(SentryUser(id: client.userID, name: client.userID)),
    );
    pangeaController = PangeaController(matrixState: this);
    WidgetsBinding.instance.addPostFrameCallback((_) {
      _setAppLanguage();
      _setLanguageListener();
    });
    _uriListener = AppLinks().uriLinkStream.listen(_processIncomingUris);
    // Pangea#
  }

  // #Pangea
  bool _showingScreenSizeDialog = false;
  double? _lastShownPopupHeight;
  @override
  void didChangeMetrics() {
    _showScreenSizeDialog();
    super.didChangeMetrics();
  }

  Future<void> _showScreenSizeDialog() async {
    if (_showingScreenSizeDialog || !kIsWeb) {
      return;
    }

    final height = MediaQuery.heightOf(context);
    if (height > 500) {
      _lastShownPopupHeight = null;
      return;
    }

    if (_lastShownPopupHeight != null && height >= _lastShownPopupHeight!) {
      return;
    }

    _showingScreenSizeDialog = true;
    _lastShownPopupHeight = height;
    await showOkAlertDialog(
      context:
          FluffyChatApp.router.routerDelegate.navigatorKey.currentContext ??
          context,
      title: L10n.of(context).screenSizeWarning,
    );
    _lastShownPopupHeight = MediaQuery.heightOf(context);
    _showingScreenSizeDialog = false;
  }

  StreamSubscription? _languageListener;
  Future<void> _setLanguageListener() async {
    await pangeaController.userController.initialize();
    _languageListener?.cancel();
    _languageListener = pangeaController.userController.languageStream.stream
        .listen((update) {
          _setAppLanguage();
          analyticsDataService.updateService.onUpdateLanguages(update);
        });
  }

  void _setAppLanguage() {
    try {
      Provider.of<LocaleProvider>(context, listen: false).setLocale(
        pangeaController.userController.profile.userSettings.sourceLanguage,
      );
    } catch (e, s) {
      Logs().e('Error setting app language', e);
      ErrorHandler.logError(e: e, s: s, data: {});
    }
  }
  // Pangea#

  void _registerSubs(String name) {
    final c = getClientByName(name);
    if (c == null) {
      Logs().w(
        'Attempted to register subscriptions for non-existing client $name',
      );
      return;
    }
    onRoomKeyRequestSub[name] ??= c.onRoomKeyRequest.stream.listen((
      RoomKeyRequest request,
    ) async {
      if (widget.clients.any(
        ((cl) =>
            cl.userID == request.requestingDevice.userId &&
            cl.identityKey == request.requestingDevice.curve25519Key),
      )) {
        Logs().i(
          '[Key Request] Request is from one of our own clients, forwarding the key...',
        );
        await request.forwardKey();
      }
    });
    onKeyVerificationRequestSub[name] ??= c.onKeyVerificationRequest.stream
        .listen((KeyVerification request) async {
          var hidPopup = false;
          request.onUpdate = () {
            if (!hidPopup &&
                {
                  KeyVerificationState.done,
                  KeyVerificationState.error,
                }.contains(request.state)) {
              FluffyChatApp.router.pop('dialog');
            }
            hidPopup = true;
          };
          request.onUpdate = null;
          hidPopup = true;
          await KeyVerificationDialog(request: request).show(
            FluffyChatApp.router.routerDelegate.navigatorKey.currentContext ??
                context,
          );
        });
    onLoginStateChanged[name] ??= c.onLoginStateChanged.stream.listen((
      state,
    ) async {
      // #Pangea
      MatrixState.pangeaController.handleLoginStateChange(
        state,
        c.userID,
        context,
      );
      // Pangea#
      final loggedInWithMultipleClients = widget.clients.length > 1;
      if (state == LoginState.loggedOut) {
        _cancelSubs(c.clientName);
        widget.clients.remove(c);
        ClientManager.removeClientNameFromStore(c.clientName, store);
        // #Pangea
        // InitWithRestoreExtension.deleteSessionBackup(name);
        // Pangea#
      }
      if (loggedInWithMultipleClients && state != LoginState.loggedIn) {
        ScaffoldMessenger.of(
          FluffyChatApp.router.routerDelegate.navigatorKey.currentContext ??
              context,
        ).showSnackBar(
          SnackBar(content: Text(L10n.of(context).oneClientLoggedOut)),
        );

        if (state != LoginState.loggedIn) {
          FluffyChatApp.router.go('/rooms');
        }
      } else {
        // #Pangea
        // FluffyChatApp.router.go(
        //   state == LoginState.loggedIn ? '/backup' : '/home',
        // );
        if (state == LoginState.loggedIn) {
          final isL2Set = await pangeaController.userController.isUserL2Set;
          FluffyChatApp.router.go(isL2Set ? '/rooms' : '/registration/create');
        } else {
          FluffyChatApp.router.go('/home');
        }
        // Pangea#
      }
    });
    onUiaRequest[name] ??= c.onUiaRequest.stream.listen(uiaRequestHandler);
    if (PlatformInfos.isWeb || PlatformInfos.isLinux) {
      c.onSync.stream.first.then((s) {
        html.Notification.requestPermission();
        onNotification[name] ??= c.onNotification.stream.listen(
          showLocalNotification,
        );
      });
    }
    // #Pangea
    _analyticsServices[name] ??= AnalyticsDataService(c);
    // Pangea#
  }

  void _cancelSubs(String name) {
    onRoomKeyRequestSub[name]?.cancel();
    onRoomKeyRequestSub.remove(name);
    onKeyVerificationRequestSub[name]?.cancel();
    onKeyVerificationRequestSub.remove(name);
    onLoginStateChanged[name]?.cancel();
    onLoginStateChanged.remove(name);
    onNotification[name]?.cancel();
    onNotification.remove(name);
    // #Pangea
    onUiaRequest[name]?.cancel();
    onUiaRequest.remove(name);
    _analyticsServices[name]?.dispose();
    _analyticsServices.remove(name);
    // Pangea#
  }

  void initMatrix() {
    for (final c in widget.clients) {
      _registerSubs(c.clientName);
    }

    if (PlatformInfos.isMobile) {
      backgroundPush = BackgroundPush(
        this,
        onFcmError: (errorMsg, {Uri? link}) async {
          final result = await showOkCancelAlertDialog(
            context:
                FluffyChatApp
                    .router
                    .routerDelegate
                    .navigatorKey
                    .currentContext ??
                context,
            title: L10n.of(context).pushNotificationsNotAvailable,
            message: errorMsg,
            okLabel: link == null
                ? L10n.of(context).ok
                : L10n.of(context).learnMore,
            cancelLabel: L10n.of(context).doNotShowAgain,
          );
          if (result == OkCancelResult.ok && link != null) {
            launchUrlString(
              link.toString(),
              mode: LaunchMode.externalApplication,
            );
          }
          if (result == OkCancelResult.cancel) {
            await AppSettings.showNoGoogle.setItem(true);
          }
        },
      );
    }

    createVoipPlugin();
  }

  void createVoipPlugin() async {
    if (AppSettings.experimentalVoip.value) {
      voipPlugin = null;
      return;
    }
    voipPlugin = VoipPlugin(this);
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    final foreground =
        state != AppLifecycleState.inactive &&
        state != AppLifecycleState.paused;
    for (final client in widget.clients) {
      client.syncPresence = state == AppLifecycleState.resumed
          ? null
          : PresenceType.unavailable;
      if (PlatformInfos.isMobile) {
        client.backgroundSync = foreground;
        client.requestHistoryOnLimitedTimeline = !foreground;
        Logs().v('Set background sync to', foreground);
      }
    }
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);

    onRoomKeyRequestSub.values.map((s) => s.cancel());
    onKeyVerificationRequestSub.values.map((s) => s.cancel());
    onLoginStateChanged.values.map((s) => s.cancel());
    onNotification.values.map((s) => s.cancel());
    client.httpClient.close();

    linuxNotifications?.close();
    // #Pangea
    _languageListener?.cancel();
    _uriListener?.cancel();
    notifPermissionNotifier.dispose();
    // Pangea#

    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Provider(create: (_) => this, child: widget.child);
  }

  Future<void> dehydrateAction(BuildContext context) async {
    final response = await showOkCancelAlertDialog(
      context: context,
      isDestructive: true,
      title: L10n.of(context).dehydrate,
      message: L10n.of(context).dehydrateWarning,
    );
    if (response != OkCancelResult.ok) {
      return;
    }
    final result = await showFutureLoadingDialog(
      context: context,
      future: client.exportDump,
    );
    final export = result.result;
    if (export == null) return;

    final exportBytes = Uint8List.fromList(const Utf8Codec().encode(export));

    final exportFileName =
        'fluffychat-export-${DateFormat(DateFormat.YEAR_MONTH_DAY).format(DateTime.now())}.fluffybackup';

    final file = MatrixFile(bytes: exportBytes, name: exportFileName);
    file.save(context);
  }

  // #Pangea
  Future<void> _processIncomingUris(Uri? uri) async {
    if (uri == null || uri.fragment.isEmpty) return;

    final path = uri.fragment.startsWith('/')
        ? uri.fragment
        : '/${uri.fragment}';

    WidgetsBinding.instance.addPostFrameCallback((_) {
      FluffyChatApp.router.go(path);
    });
  }

  // Pangea#
}

class _AccountBundleWithClient {
  final Client? client;
  final AccountBundle? bundle;

  _AccountBundleWithClient({this.client, this.bundle});
}