resolvePath method

Future<Map<String, dynamic>> resolvePath(String path)

Implementation

Future<Map<String, dynamic>> resolvePath(String path) async {
  if (baseFolderUUID.isEmpty) throw Exception("Not logged in");

  var cleanPath = path.trim();
  if (cleanPath.startsWith('/')) cleanPath = cleanPath.substring(1);
  if (cleanPath.endsWith('/'))
    cleanPath = cleanPath.substring(0, cleanPath.length - 1);

  if (cleanPath.isEmpty || cleanPath == '.') {
    return {
      'type': 'folder',
      'uuid': baseFolderUUID,
      'metadata': {'uuid': baseFolderUUID, 'name': 'Root'},
      'path': '/'
    };
  }

  if (cache.pathCache.containsKey(cleanPath)) {
    return cache.pathCache[cleanPath]!;
  }

  String currentUuid = baseFolderUUID;
  String resolvedPath = '/';
  Map<String, dynamic> currentMetadata = {
    'uuid': baseFolderUUID,
    'name': 'Root'
  };

  final pathParts = cleanPath.split('/').where((p) => p.isNotEmpty).toList();

  for (var i = 0; i < pathParts.length; i++) {
    final part = pathParts[i];
    final isLastPart = (i == pathParts.length - 1);
    final currentPartPath = '$resolvedPath$part'.replaceAll('//', '/');

    if (cache.pathCache
        .containsKey(currentPartPath.replaceAll(RegExp(r'^/'), ''))) {
      final cached =
          cache.pathCache[currentPartPath.replaceAll(RegExp(r'^/'), '')]!;
      currentUuid = cached['uuid'];
      currentMetadata = cached['metadata'] ?? cached;
      resolvedPath = '$currentPartPath/';
      if (isLastPart) return cached;
      continue;
    }

    final folders = await cache.listFoldersAsync(currentUuid,
        detailed: true, api: api, crypto: crypto, masterKeys: masterKeys);
    Map<String, dynamic>? foundFolder;

    for (var folder in folders) {
      if (folder['name'] == part) {
        foundFolder = folder;
        break;
      }
    }

    Map<String, dynamic>? foundFile;
    if (isLastPart) {
      final files = await cache.listFolderFiles(currentUuid,
          detailed: true, api: api, crypto: crypto, masterKeys: masterKeys);
      for (var file in files) {
        if (file['name'] == part) {
          foundFile = file;
          break;
        }
      }
    }

    if (foundFolder != null && (!isLastPart || foundFile == null)) {
      currentUuid = foundFolder['uuid'];
      currentMetadata = foundFolder;
      resolvedPath = '$resolvedPath$part/'.replaceAll('//', '/');

      final result = {
        'type': 'folder',
        'uuid': foundFolder['uuid'],
        'metadata': foundFolder,
        'path': resolvedPath.substring(0, resolvedPath.length - 1),
        'parent': foundFolder['parent'],
      };
      cache.pathCache[result['path'] as String] = result;
      if (isLastPart) return result;
    } else if (foundFile != null && isLastPart) {
      resolvedPath = '$resolvedPath$part'.replaceAll('//', '/');
      return {
        'type': 'file',
        'uuid': foundFile['uuid'],
        'metadata': foundFile,
        'path': resolvedPath,
        'parent': currentUuid,
      };
    } else {
      throw Exception("Path not found: $resolvedPath$part");
    }
  }

  return {
    'type': 'folder',
    'uuid': currentUuid,
    'metadata': currentMetadata,
    'path': resolvedPath.isEmpty ? '/' : resolvedPath
  };
}