managarten/memoro/apps/mobile/features/storage/fileSystemUtils.ts

/**
 * FileSystem Utility Module for Expo SDK 54
 *
 * This module provides wrapper functions using the new File/Directory class-based API
 * introduced in Expo SDK 54, maintaining a similar interface to the legacy API
 * for easier migration.
 */

import { File, Directory, Paths } from 'expo-file-system';

/**
 * Encoding types for file operations
 */
export const EncodingType = {
  UTF8: 'utf8' as const,
  Base64: 'base64' as const,
} as const;

export type EncodingTypeValue = typeof EncodingType[keyof typeof EncodingType];

/**
 * File operation options
 */
export interface FileOperationOptions {
  encoding?: EncodingTypeValue;
  intermediates?: boolean;
}

/**
 * File information result
 */
export interface FileInfo {
  exists: boolean;
  isDirectory?: boolean;
  size?: number;
  modificationTime?: number;
  uri?: string;
}

/**
 * Get the document directory path
 */
export function getDocumentDirectory(): string {
  const docDir = Paths.document.uri;
  console.log('[FileSystemUtils] getDocumentDirectory returns:', docDir);
  // Ensure the path ends with a single slash
  return docDir.endsWith('/') ? docDir : docDir + '/';
}

/**
 * Get the cache directory path
 */
export function getCacheDirectory(): string {
  return Paths.cache.uri;
}

/**
 * Write string content to a file
 * Wrapper for the new File API
 */
export async function writeStringToFile(
  fileUri: string,
  contents: string,
  options?: FileOperationOptions
): Promise<void> {
  // Parse the file path to get directory and filename
  const lastSlash = fileUri.lastIndexOf('/');
  const dirPath = fileUri.substring(0, lastSlash);
  const fileName = fileUri.substring(lastSlash + 1);

  const directory = new Directory(dirPath);
  const file = new File(directory, fileName);

  // Ensure directory exists
  if (!directory.exists) {
    directory.create({ intermediates: true });
  }

  // Create and write the file
  if (!file.exists) {
    file.create();
  }

  // Convert content based on encoding
  if (options?.encoding === 'base64') {
    // For base64, we need to convert the string to Uint8Array
    const binaryString = atob(contents);
    const bytes = new Uint8Array(binaryString.length);
    for (let i = 0; i < binaryString.length; i++) {
      bytes[i] = binaryString.charCodeAt(i);
    }
    file.write(bytes);
  } else {
    file.write(contents);
  }
}

/**
 * Read string content from a file
 * Wrapper for the new File API
 */
export async function readStringFromFile(
  fileUri: string,
  options?: FileOperationOptions
): Promise<string> {
  // Parse the file path
  const lastSlash = fileUri.lastIndexOf('/');
  const dirPath = fileUri.substring(0, lastSlash);
  const fileName = fileUri.substring(lastSlash + 1);

  const directory = new Directory(dirPath);
  const file = new File(directory, fileName);

  if (options?.encoding === 'base64') {
    return file.base64();
  }
  return file.text();
}

/**
 * Delete a file or directory
 * Wrapper for the new File/Directory API
 */
export async function deleteFile(
  fileUri: string,
  options?: { idempotent?: boolean }
): Promise<void> {
  try {
    // Try as file first
    const lastSlash = fileUri.lastIndexOf('/');
    const dirPath = fileUri.substring(0, lastSlash);
    const fileName = fileUri.substring(lastSlash + 1);

    const directory = new Directory(dirPath);
    const file = new File(directory, fileName);

    if (file.exists) {
      file.delete();
      return;
    }

    // Try as directory
    const dir = new Directory(fileUri);
    if (dir.exists) {
      dir.delete();
      return;
    }

    // If idempotent is false and nothing was deleted, throw error
    if (!options?.idempotent) {
      throw new Error(`File or directory not found: ${fileUri}`);
    }
  } catch (error) {
    if (!options?.idempotent) {
      throw error;
    }
  }
}

/**
 * Copy a file to a new location
 * Wrapper for the new File API
 */
export async function copyFile(
  source: string,
  destination: string
): Promise<void> {
  console.log('[FileSystemUtils] copyFile called - source:', source, 'dest:', destination);

  // Parse source path
  const sourceLastSlash = source.lastIndexOf('/');
  const sourceDirPath = source.substring(0, sourceLastSlash);
  const sourceFileName = source.substring(sourceLastSlash + 1);
  console.log('[FileSystemUtils] Source - dir:', sourceDirPath, 'file:', sourceFileName);

  // Parse destination path
  const destLastSlash = destination.lastIndexOf('/');
  const destDirPath = destination.substring(0, destLastSlash);
  const destFileName = destination.substring(destLastSlash + 1);
  console.log('[FileSystemUtils] Destination - dir:', destDirPath, 'file:', destFileName);

  const sourceDir = new Directory(sourceDirPath);
  const sourceFile = new File(sourceDir, sourceFileName);
  console.log('[FileSystemUtils] Source file exists:', sourceFile.exists);

  const destDir = new Directory(destDirPath);
  console.log('[FileSystemUtils] Destination dir exists:', destDir.exists);

  // Ensure destination directory exists
  if (!destDir.exists) {
    console.log('[FileSystemUtils] Creating destination directory with intermediates');
    destDir.create({ intermediates: true });
  }

  const destFile = new File(destDir, destFileName);
  console.log('[FileSystemUtils] Copying file...');

  sourceFile.copy(destFile);
  console.log('[FileSystemUtils] File copied successfully');
}

/**
 * Create a directory
 * Wrapper for the new Directory API
 */
export async function createDirectory(
  fileUri: string,
  options?: { intermediates?: boolean }
): Promise<void> {
  const directory = new Directory(fileUri);

  if (!directory.exists) {
    directory.create({
      intermediates: options?.intermediates || false
    });
  }
}

/**
 * Get information about a file or directory
 * Wrapper for the new File/Directory API
 */
export async function getFileInfo(
  fileUri: string,
  options?: { size?: boolean }
): Promise<FileInfo> {
  console.log('[FileSystemUtils] getFileInfo called with:', fileUri);

  try {
    // Try as file first
    const lastSlash = fileUri.lastIndexOf('/');
    const dirPath = fileUri.substring(0, lastSlash);
    const fileName = fileUri.substring(lastSlash + 1);

    console.log('[FileSystemUtils] Checking as file - dir:', dirPath, 'file:', fileName);

    const directory = new Directory(dirPath);
    const file = new File(directory, fileName);

    console.log('[FileSystemUtils] File exists:', file.exists);

    if (file.exists) {
      // In Expo SDK 54, size is a property directly on the File object
      console.log('[FileSystemUtils] File.size value:', file.size);
      // Always return size if available - it's a useful property
      console.log('[FileSystemUtils] Returning file info with size:', file.size);
      return {
        exists: true,
        isDirectory: false,
        size: file.size,  // Always return size when file exists
        uri: fileUri,
      };
    }

    // Try as directory
    console.log('[FileSystemUtils] Checking as directory:', fileUri);
    const dir = new Directory(fileUri);
    console.log('[FileSystemUtils] Directory exists:', dir.exists);

    if (dir.exists) {
      return {
        exists: true,
        isDirectory: true,
        uri: fileUri,
      };
    }

    console.log('[FileSystemUtils] Neither file nor directory exists');
    return { exists: false };
  } catch (error) {
    console.log('[FileSystemUtils] Error in getFileInfo:', error);
    return { exists: false };
  }
}

/**
 * Read the contents of a directory
 * Wrapper for the new Directory API
 */
export async function readDirectory(fileUri: string): Promise<string[]> {
  console.log('[FileSystemUtils] readDirectory called with:', fileUri);

  const directory = new Directory(fileUri);
  console.log('[FileSystemUtils] Directory exists:', directory.exists);

  const entries = directory.list();
  console.log('[FileSystemUtils] Directory.list() returned:', entries?.length || 0, 'entries');

  if (entries && entries.length > 0) {
    // Log the first entry to understand its structure
    console.log('[FileSystemUtils] First entry type:', typeof entries[0]);
    console.log('[FileSystemUtils] First entry keys:', Object.keys(entries[0]));
    console.log('[FileSystemUtils] First entry:', JSON.stringify(entries[0], null, 2));

    // Check if entry has 'name' property
    if (entries[0].name !== undefined) {
      console.log('[FileSystemUtils] Entry has "name" property:', entries[0].name);
    }

    // Check if entry has 'uri' property
    if (entries[0].uri !== undefined) {
      console.log('[FileSystemUtils] Entry has "uri" property:', entries[0].uri);
    }
  }

  // Extract names from the File/Directory objects
  // In Expo SDK 54, the objects have a 'name' property directly
  const fileNames = entries.map(entry => {
    const name = entry.name || (entry.uri ? entry.uri.split('/').pop() : 'unknown') || 'unknown';
    console.log('[FileSystemUtils] Mapped entry to name:', name);
    return name;
  });

  console.log('[FileSystemUtils] Returning file names:', fileNames);
  return fileNames;
}

/**
 * Move a file to a new location
 * Wrapper for the new File API
 */
export async function moveFile(
  source: string,
  destination: string
): Promise<void> {
  // Parse source path
  const sourceLastSlash = source.lastIndexOf('/');
  const sourceDirPath = source.substring(0, sourceLastSlash);
  const sourceFileName = source.substring(sourceLastSlash + 1);

  // Parse destination path
  const destLastSlash = destination.lastIndexOf('/');
  const destDirPath = destination.substring(0, destLastSlash);
  const destFileName = destination.substring(destLastSlash + 1);

  const sourceDir = new Directory(sourceDirPath);
  const sourceFile = new File(sourceDir, sourceFileName);

  const destDir = new Directory(destDirPath);

  // Ensure destination directory exists
  if (!destDir.exists) {
    destDir.create({ intermediates: true });
  }

  const destFile = new File(destDir, destFileName);

  sourceFile.move(destFile);
}

// No legacy aliases - use the new function names directly