managarten/memoro/apps/mobile/utils/mediaUtils.ts

import { Platform } from 'react-native';
import { createAudioPlayer, setAudioModeAsync } from 'expo-audio';
import * as DocumentPicker from 'expo-document-picker';

export interface DurationExtractionResult {
  durationMillis: number;
  durationSeconds: number;
  formatted: string;
}

/**
 * Extracts duration from a media file (audio or video)
 * @param file - The file from DocumentPicker
 * @returns Duration in milliseconds
 * @throws Error if duration cannot be extracted
 */
export const extractMediaDuration = async (
  file: DocumentPicker.DocumentPickerAsset
): Promise<number> => {
  if (Platform.OS === 'web') {
    return extractDurationWeb(file);
  }
  return extractDurationNative(file.uri, file.mimeType);
};

/**
 * Extracts duration with formatted output
 * @param file - The file from DocumentPicker
 * @returns Duration with milliseconds, seconds, and formatted string
 * @throws Error if duration cannot be extracted
 */
export const extractMediaDurationWithFormat = async (
  file: DocumentPicker.DocumentPickerAsset
): Promise<DurationExtractionResult> => {
  const durationMillis = await extractMediaDuration(file);
  const durationSeconds = Math.floor(durationMillis / 1000);
  const formatted = formatDuration(durationMillis);

  return {
    durationMillis,
    durationSeconds,
    formatted
  };
};

/**
 * Web implementation using HTML5 Audio/Video elements
 */
const extractDurationWeb = (file: any): Promise<number> => {
  return new Promise((resolve, reject) => {
    const isVideo = file.type?.startsWith('video/') ||
                   file.mimeType?.startsWith('video/');
    const element = document.createElement(isVideo ? 'video' : 'audio');

    element.preload = 'metadata';

    const cleanup = () => {
      if (element.src && element.src.startsWith('blob:')) {
        URL.revokeObjectURL(element.src);
      }
      element.src = '';
      element.remove();
    };

    element.onloadedmetadata = () => {
      if (element.duration && !isNaN(element.duration) && element.duration > 0) {
        const durationMillis = Math.floor(element.duration * 1000);
        cleanup();
        resolve(durationMillis);
      } else {
        cleanup();
        reject(new Error('Invalid or zero duration extracted from media file'));
      }
    };

    element.onerror = (error) => {
      cleanup();
      reject(new Error(`Failed to load media file: ${error}`));
    };

    // Create blob URL for the file
    try {
      const blob = file.file || file;
      element.src = URL.createObjectURL(blob);
    } catch (error) {
      cleanup();
      reject(new Error(`Failed to create blob URL: ${error}`));
    }
  });
};

/**
 * Native implementation using expo-audio
 */
const extractDurationNative = async (
  uri: string,
  mimeType?: string | null
): Promise<number> => {
  let player = null;

  try {
    // Configure audio mode for metadata extraction only
    await setAudioModeAsync({
      allowsRecording: false,
      playsInSilentMode: false,
      shouldPlayInBackground: false,
      interruptionMode: 'mixWithOthers',
    });

    // Create audio player
    player = createAudioPlayer(uri);

    // Wait a bit for the player to load metadata
    // expo-audio loads metadata asynchronously
    await new Promise(resolve => setTimeout(resolve, 100));

    // Get duration (in seconds from expo-audio)
    const durationSeconds = player.duration;

    if (durationSeconds && durationSeconds > 0) {
      return Math.floor(durationSeconds * 1000); // Convert to milliseconds
    }

    throw new Error('Could not extract duration from media file');
  } catch (error) {
    console.error('Duration extraction failed:', error);
    throw new Error(`Failed to extract duration: ${error instanceof Error ? error.message : 'Unknown error'}`);
  } finally {
    // Critical: Always clean up the player
    if (player) {
      try {
        player.release();
      } catch (cleanupError) {
        console.warn('Failed to release audio player:', cleanupError);
      }
    }
  }
};

/**
 * Formats duration from milliseconds to human-readable string
 * @param milliseconds - Duration in milliseconds
 * @returns Formatted string like "2:34" or "1:02:34"
 */
export const formatDuration = (milliseconds: number): string => {
  const totalSeconds = Math.floor(milliseconds / 1000);
  const hours = Math.floor(totalSeconds / 3600);
  const minutes = Math.floor((totalSeconds % 3600) / 60);
  const seconds = totalSeconds % 60;

  if (hours > 0) {
    return `${hours}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
  }
  return `${minutes}:${seconds.toString().padStart(2, '0')}`;
};

/**
 * Validates if a file is a supported media type
 * @param file - The file from DocumentPicker
 * @returns true if the file is a supported audio or video format
 */
export const isSupportedMediaFile = (file: DocumentPicker.DocumentPickerAsset): boolean => {
  const mimeType = file.mimeType?.toLowerCase() || '';
  const name = file.name?.toLowerCase() || '';

  const supportedMimeTypes = [
    'audio/mpeg', 'audio/mp3', 'audio/mp4', 'audio/x-m4a', 'audio/m4a',
    'audio/wav', 'audio/x-wav', 'audio/aac', 'audio/ogg',
    'video/mp4', 'video/quicktime', 'video/x-m4v', 'video/mpeg'
  ];

  const supportedExtensions = [
    '.mp3', '.m4a', '.wav', '.aac', '.ogg',
    '.mp4', '.mov', '.m4v', '.mpeg', '.mpg'
  ];

  return supportedMimeTypes.includes(mimeType) ||
         supportedExtensions.some(ext => name.endsWith(ext));
};