Import History

// Extracts YouTube ID from track comment or filename
final videoId = extractYoutubeId(track.comment) ?? 
                extractYoutubeId(track.filename);

// Matches history entry by ID
if (historyEntry.id == videoId) {
  addToHistory(track, date: historyEntry.timestamp);
}

// Matching criteria (all must be true):
// 1. Video title contains track title
// 2. Video title OR channel contains artist name
// 3. OR channel name matches album name

final titleMatch = videoTitle.contains(track.title);
final artistMatch = videoTitle.contains(track.artist) ||
                    channelName.contains(track.artist) ||
                    channelName.contains(track.album);

if (titleMatch && artistMatch) {
  // Track is considered a match
}

// Local history (matched tracks)
HistoryController.inst.addTracksToHistory(matchedTracks);

// YouTube history (all videos)
YoutubeHistoryController.inst.addVideosToHistory(allVideos);

// Phase 1: Direct matching by title and artist
final titleMatches = tracksGroupedByTitle[csvTitle];
final artistMatches = tracksGroupedByArtist[csvArtist];

// Find intersection of both
final directMatches = titleMatches.where(
  (track) => artistMatches.contains(track)
);

// Phase 2: Fuzzy matching (if no direct match)
if (directMatches.isEmpty) {
  final fuzzyMatches = allTracks.where((track) {
    // CSV title contains track title
    final titleMatch = csvTitle.contains(track.title);
    
    // CSV artist contains any track artist
    final artistMatch = track.artistsList.any(
      (artist) => csvArtist.contains(artist)
    );
    
    return titleMatch && artistMatch;
  });
}

final progress = {
  'parsed': parsedHistoryJson.value,        // Total entries processed
  'total': totalJsonToParse.value,          // Total entries to process
  'added': addedHistoryJsonToPlaylist.value, // Successfully matched
  'percentage': (parsed / total * 100),     // Progress percentage
};

// System notification during import
NotificationManager.instance.importHistoryNotification(
  parsed: currentProgress,
  total: totalEntries,
  startTime: importStartTime,
);

// Missing entry structure
final missingEntry = {
  'title': 'Track Title',
  'artist': 'Artist Name',
  'channel': 'YouTube Channel',  // For YouTube imports
  'source': TrackSource.youtube,
  'dates': [timestamp1, timestamp2, ...], // All occurrence timestamps
};

await addFilesSourceToNamidaHistory(
  files: historyFiles,
  source: TrackSource.youtube,
  oldestDate: DateTime(2023, 1, 1),
  newestDate: DateTime(2024, 1, 1),
);

// Match YouTube history entries to newly downloaded tracks
final (totalCount, addedCount) = await copyYTHistoryContentToLocalHistory(
  matchAll: false,
);

print('Matched $addedCount of $totalCount YouTube history entries');

// Automatic chunking and progress updates
const chunkSize = 20;
int totalParsed = 0;

for (final entry in historyEntries) {
  processEntry(entry);
  totalParsed++;
  
  if (totalParsed >= chunkSize) {
    // Update progress UI
    sendProgressUpdate(totalParsed);
    totalParsed = 0;
  }
}

// Supports nested ZIPs (Google Takeout format)
await for (final file in zipContents) {
  if (file.path.contains('watch-history.json')) {
    processHistoryFile(file);
  }
}

// Updates YouTube video watch counts and metadata
await updateYoutubeStatsDirectory(
  affectedIds: importedVideoIds,
  onProgress: (count) => print('Updated $count videos'),
);