managarten/apps-archived/memoro/apps/mobile/features/memos/utils/transcriptUtils.ts

/**
 * Utility functions for handling transcript generation from utterances
 */

/**
 * Generate a plain text transcript from utterances array
 * @param utterances - Array of utterance objects with text property
 * @returns Plain text transcript string
 */
export function generateTranscriptFromUtterances(
	utterances?: Array<{
		text: string;
		speakerId?: string;
		offset?: number;
		duration?: number;
	}> | null
): string {
	if (!utterances || utterances.length === 0) {
		return '';
	}

	// Sort utterances by offset if available
	const sortedUtterances = [...utterances].sort((a, b) => {
		const offsetA = a.offset || 0;
		const offsetB = b.offset || 0;
		return offsetA - offsetB;
	});

	// Concatenate all utterance texts with spaces
	return sortedUtterances
		.map((utterance) => utterance.text)
		.filter((text) => text && text.trim() !== '')
		.join(' ');
}

/**
 * Check if transcript data exists (either in utterances or legacy transcript fields)
 * @param memo - The memo object to check
 * @returns Boolean indicating if transcript exists
 */
export function hasTranscript(memo: any): boolean {
	// Check utterances first (new structure)
	if (memo?.source?.utterances && memo.source.utterances.length > 0) {
		return true;
	}

	// Check legacy fields for backward compatibility
	return !!(
		memo?.transcript ||
		memo?.source?.transcript ||
		memo?.source?.content ||
		memo?.source?.transcription ||
		memo?.metadata?.transcript
	);
}

/**
 * Get transcript text from memo (generates from utterances or returns legacy transcript)
 * @param memo - The memo object
 * @returns The transcript text
 */
export function getTranscriptText(memo: any): string {
	// If utterances exist, generate transcript from them
	if (memo?.source?.utterances && memo.source.utterances.length > 0) {
		return generateTranscriptFromUtterances(memo.source.utterances);
	}

	// Fall back to legacy transcript fields
	return (
		memo?.transcript ||
		memo?.source?.transcript ||
		memo?.source?.content ||
		memo?.source?.transcription ||
		memo?.metadata?.transcript ||
		''
	);
}

/**
 * Get utterances from various possible locations in memo
 * @param memo - The memo object
 * @returns Array of utterances or null
 */
export function getUtterances(
	memo: any
): Array<{ text: string; speakerId?: string; offset?: number; duration?: number }> | null {
	// Check primary location
	if (memo?.source?.utterances && Array.isArray(memo.source.utterances)) {
		return memo.source.utterances;
	}

	// Check metadata location (for backward compatibility)
	if (memo?.metadata?.utterances && Array.isArray(memo.metadata.utterances)) {
		return memo.metadata.utterances;
	}

	// If only transcript exists, create a single utterance
	const transcriptText =
		memo?.transcript ||
		memo?.source?.transcript ||
		memo?.source?.content ||
		memo?.source?.transcription ||
		memo?.metadata?.transcript;

	if (transcriptText) {
		return [
			{
				text: transcriptText,
				speakerId: 'default',
				offset: 0,
				duration: 0,
			},
		];
	}

	return null;
}

/**
 * Check if a memo is a combined memo
 * @param memo - The memo object
 * @returns Boolean indicating if it's a combined memo
 */
export function isCombinedMemo(memo: any): boolean {
	return memo?.source?.type === 'combined';
}

/**
 * Get combined memo recordings with their transcripts
 * @param memo - The memo object
 * @returns Array of recordings with transcript data or empty array
 */
export function getCombinedMemoRecordings(memo: any): Array<{
	title: string;
	transcript: string;
	utterances: Array<{ text: string; speakerId: string; offset: number; duration: number }>;
	speakers: Record<string, string>;
	timestamp: string;
	index: number;
}> {
	if (!isCombinedMemo(memo) || !memo?.source?.additional_recordings) {
		return [];
	}

	return memo.source.additional_recordings.map((recording: any, index: number) => {
		const memoMetadata = recording.memo_metadata || {};

		return {
			title: memoMetadata.original_title || memoMetadata.display_title || `Recording ${index + 1}`,
			transcript: recording.transcript || '',
			utterances: recording.utterances || [],
			speakers: recording.speakers || {},
			timestamp: recording.timestamp || memoMetadata.original_created_at || '',
			index: memoMetadata.combine_index ?? index,
		};
	});
}

/**
 * Calculate total audio duration for combined memos
 * @param memo - The memo object
 * @returns Total duration in seconds or 0
 */
export function getCombinedMemoDuration(memo: any): number {
	if (!isCombinedMemo(memo) || !memo?.source?.additional_recordings) {
		return 0;
	}

	let totalDuration = 0;

	memo.source.additional_recordings.forEach((recording: any) => {
		if (recording.duration) {
			totalDuration += recording.duration;
		}
	});

	return totalDuration;
}