filter

  filter,
  location,
  cluster,
  dataset

/**
 * Protected API route to get file context information (dataset, location, cluster)
 * 
 * @route GET /api/files/:fileId/context
 * @authentication Required
 * @param {string} fileId - File ID in URL path
 * @returns {Object} Response containing:
 *   - data: Object with dataset, location, and cluster information
 * @error 400 - If fileId is invalid
 * @error 404 - If file not found
 * @error 500 - If database operation fails
 * @description Returns context information for breadcrumb display
 */
files.get("/:fileId/context", authenticate, async (c) => {
  try {
    const fileId = c.req.param("fileId");
    
    // Validate file ID format
    if (!isValidFileId(fileId)) {
      return c.json({
        error: "Invalid file ID format"
      }, 400);
    }
    
    // Connect to database
    const db = createDatabase(c.env);
    
    // Query file with location, cluster, and dataset information
    const result = await db
      .select({
        fileId: file.id,
        fileName: file.fileName,
        datasetId: dataset.id,
        datasetName: dataset.name,
        locationId: location.id,
        locationName: location.name,
        clusterId: cluster.id,
        clusterName: cluster.name,
      })
      .from(file)
      .leftJoin(location, eq(file.locationId, location.id))
      .leftJoin(cluster, eq(file.clusterId, cluster.id))
      .leftJoin(dataset, eq(location.datasetId, dataset.id))
      .where(
        sqlExpr`${file.id} = ${fileId} AND ${file.active} = true`
      )
      .limit(1);
    
    if (result.length === 0) {
      return c.json({
        error: "File not found"
      }, 404);
    }
    
    const fileContext = result[0];
    
    return c.json({
      data: {
        dataset: {
          id: fileContext.datasetId,
          name: fileContext.datasetName
        },
        location: {
          id: fileContext.locationId,
          name: fileContext.locationName
        },
        cluster: {
          id: fileContext.clusterId,
          name: fileContext.clusterName
        }
      }
    });
    
  } catch (error) {
    console.error("Error fetching file context:", error);
    return c.json({
      error: "Failed to fetch file context",
      details: error instanceof Error ? error.message : String(error),
    }, 500);
  }
});

        {...(datasetName && { datasetName })}

  // Context information for display
  datasetName?: string;
  locationName?: string;
  clusterName?: string;

  // File context data
  fileContext: {
    dataset?: { id: string; name: string };
    location?: { id: string; name: string };
    cluster?: { id: string; name: string };
  } | null;
  fileContextLoading: boolean;
  

  datasetOwnerId,
  datasetName,
  locationName,
  clusterName

  datasetOwnerId

    fileContext: null,
    fileContextLoading: false,

  // Fetch file context data
  const fetchFileContext = useCallback(async (fileId: string) => {
    setState(prev => ({ ...prev, fileContextLoading: true }));
    try {
      const accessToken = await getAccessToken();
      
      const response = await fetch(`/api/files/${fileId}/context`, {
        headers: {
          'Authorization': `Bearer ${accessToken}`,
        },
      });
      
      if (!response.ok) {
        throw new Error(`Failed to fetch file context: ${response.status}`);
      }
      
      const data = await response.json();
      setState(prev => ({ 
        ...prev, 
        fileContext: data.data,
        fileContextLoading: false 
      }));
    } catch (error) {
      console.error('Error fetching file context:', error);
      setState(prev => ({ 
        ...prev, 
        fileContextLoading: false 
      }));
    }
  }, [getAccessToken]);

      // Always fetch selections if we have a file

      // Always fetch selections and context if we have a file

      fetchFileContext(file.id);

  }, [state.wavesurfer, file, loadOnlineFile, fetchSelections]);

  }, [state.wavesurfer, file, loadOnlineFile, fetchSelections, fetchFileContext]);

                {datasetName && `Dataset: ${datasetName}`}
                {datasetName && locationName && ' • '}
                {locationName && `Location: ${locationName}`}
                {(datasetName || locationName) && clusterName && ' • '}
                {clusterName && `Cluster: ${clusterName}`}
                {!datasetName && !locationName && !clusterName && 'Audio File'}

                {state.fileContext ? (
                  <>
                    {state.fileContext.dataset && `Dataset: ${state.fileContext.dataset.name}`}
                    {state.fileContext.dataset && state.fileContext.location && ' • '}
                    {state.fileContext.location && `Location: ${state.fileContext.location.name}`}
                    {(state.fileContext.dataset || state.fileContext.location) && state.fileContext.cluster && ' • '}
                    {state.fileContext.cluster && `Cluster: ${state.fileContext.cluster.name}`}
                  </>
                ) : state.fileContextLoading ? (
                  'Loading context...'
                ) : (
                  'Audio File'
                )}

  // For file modal context
  datasetName?: string;
  locationName?: string;

  nightFilter: externalNightFilter,
  datasetName,
  locationName

  nightFilter: externalNightFilter

        {...(datasetName && { datasetName })}
        {...(locationName && { locationName })}
        clusterName={clusterName}

                datasetName={selectedDatasetName}
                locationName={selectedLocationName}