Add database loading for existing files in metadataStore

internal/api/handlers.go

@@ -1427,6 +1427,41 @@ func (g *Gateway) RefreshAllMetadataStreamingInfo() error {
 	return nil
 }
 
+// LoadExistingFilesToMetadataStore loads all public files from database into metadataStore
+func (g *Gateway) LoadExistingFilesToMetadataStore() error {
+	// Get all public files from database
+	files, err := g.storage.GetPublicFiles()
+	if err != nil {
+		return fmt.Errorf("failed to get public files: %w", err)
+	}
+	
+	log.Printf("DEBUG: Found %d public files in database", len(files))
+	
+	for _, file := range files {
+		// Get full metadata for this file
+		metadata, err := g.getMetadata(file.Hash)
+		if err != nil {
+			log.Printf("Warning: Failed to get metadata for %s: %v", file.Hash, err)
+			continue
+		}
+		
+		// Convert to FileMetadata format for metadataStore
+		fileMetadata := FileMetadata{
+			FileName:      file.OriginalName,
+			TotalSize:     file.Size,
+			Chunks:        []ChunkInfo{}, // Will be populated by getMetadata if needed
+			StreamingInfo: metadata.StreamingInfo,
+			TorrentInfo:   metadata.TorrentInfo,
+		}
+		
+		// Store in metadataStore
+		metadataStore[file.Hash] = fileMetadata
+		log.Printf("DEBUG: Loaded file %s into metadataStore", file.Hash)
+	}
+	
+	return nil
+}
+
 func (g *Gateway) getMetadata(fileHash string) (*FileMetadata, error) {
 	// Get metadata from storage backend
 	dbMetadata, err := g.storage.GetFileMetadata(fileHash)
@@ -3186,8 +3221,13 @@ func RegisterRoutes(r *mux.Router, cfg *config.Config, storage *storage.Backend)
 	if gateway.transcodingManager != nil {
 		gateway.transcodingManager.SetUpdateMetadataCallback(gateway.UpdateMetadataStreamingInfo)
 		
-		// Refresh existing files to add streaming info for already transcoded files
+		// Load existing files from database into metadataStore and refresh streaming info
 		go func() {
+			log.Printf("DEBUG: Loading existing files from database into metadataStore")
+			if err := gateway.LoadExistingFilesToMetadataStore(); err != nil {
+				log.Printf("Warning: Failed to load existing files: %v", err)
+			}
+			
 			log.Printf("DEBUG: Refreshing streaming info for existing files in metadataStore")
 			if err := gateway.RefreshAllMetadataStreamingInfo(); err != nil {
 				log.Printf("Warning: Failed to refresh metadata streaming info: %v", err)

internal/storage/backend.go

@@ -725,6 +725,43 @@ func (b *Backend) GetUserFiles(pubkey string) ([]*FileMetadata, error) {
 	return files, nil
 }
 
+// GetPublicFiles returns all public files in the system
+func (b *Backend) GetPublicFiles() ([]*FileMetadata, error) {
+	rows, err := b.db.Query(`
+		SELECT hash, original_name, size, chunk_count, content_type, 
+		       COALESCE(storage_type, 'torrent'), COALESCE(owner_pubkey, ''), 
+		       COALESCE(access_level, 'public'), created_at, access_count, last_access
+		FROM files 
+		WHERE access_level = 'public'
+		ORDER BY created_at DESC
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query public files: %w", err)
+	}
+	defer rows.Close()
+
+	var files []*FileMetadata
+	for rows.Next() {
+		var metadata FileMetadata
+		err := rows.Scan(
+			&metadata.Hash, &metadata.OriginalName, &metadata.Size,
+			&metadata.ChunkCount, &metadata.ContentType, &metadata.StorageType,
+			&metadata.OwnerPubkey, &metadata.AccessLevel, &metadata.CreatedAt,
+			&metadata.AccessCount, &metadata.LastAccess,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan file metadata: %w", err)
+		}
+		files = append(files, &metadata)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating over public files: %w", err)
+	}
+
+	return files, nil
+}
+
 // GetUserStats calculates storage statistics for a user
 func (b *Backend) GetUserStats(pubkey string) (int64, int, error) {
 	var storageUsed int64