managarten/apps-archived/memoro/apps/mobile/features/storage/transcriptionUtils.ts

import { Alert } from 'react-native';
import { analyzeNetworkErrorSync } from '../errorHandling/utils/networkErrorUtils';

/**
 * Utility functions for audio transcription
 * Routes all requests through memoro-service for intelligent backend routing
 */

const MEMORO_SERVICE_URL =
	process.env.EXPO_PUBLIC_MEMORO_MIDDLEWARE_URL?.replace(/\/$/, '') ||
	'https://memoro-service-111768794939.europe-west3.run.app';

/**
 * Transcribes via Memoro Service (which handles intelligent routing)
 */
const transcribeViaMemoryService = async (
	audioPath: string,
	appToken: string,
	duration: number,
	memoId?: string,
	spaceId?: string,
	recordingLanguages?: string[],
	title?: string,
	blueprintId?: string
): Promise<Response> => {
	console.debug('🎯 Using Memoro Service for intelligent transcription routing');

	return fetch(`${MEMORO_SERVICE_URL}/memoro/process-uploaded-audio`, {
		method: 'POST',
		headers: {
			'Content-Type': 'application/json',
			Authorization: `Bearer ${appToken}`,
		},
		body: JSON.stringify({
			filePath: audioPath,
			duration,
			memoId,
			spaceId,
			recordingLanguages,
			title,
			blueprintId,
		}),
	});
};

/**
 * Enhanced transcription result with network error information
 */
export interface TranscriptionRequestResult {
	success: boolean;
	error?: string;
	isNetworkError?: boolean;
	userMessage?: string;
	technicalMessage?: string;
}

/**
 * Triggers transcription via memoro-service (which handles intelligent routing)
 */
export const triggerTranscription = async ({
	userId,
	fileName,
	duration,
	memoId,
	spaceId,
	recordingLanguages,
	title,
	blueprintId,
	showAlerts = true,
	t = (key: string, fallback: string) => fallback,
}: {
	userId: string;
	fileName: string;
	duration: number;
	memoId?: string;
	spaceId?: string;
	recordingLanguages?: string[];
	title?: string;
	blueprintId?: string;
	showAlerts?: boolean;
	t?: (key: string, fallback: string) => string;
}): Promise<TranscriptionRequestResult> => {
	try {
		// Get the app token for authenticated requests
		const { tokenManager } = await import('~/features/auth/services/tokenManager');
		const appToken = await tokenManager.getValidToken();
		if (!appToken) {
			const errorMsg = t('audio_archive.no_auth_token', 'Kein authentifizierter Token gefunden');
			if (showAlerts) {
				Alert.alert(t('common.error', 'Fehler'), errorMsg);
			}
			return { success: false, error: errorMsg };
		}

		const audioPath = `${userId}/${fileName}`;

		console.debug('🎯 Triggering transcription with:', {
			audioPath,
			duration,
			memoId,
			spaceId,
			title,
			blueprintId,
			recordingLanguages,
		});

		// Let memoro-service handle the intelligent routing
		const transcribeResponse = await transcribeViaMemoryService(
			audioPath,
			appToken,
			duration,
			memoId,
			spaceId,
			recordingLanguages,
			title,
			blueprintId
		);

		// Handle response
		if (!transcribeResponse.ok) {
			const errorText = await transcribeResponse.text();
			console.debug('Fehler beim Aufruf der Transcription via Memoro Service:', {
				status: transcribeResponse.status,
				statusText: transcribeResponse.statusText,
				errorText,
			});

			// Create an error object with status for network analysis
			const transcriptionError = new Error(`Transcription failed: ${errorText}`);
			(transcriptionError as any).status = transcribeResponse.status;

			// Analyze if this is a network-related error
			const networkErrorInfo = analyzeNetworkErrorSync(transcriptionError);

			if (networkErrorInfo.isNetworkError) {
				// For network errors, return the user-friendly message but don't show alert here
				// Let the calling code decide how to display it (toast vs alert)
				return {
					success: false,
					error: errorText,
					isNetworkError: true,
					userMessage: networkErrorInfo.userMessage,
					technicalMessage: networkErrorInfo.technicalMessage,
				};
			} else {
				const errorMsg = t(
					'audio_archive.transcription_start_error',
					'Die Transkription konnte nicht gestartet werden.'
				);
				if (showAlerts) {
					Alert.alert(t('common.error', 'Fehler'), errorMsg);
				}
				return {
					success: false,
					error: errorMsg,
					isNetworkError: false,
					userMessage: errorMsg,
					technicalMessage: errorText,
				};
			}
		}

		console.debug('✅ Transcription started successfully via Memoro Service');
		return { success: true };
	} catch (error) {
		console.debug('Error triggering transcription:', error);

		// Analyze if this is a network-related error
		const networkErrorInfo = analyzeNetworkErrorSync(error);

		if (networkErrorInfo.isNetworkError) {
			return {
				success: false,
				error: String(error),
				isNetworkError: true,
				userMessage: networkErrorInfo.userMessage,
				technicalMessage: networkErrorInfo.technicalMessage,
			};
		} else {
			const errorMsg = t(
				'audio_archive.transcription_error',
				'Beim Starten der Transkription ist ein Fehler aufgetreten.'
			);
			if (showAlerts) {
				Alert.alert(t('common.error', 'Fehler'), errorMsg);
			}
			return {
				success: false,
				error: errorMsg,
				isNetworkError: false,
				userMessage: errorMsg,
				technicalMessage: String(error),
			};
		}
	}
};