import { DateTime } from 'luxon';

 * Format timestamps for a given timezone
 * The localDate represents the time as parsed from the filename

 * Format timestamps for a given timezone using Luxon
 * For non-AudioMoth files: uses fixed offset based on first file's date/time
 * Audio recorders don't adjust for DST - they use deployment-time offset throughout

function formatTimestampsForTimezone(localDate: Date, timeZone: string): { local: string, utc: string } {

function formatTimestampsWithFixedOffset(
  localDate: Date, 
  timeZone: string, 
  fixedOffsetMinutes?: number
): { local: string, utc: string, offsetMinutes?: number } {

  // For non-UTC timezones, this is a simplified implementation
  // In practice, you'd need a proper timezone library like date-fns-tz or Luxon
  // For now, we'll assume a fixed offset (this matches your Julia approach of using consistent offset)

    // Use browser's current timezone offset as a placeholder
    // In real implementation, you'd calculate the actual offset for the target timezone
    const offsetMinutes = new Date().getTimezoneOffset();

    let offsetMinutes: number;
    
    if (fixedOffsetMinutes !== undefined) {
      // Use the provided fixed offset (for all files after the first)
      offsetMinutes = fixedOffsetMinutes;
    } else {
      // Calculate offset for this specific date/time (for the first file)
      const luxonDateTime = DateTime.fromObject({
        year,
        month,
        day,
        hour,
        minute,
        second
      }, { zone: timeZone });
      
      if (!luxonDateTime.isValid) {
        throw new Error(`Invalid timezone or date: ${timeZone}, ${luxonDateTime.invalidExplanation}`);
      }
      
      // Get the offset in minutes for this specific date/time
      offsetMinutes = luxonDateTime.offset;
    }
    
    // Format the offset for ISO string

    const offsetSign = offsetMinutes <= 0 ? '+' : '-';

    const offsetSign = offsetMinutes >= 0 ? '+' : '-';

    // Create local ISO string with the timezone offset

    // Convert to UTC by applying the offset
    const utcDate = new Date(localDate.getTime() - (offsetMinutes * 60 * 1000));
    const utcISO = utcDate.toISOString();

    // Convert to UTC by subtracting the offset
    const utcTime = new Date(localDate.getTime() - (offsetMinutes * 60 * 1000));
    const utcISO = utcTime.toISOString();

      utc: utcISO

      utc: utcISO,
      offsetMinutes // Return the offset so it can be reused for other files

 * Audio recorders don't adjust for DST - they use the deployment-time offset

  // For consistency across cluster, use the same offset calculation method for all files
  // In practice, recorders don't account for daylight saving, so we use a fixed offset

  // Sort files by timestamp to find the first (earliest) file
  const fileIndices = Array.from({ length: filenames.length }, (_, i) => i);
  fileIndices.sort((a, b) => localDateTimes[a].getTime() - localDateTimes[b].getTime());
  // Calculate timezone offset using the FIRST (earliest) file
  // This simulates the recorder being deployed at a specific time with a fixed offset
  const firstFileIndex = fileIndices[0];
  const firstFileDateTime = localDateTimes[firstFileIndex];
  
  console.log(`Using first file (${filenames[firstFileIndex]}) to determine fixed timezone offset for ${clusterTimezoneId}`);
  
  const firstFileTimestamps = formatTimestampsWithFixedOffset(firstFileDateTime, clusterTimezoneId);
  const fixedOffsetMinutes = firstFileTimestamps.offsetMinutes;
  
  if (fixedOffsetMinutes !== undefined) {
    console.log(`Fixed offset for entire cluster: ${fixedOffsetMinutes >= 0 ? '+' : ''}${fixedOffsetMinutes / 60} hours`);
  }
  // Apply the same fixed offset to ALL files in the cluster

    // Format timestamps for the given timezone
    const timestamps = formatTimestampsForTimezone(localDateTime, clusterTimezoneId);

    // Use the fixed offset from the first file for all files
    const timestamps = formatTimestampsWithFixedOffset(localDateTime, clusterTimezoneId, fixedOffsetMinutes);

  console.log(`Successfully parsed ${results.length} filenames`);

  console.log(`Successfully parsed ${results.length} filenames using fixed offset`);

/**
 * Tests for Luxon integration in filename parsing
 * Tests timezone handling with fixed offset strategy
 */
import { describe, it, expect } from 'vitest';
import { parseClusterFilenames } from '@/utils/filenameParser';
describe('Filename Parser Luxon Integration', () => {
  describe('parseClusterFilenames with timezone handling', () => {
    it('should handle UTC timezone correctly', () => {
      const filenames = ["201012_123456.wav", "201014_123456.WAV"];
      const result = parseClusterFilenames(filenames, "UTC");
      
      expect(result).toHaveLength(2);
      expect(result[0].fileName).toBe("201012_123456.wav");
      expect(result[0].timestamp.timestampLocal).toMatch(/^2020-10-12T12:34:56\.000\+00:00$/);
      expect(result[0].timestamp.timestampUTC).toMatch(/^2020-10-12T12:34:56\.000Z$/);
    });
    it('should use fixed offset for entire cluster', () => {
      // Test files that span a DST transition period
      // In Auckland, DST typically ends in early April (UTC+13 -> UTC+12)
      const filenames = [
        "200315_120000.wav", // March 15th (summer time, UTC+13)
        "200415_120000.wav"  // April 15th (would be winter time, UTC+12 if DST applied)
      ];
      
      const result = parseClusterFilenames(filenames, "Pacific/Auckland");
      
      expect(result).toHaveLength(2);
      
      // Both files should use the same offset (from the first file)
      const firstOffset = extractOffsetFromTimestamp(result[0].timestamp.timestampLocal);
      const secondOffset = extractOffsetFromTimestamp(result[1].timestamp.timestampLocal);
      
      expect(firstOffset).toBe(secondOffset);
      
      // The offset should be UTC+13 (summer time from March 15th)
      expect(firstOffset).toBe("+13:00");
    });
    it('should calculate correct offset for different timezones', () => {
      const filenames = ["20240615_120000.wav"]; // June 15th, 2024
      
      // Test Auckland (should be UTC+12 in winter)
      const aucklandResult = parseClusterFilenames(filenames, "Pacific/Auckland");
      const aucklandOffset = extractOffsetFromTimestamp(aucklandResult[0].timestamp.timestampLocal);
      expect(aucklandOffset).toBe("+12:00");
      
      // Test New York (should be UTC-4 in summer)
      const nyResult = parseClusterFilenames(filenames, "America/New_York");
      const nyOffset = extractOffsetFromTimestamp(nyResult[0].timestamp.timestampLocal);
      expect(nyOffset).toBe("-04:00");
    });
    it('should handle invalid timezone gracefully', () => {
      const filenames = ["20240615_120000.wav"]; // Use 8-digit format to avoid needing multiple files
      
      // Should fallback to UTC format on invalid timezone
      expect(() => {
        parseClusterFilenames(filenames, "Invalid/Timezone");
      }).not.toThrow();
    });
    it('should sort files chronologically to find first file', () => {
      // Files not in chronological order
      const filenames = [
        "200315_120000.wav", // Later file  
        "200101_120000.wav", // Earlier file (should be used for offset)
        "200215_120000.wav"  // Middle file
      ];
      
      const result = parseClusterFilenames(filenames, "Pacific/Auckland");
      
      expect(result).toHaveLength(3);
      
      // All files should use the same offset (based on earliest file: Jan 1st)
      const offsets = result.map(r => extractOffsetFromTimestamp(r.timestamp.timestampLocal));
      const uniqueOffsets = new Set(offsets);
      expect(uniqueOffsets.size).toBe(1); // All files should have same offset
      
      // The offset should be based on January 1st (UTC+13 in Auckland summer)
      expect(offsets[0]).toBe("+13:00");
    });
    it('should maintain original filename order in results', () => {
      const filenames = [
        "200315_120000.wav",
        "200101_120000.wav", 
        "200215_120000.wav"
      ];
      
      const result = parseClusterFilenames(filenames, "UTC");
      
      // Results should maintain original order
      expect(result[0].fileName).toBe("200315_120000.wav");
      expect(result[1].fileName).toBe("200101_120000.wav");
      expect(result[2].fileName).toBe("200215_120000.wav");
    });
  });
});
/**
 * Helper function to extract timezone offset from ISO timestamp
 */
function extractOffsetFromTimestamp(timestamp: string): string {
  const match = timestamp.match(/([+-]\d{2}:\d{2})$/);
  return match ? match[1] : '';
}

[ ] Check render of opus spectrogram