import { nanoid } from "nanoid";

    // Create admin access grants for the dataset creator
    // Grant all permissions (READ, UPLOAD, DOWNLOAD, EDIT, DELETE) to the creator
    const permissions = ['READ', 'UPLOAD', 'DOWNLOAD', 'EDIT', 'DELETE'] as const;
    const accessGrants = permissions.map(permission => ({
      id: nanoid(12),
      datasetId: result[0].id,
      role: 'ADMIN' as const,
      permission,
      userId: userId,
      createdBy: userId,
      createdAt: now,
      lastModified: now,
      modifiedBy: userId,
      active: true,
    }));
    await db.insert(accessGrant).values(accessGrants);

 */
/**
 * Protected API route to get cluster location coordinates
 * 
 * @route GET /api/clusters/:id/location
 * @authentication Required
 * @param {string} id - Cluster ID in URL path
 * @returns {Object} Response containing:
 *   - data: { latitude: number, longitude: number }
 * @description Gets the location coordinates for a cluster. Requires READ permission on the dataset.

clusters.get("/:id/location", authenticate, async (c) => {
  try {
    const jwtPayload = (c as unknown as { jwtPayload: JWTPayload }).jwtPayload;
    const userId = jwtPayload.sub;
    const clusterId = c.req.param("id");
    
    const db = createDatabase(c.env);
    // Get cluster and its location coordinates
    const clusterWithLocation = await db
      .select({
        datasetId: cluster.datasetId,
        latitude: location.latitude,
        longitude: location.longitude
      })
      .from(cluster)
      .leftJoin(location, eq(cluster.locationId, location.id))
      .where(eq(cluster.id, clusterId))
      .limit(1);
    if (clusterWithLocation.length === 0) {
      return c.json({
        error: "Cluster not found"
      }, 404);
    }
    const clusterData = clusterWithLocation[0];
    // Check if user has READ permission on the dataset
    const hasPermission = await checkUserPermission(db, userId, clusterData.datasetId, 'READ');
    if (!hasPermission) {
      return c.json({
        error: "You don't have permission to access this cluster"
      }, 403);
    }
    // Validate that location coordinates are available
    if (clusterData.latitude === null || clusterData.longitude === null) {
      return c.json({
        error: "Location coordinates not available for this cluster"
      }, 404);
    }
    return c.json({
      data: {
        latitude: parseFloat(clusterData.latitude),
        longitude: parseFloat(clusterData.longitude)
      }
    });
  } catch (error) {
    return c.json(standardErrorResponse(error, "fetching cluster location"), 500);
  }
});

import { calculateAstronomicalData } from './astronomicalCalculations';

  precomputedTimestamp?: ParsedTimestamp

  precomputedTimestamp?: ParsedTimestamp,
  folderPath?: string,
  clusterLocation?: { latitude: number; longitude: number }

    path: folderPath || null,

  };
  // Determine timestamp for astronomical calculations
  let timestampUTC: string;
  let timestampLocal: string;
  if (metadata.isAudioMoth && metadata.audioMothData) {
    timestampUTC = metadata.audioMothData.timestampUTC;
    timestampLocal = metadata.audioMothData.timestampLocal;
  } else if (precomputedTimestamp) {
    timestampUTC = precomputedTimestamp.timestampUTC;
    timestampLocal = precomputedTimestamp.timestampLocal;
  } else {
    // Fallback to current time if no timestamp available
    console.warn(`No timestamp data available for file: ${file.name}`);
    const now = new Date();
    timestampUTC = now.toISOString();
    timestampLocal = now.toISOString();
  }
  // Calculate astronomical data if cluster location is available
  let astronomicalData = null;
  if (clusterLocation && basicInfo.duration) {
    try {
      astronomicalData = calculateAstronomicalData(
        timestampUTC,
        basicInfo.duration,
        clusterLocation
      );
    } catch (error) {
      console.error('Error calculating astronomical data:', error);
    }
  }
  const completeFileData = {
    ...baseFileData,
    timestampLocal,
    maybeSolarNight: astronomicalData?.maybeSolarNight || null,
    maybeCivilNight: astronomicalData?.maybeCivilNight || null,
    moonPhase: astronomicalData?.moonPhase || null,

      ...baseFileData,
      timestampLocal: metadata.audioMothData.timestampLocal,

      ...completeFileData,

    // For non-AudioMoth files, use precomputed timestamp from filename parsing
    if (precomputedTimestamp) {
      return {
        ...baseFileData,
        timestampLocal: precomputedTimestamp.timestampLocal,
        // No moth metadata for non-AudioMoth files
      };
    } else {
      // Fallback to current time if no precomputed timestamp available
      console.warn(`No timestamp data available for non-AudioMoth file: ${file.name}`);
      return {
        ...baseFileData,
        timestampLocal: new Date().toISOString(),
        // No moth metadata for non-AudioMoth files
      };
    }

    return completeFileData;

  const [refreshTrigger, setRefreshTrigger] = useState<number>(0);

    // Trigger a refresh of the file list by resetting the current page

    // Trigger a refresh of the file list by resetting the current page and incrementing refresh trigger

    setRefreshTrigger(prev => prev + 1);

    refreshTrigger,

import { type ClusterLocation } from "../utils/astronomicalCalculations";

  const [clusterLocation, setClusterLocation] = useState<ClusterLocation | null>(null);

  // Fetch cluster data to get timezone

  // Fetch cluster data to get timezone and location coordinates

        const response = await fetch(`/api/clusters?locationId=${encodeURIComponent(locationId)}`, {

        
        // Fetch cluster timezone
        const clustersResponse = await fetch(`/api/clusters?locationId=${encodeURIComponent(locationId)}`, {

        if (response.ok) {
          const result = await response.json();

        if (clustersResponse.ok) {
          const result = await clustersResponse.json();

        // Fetch cluster location coordinates
        const locationResponse = await fetch(`/api/clusters/${encodeURIComponent(clusterId)}/location`, {
          headers: {
            Authorization: `Bearer ${accessToken}`,
          },
        });
        if (locationResponse.ok) {
          const locationResult = await locationResponse.json();
          setClusterLocation(locationResult.data);
          console.log(`Cluster location: lat=${locationResult.data.latitude}, lng=${locationResult.data.longitude}`);
        } else {
          console.error('Failed to fetch cluster location coordinates');
          setClusterLocation(null);
        }

        setClusterLocation(null);

    setClusterTimezone(null);
    setClusterLocation(null);

            const fileImportData = await createFileImportData(file, locationId, clusterId);

            const fileImportData = await createFileImportData(file, locationId, clusterId, undefined, folderPath, clusterLocation || undefined);

            const fileImportData = await createFileImportData(file, locationId, clusterId, precomputedTimestamp);

            const fileImportData = await createFileImportData(file, locationId, clusterId, precomputedTimestamp, folderPath, clusterLocation || undefined);

  }, [selectedFolder, folderPath, scanAudioFiles, onImportComplete, handleClose, clusterId, datasetId, locationId, clusterTimezone, isAuthenticated, getAccessToken]);

  }, [selectedFolder, folderPath, scanAudioFiles, onImportComplete, handleClose, clusterId, datasetId, locationId, clusterTimezone, clusterLocation, isAuthenticated, getAccessToken]);

    "@types/suncalc": "^1.9.2",

    "suncalc": "^1.9.0",

        "@types/suncalc": "^1.9.2",

        "suncalc": "^1.9.0",

    "node_modules/@types/suncalc": {
      "version": "1.9.2",
      "resolved": "https://registry.npmjs.org/@types/suncalc/-/suncalc-1.9.2.tgz",
      "integrity": "sha512-ATAGBHHfA1TlE2tjfidLyTcysjoT2JHHEAmWRULh73SU9UTn++j5fqHEW16X6Y/2Li87jEQXzgu4R/OOdlDqzw==",
      "license": "MIT"
    },

    },
    "node_modules/suncalc": {
      "version": "1.9.0",
      "resolved": "https://registry.npmjs.org/suncalc/-/suncalc-1.9.0.tgz",
      "integrity": "sha512-vMJ8Byp1uIPoj+wb9c1AdK4jpkSKVAywgHX0lqY7zt6+EWRRC3Z+0Ucfjy/0yxTVO1hwwchZe4uoFNqrIC24+A=="

[ ] Opus support

[X] Opus support
[ ] Check safari supports .opus, handle error if not