fluffychat/lib/pangea/chat_settings/widgets/delete_space_dialog.dart

import 'package:flutter/material.dart';

import 'package:go_router/go_router.dart';
import 'package:matrix/matrix.dart';

import 'package:fluffychat/config/themes.dart';
import 'package:fluffychat/l10n/l10n.dart';
import 'package:fluffychat/pangea/activity_sessions/activity_room_extension.dart';
import 'package:fluffychat/pangea/chat_settings/utils/delete_room.dart';
import 'package:fluffychat/pangea/common/utils/error_handler.dart';
import 'package:fluffychat/pangea/common/widgets/error_indicator.dart';
import 'package:fluffychat/pangea/extensions/pangea_room_extension.dart';
import 'package:fluffychat/widgets/future_loading_dialog.dart';

class DeleteSpaceDialog extends StatefulWidget {
  final Room space;
  const DeleteSpaceDialog({super.key, required this.space});

  static Future<void> show(Room room, BuildContext context) async {
    final resp = await showDialog<List<SpaceRoomsChunk$2>?>(
      context: context,
      builder: (_) => DeleteSpaceDialog(space: room),
    );
    if (resp == null) return;
    final result = await showFutureLoadingDialog(
      context: context,
      future: () => _deleteSpace(room, resp),
    );

    if (!result.isError) {
      context.go("/rooms");
    }
  }

  static Future<void> _deleteSpace(
    Room space,
    List<SpaceRoomsChunk$2> rooms,
  ) async {
    final List<Future<void>> futures = [];
    for (final room in rooms) {
      final roomInstance = space.client.getRoomById(room.roomId);
      if (roomInstance != null) {
        // Niether delete not leave activities the user has archived,
        // since they're hidden in the main chat UI.
        if (roomInstance.isActivitySession) {
          if (!roomInstance.hasArchivedActivity) {
            futures.add(roomInstance.leave());
          }
        } else {
          futures.add(roomInstance.delete());
        }
      }
    }
    await Future.wait(futures);
    await space.delete();
  }

  @override
  State<DeleteSpaceDialog> createState() => DeleteSpaceDialogState();
}

class DeleteSpaceDialogState extends State<DeleteSpaceDialog> {
  List<SpaceRoomsChunk$2> _rooms = [];
  final List<SpaceRoomsChunk$2> _roomsToDelete = [];

  bool _loadingRooms = true;
  String? _roomLoadError;

  final bool _deleting = false;
  String? _deleteError;

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addPostFrameCallback(
      (_) => _getSpaceChildrenToDelete(),
    );
  }

  Future<void> _getSpaceChildrenToDelete() async {
    setState(() {
      _loadingRooms = true;
      _roomLoadError = null;
    });

    try {
      _rooms = await widget.space.getSpaceChildrenToDelete();
    } catch (e, s) {
      _roomLoadError = L10n.of(context).errorLoadingSpaceChildren;
      ErrorHandler.logError(e: e, s: s, data: {"roomID": widget.space.id});
    } finally {
      setState(() {
        _loadingRooms = false;
      });
    }
  }

  void _onRoomSelected(bool? selected, SpaceRoomsChunk$2 room) {
    if (selected == null ||
        (selected && _roomsToDelete.contains(room)) ||
        (!selected && !_roomsToDelete.contains(room))) {
      return;
    }

    setState(() {
      selected ? _roomsToDelete.add(room) : _roomsToDelete.remove(room);
    });
  }

  void _toggleSelectAll() {
    setState(() {
      if (_roomsToDelete.length == _selectableRooms.length) {
        _roomsToDelete.clear();
      } else {
        _roomsToDelete
          ..clear()
          ..addAll(_selectableRooms);
      }
    });
  }

  List<SpaceRoomsChunk$2> get _selectableRooms {
    return _rooms.where((chunk) {
      final room = widget.space.client.getRoomById(chunk.roomId);
      return room != null &&
          room.membership == Membership.join &&
          room.isRoomAdmin;
    }).toList();
  }

  @override
  Widget build(BuildContext context) {
    return Dialog(
      shape: RoundedRectangleBorder(
        side: BorderSide(color: Theme.of(context).colorScheme.error),
        borderRadius: BorderRadius.circular(32.0),
      ),
      child: Container(
        constraints: const BoxConstraints(maxWidth: 400, maxHeight: 600),
        padding: const EdgeInsets.symmetric(vertical: 20),
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            Text(
              L10n.of(context).areYouSure,
              style: Theme.of(context).textTheme.titleLarge?.copyWith(
                color: Theme.of(context).colorScheme.error,
              ),
            ),
            Padding(
              padding: const EdgeInsets.symmetric(
                horizontal: 16.0,
                vertical: 8.0,
              ),
              child: Text(
                widget.space.spaceChildCount > 0
                    ? L10n.of(context).deleteSpaceDesc
                    : L10n.of(context).deleteEmptySpaceDesc,
                textAlign: TextAlign.center,
                style: TextStyle(color: Theme.of(context).colorScheme.error),
              ),
            ),
            if (widget.space.spaceChildCount != 0)
              Builder(
                builder: (context) {
                  if (_loadingRooms) {
                    return const Center(
                      child: SizedBox(
                        height: 20,
                        width: 20,
                        child: CircularProgressIndicator.adaptive(),
                      ),
                    );
                  }

                  if (_roomLoadError != null) {
                    return Center(
                      child: Padding(
                        padding: const EdgeInsets.symmetric(vertical: 16.0),
                        child: ErrorIndicator(message: _roomLoadError!),
                      ),
                    );
                  }

                  return Expanded(
                    child: Padding(
                      padding: const EdgeInsets.symmetric(vertical: 16.0),
                      child: Column(
                        mainAxisSize: MainAxisSize.min,
                        children: [
                          if (_selectableRooms.length > 1)
                            CheckboxListTile(
                              value:
                                  _roomsToDelete.length ==
                                  _selectableRooms.length,
                              onChanged: (_) => _toggleSelectAll(),
                              title: Text(
                                _roomsToDelete.length == _selectableRooms.length
                                    ? L10n.of(context).deselectAll
                                    : L10n.of(context).selectAll,
                              ),
                              controlAffinity: ListTileControlAffinity.leading,
                            ),
                          Expanded(
                            child: ListView.builder(
                              itemCount: _rooms.length,
                              itemBuilder: (context, index) {
                                final chunk = _rooms[index];

                                final room = widget.space.client.getRoomById(
                                  chunk.roomId,
                                );
                                final isMember =
                                    room != null &&
                                    room.membership == Membership.join &&
                                    room.isRoomAdmin;

                                final displayname =
                                    chunk.name ??
                                    chunk.canonicalAlias ??
                                    L10n.of(context).emptyChat;

                                return AnimatedOpacity(
                                  duration: FluffyThemes.animationDuration,
                                  opacity: isMember ? 1 : 0.5,
                                  child: CheckboxListTile(
                                    value: _roomsToDelete.contains(chunk),
                                    onChanged: isMember
                                        ? (value) =>
                                              _onRoomSelected(value, chunk)
                                        : null,
                                    title: Text(displayname),
                                    controlAffinity:
                                        ListTileControlAffinity.leading,
                                  ),
                                );
                              },
                            ),
                          ),
                        ],
                      ),
                    ),
                  );
                },
              ),
            Padding(
              padding: const EdgeInsets.fromLTRB(8.0, 16.0, 8.0, 8.0),
              child: Row(
                spacing: 8.0,
                mainAxisAlignment: MainAxisAlignment.center,
                children: [
                  OutlinedButton(
                    onPressed: Navigator.of(context).pop,
                    child: Text(L10n.of(context).cancel),
                  ),
                  AnimatedSize(
                    duration: FluffyThemes.animationDuration,
                    child: OutlinedButton(
                      onPressed: () =>
                          Navigator.of(context).pop(_roomsToDelete),
                      style: OutlinedButton.styleFrom(
                        foregroundColor: Theme.of(context).colorScheme.error,
                        side: BorderSide(
                          color: _deleting
                              ? Theme.of(context).disabledColor
                              : Theme.of(context).colorScheme.error,
                        ),
                      ),
                      child: _deleting
                          ? const SizedBox(
                              height: 10,
                              width: 100,
                              child: LinearProgressIndicator(),
                            )
                          : Text(L10n.of(context).delete),
                    ),
                  ),
                ],
              ),
            ),
            AnimatedSize(
              duration: FluffyThemes.animationDuration,
              child: _deleteError != null
                  ? Padding(
                      padding: const EdgeInsets.all(8.0),
                      child: Text(_deleteError!),
                    )
                  : const SizedBox(),
            ),
          ],
        ),
      ),
    );
  }
}