immich/mobile/lib/services/folder.service.dart

import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:immich_mobile/constants/enums.dart';
import 'package:immich_mobile/entities/asset.entity.dart';
import 'package:immich_mobile/models/folder/recursive_folder.model.dart';
import 'package:immich_mobile/models/folder/root_folder.model.dart';
import 'package:immich_mobile/repositories/folder_api.repository.dart';
import 'package:logging/logging.dart';

final folderServiceProvider = Provider(
  (ref) => FolderService(ref.watch(folderApiRepositoryProvider)),
);

class FolderService {
  final FolderApiRepository _folderApiRepository;
  final Logger _log = Logger("FolderService");

  FolderService(this._folderApiRepository);

  Future<RootFolder> getFolderStructure(SortOrder order) async {
    final paths = await _folderApiRepository.getAllUniquePaths();

    // Create folder structure
    Map<String, List<RecursiveFolder>> folderMap = {};

    for (String fullPath in paths) {
      if (fullPath == '/') continue;

      // Ensure the path starts with a slash
      if (!fullPath.startsWith('/')) {
        fullPath = '/$fullPath';
      }

      List<String> segments = fullPath.split('/')
        ..removeWhere((s) => s.isEmpty);

      String currentPath = '';

      for (int i = 0; i < segments.length; i++) {
        String parentPath = currentPath.isEmpty ? '_root_' : currentPath;
        currentPath =
            i == 0 ? '/${segments[i]}' : '$currentPath/${segments[i]}';

        if (!folderMap.containsKey(parentPath)) {
          folderMap[parentPath] = [];
        }

        if (!folderMap[parentPath]!.any((f) => f.name == segments[i])) {
          folderMap[parentPath]!.add(
            RecursiveFolder(
              path: parentPath == '_root_' ? '' : parentPath,
              name: segments[i],
              subfolders: [],
            ),
          );
          // Sort folders based on order parameter
          folderMap[parentPath]!.sort(
            (a, b) => order == SortOrder.desc
                ? b.name.compareTo(a.name)
                : a.name.compareTo(b.name),
          );
        }
      }
    }

    void attachSubfolders(RecursiveFolder folder) {
      String fullPath = folder.path.isEmpty
          ? '/${folder.name}'
          : '${folder.path}/${folder.name}';

      if (folderMap.containsKey(fullPath)) {
        folder.subfolders.addAll(folderMap[fullPath]!);
        // Sort subfolders based on order parameter
        folder.subfolders.sort(
          (a, b) => order == SortOrder.desc
              ? b.name.compareTo(a.name)
              : a.name.compareTo(b.name),
        );
        for (var subfolder in folder.subfolders) {
          attachSubfolders(subfolder);
        }
      }
    }

    List<RecursiveFolder> rootSubfolders = folderMap['_root_'] ?? [];
    // Sort root subfolders based on order parameter
    rootSubfolders.sort(
      (a, b) => order == SortOrder.desc
          ? b.name.compareTo(a.name)
          : a.name.compareTo(b.name),
    );

    for (var folder in rootSubfolders) {
      attachSubfolders(folder);
    }

    return RootFolder(
      subfolders: rootSubfolders,
      path: '/',
    );
  }

  Future<List<Asset>> getFolderAssets(
    RootFolder folder,
    SortOrder order,
  ) async {
    try {
      if (folder is RecursiveFolder) {
        String fullPath =
            folder.path.isEmpty ? folder.name : '${folder.path}/${folder.name}';
        fullPath = fullPath[0] == '/' ? fullPath.substring(1) : fullPath;
        var result = await _folderApiRepository.getAssetsForPath(fullPath);

        if (order == SortOrder.desc) {
          result.sort((a, b) => b.fileCreatedAt.compareTo(a.fileCreatedAt));
        } else {
          result.sort((a, b) => a.fileCreatedAt.compareTo(b.fileCreatedAt));
        }

        return result;
      }
      final result = await _folderApiRepository.getAssetsForPath('/');
      return result;
    } catch (e, stack) {
      _log.severe(
        "Failed to fetch assets for folder ${folder is RecursiveFolder ? folder.name : "root"}",
        e,
        stack,
      );
      return [];
    }
  }
}