Local File Import

for (String filePath in level0FilesPaths) {
  try {
    // Extract metadata from the audio file
    Metadata metadata;
    try {
      metadata = await MediaHelper.getAudioMetadata(filePath, rootFolderPath)
          .timeout(const Duration(seconds: 60));
    } catch (timeoutError) {
      // Create basic metadata as fallback
      metadata = Metadata(
        trackName: path.basenameWithoutExtension(filePath),
        albumName: path.basenameWithoutExtension(filePath),
        albumArtistName: 'Unknown',
        trackDuration: null,
        albumArt: null,
        filePath: filePath,
      );
    }

    // Get title and author from metadata
    String title = metadata.albumName ??
        metadata.trackName ??
        path.basenameWithoutExtension(filePath);
    String author = metadata.albumArtistName ??
        metadata.trackArtistNames?.join(', ') ??
        'Unknown';

    // Look for cover image with same name as audio file
    String? coverImagePath = await MediaHelper.findCoverImageForAudioFile(
        filePath, rootFolderPath);

    // If no cover image found, try to extract from metadata
    if (coverImagePath == null && metadata.albumArt != null) {
      coverImagePath = await MediaHelper.saveAlbumArtFromMetadata(
          metadata.albumArt!, path.basenameWithoutExtension(filePath));
    }

    // Create the audiobook object
    final audiobook = LocalAudiobook(
      id: filePath,
      title: title,
      author: author,
      folderPath: rootFolderPath,
      coverImagePath: coverImagePath,
      audioFiles: [filePath],
      totalDuration: metadata.trackDuration != null
          ? Duration(milliseconds: metadata.trackDuration!)
          : null,
      dateAdded: DateTime.now(),
      lastModified: DateTime.now(),
      description: metadata.authorName ?? metadata.writerName,
      genre: metadata.genre,
    );

    audiobooks.add(audiobook);
  } catch (e) {
    AppLogger.error('Error processing audiobook $filePath: $e');
    continue;
  }
}

for (String subfolder in folderGroups.keys) {
  List<String> filesInFolder = folderGroups[subfolder]!;

  // Filter audio files
  List<String> audioFiles = [];
  for (String filePath in filesInFolder) {
    if (await MediaHelper.isAudioFile(filePath)) {
      audioFiles.add(filePath);
    }
  }

  if (audioFiles.isEmpty) continue;

  // Title is the subfolder name (capitalized)
  String title = MediaHelper.capitalizeWords(subfolder);
  String author = 'Unknown';

  // Find cover image in the subfolder
  String? coverImagePath = await MediaHelper.findCoverImageInFolder(
      filesInFolder, subfolder, rootFolderPath);

  // If no cover found, try to extract from first audio file metadata
  if (coverImagePath == null && audioFiles.isNotEmpty) {
    coverImagePath = await MediaHelper.extractCoverFromAudioMetadata(
        audioFiles.first, rootFolderPath, subfolder);
  }

  // Calculate total duration from all audio files
  Duration? totalDuration = await MediaHelper.calculateTotalDuration(
      audioFiles, rootFolderPath);

  final audiobook = LocalAudiobook(
    id: path.join(rootFolderPath, subfolder),
    title: title,
    author: author,
    folderPath: path.join(rootFolderPath, subfolder),
    coverImagePath: coverImagePath,
    audioFiles: audioFiles,
    totalDuration: totalDuration,
    dateAdded: DateTime.now(),
    lastModified: DateTime.now(),
  );

  audiobooks.add(audiobook);
}

for (String author in authorBookGroups.keys) {
  for (String book in authorBookGroups[author]!.keys) {
    List<String> filesInBook = authorBookGroups[author]![book]!;

    // Filter audio files
    List<String> audioFiles = [];
    for (String filePath in filesInBook) {
      if (await MediaHelper.isAudioFile(filePath)) {
        audioFiles.add(filePath);
      }
    }

    if (audioFiles.isEmpty) continue;

    // Title is the book name, Author is the author name
    String title = MediaHelper.capitalizeWords(book);
    String authorName = MediaHelper.capitalizeWords(author);

    // Find cover image in the book folder
    String? coverImagePath = await MediaHelper.findCoverImageInFolder(
        filesInBook, book, rootFolderPath);

    // If no cover found, try to extract from first audio file
    if (coverImagePath == null && audioFiles.isNotEmpty) {
      coverImagePath = await MediaHelper.extractCoverFromAudioMetadata(
          audioFiles.first, rootFolderPath, book);
    }

    // Calculate total duration from all audio files
    Duration? totalDuration = await MediaHelper.calculateTotalDuration(
        audioFiles, rootFolderPath);

    final audiobook = LocalAudiobook(
      id: path.join(rootFolderPath, author, book),
      title: title,
      author: authorName,
      folderPath: path.join(rootFolderPath, author, book),
      coverImagePath: coverImagePath,
      audioFiles: audioFiles,
      totalDuration: totalDuration,
      dateAdded: DateTime.now(),
      lastModified: DateTime.now(),
    );

    audiobooks.add(audiobook);
  }
}

static Future<List<LocalAudiobook>> smartRefreshAudiobooks() async {
  // Get current file list from SAF
  List<String>? currentFiles = await Saf.getFilesPathFor(rootFolderPath);
  
  // Get cached file list
  List<String>? cachedFiles = await getLastScannedFiles();

  // If no cache exists, do a full scan
  if (cachedFiles == null) {
    final scanned = await scanForAudiobooks();
    await saveScannedFiles(currentFiles);
    return scanned;
  }

  // Compare file lists to detect changes
  Set<String> currentFileSet = currentFiles.toSet();
  Set<String> cachedFileSet = cachedFiles.toSet();

  Set<String> newFiles = currentFileSet.difference(cachedFileSet);
  Set<String> deletedFiles = cachedFileSet.difference(currentFileSet);
  Set<String> changedFiles = newFiles.union(deletedFiles);

  // If no changes, return cached audiobooks
  if (changedFiles.isEmpty) {
    await saveScannedFiles(currentFiles); // Update scan time
    return await getAllAudiobooks();
  }

  // Get affected audiobook IDs
  Set<String> affectedIds =
      _getAffectedAudiobookIds(changedFiles.toList(), rootFolderPath);

  // Process only affected audiobooks
  for (String audiobookId in affectedIds) {
    // Get files for this specific audiobook
    List<String> audiobookFiles = currentFiles.where((file) {
      String? fileAudiobookId =
          _getAudiobookIdForFile(file, rootFolderPath);
      return fileAudiobookId == audiobookId;
    }).toList();

    // Process the audiobook
    LocalAudiobook? processedAudiobook = await _processSingleAudiobook(
        audiobookId, audiobookFiles, level, rootFolderPath);

    if (processedAudiobook != null) {
      audiobookMap[audiobookId] = processedAudiobook;
      await updateAudiobook(processedAudiobook);
    }
  }

  return audiobookMap.values.toList();
}

/// Get the last scanned file paths from cache
static Future<List<String>?> getLastScannedFiles() async {
  try {
    final box = await Hive.openBox(_fileCacheBoxName);
    final cacheData = box.get('file_cache');
    if (cacheData != null) {
      final map = Map<String, dynamic>.from(cacheData);
      return List<String>.from(map['file_paths'] ?? []);
    }
    return null;
  } catch (e) {
    AppLogger.error('Error getting last scanned files from cache: $e');
    return null;
  }
}

/// Save the scanned file paths to cache
static Future<void> saveScannedFiles(List<String> files) async {
  try {
    final box = await Hive.openBox(_fileCacheBoxName);
    final cacheData = {
      'file_paths': files,
      'last_scan_time': DateTime.now().millisecondsSinceEpoch,
    };
    await box.put('file_cache', cacheData);
  } catch (e) {
    AppLogger.error('Error saving scanned files to cache: $e');
  }
}