managarten/apps-archived/memoro/apps/mobile/features/memos/hooks/useMemoState.ts

import { useState, useEffect, useCallback, useRef } from 'react';
import { Alert } from 'react-native';
import { useTranslation } from 'react-i18next';
import { getAuthenticatedClient } from '~/features/auth/lib/supabaseClient';
import { tokenManager } from '~/features/auth/services/tokenManager';
import { getTranscriptText, getUtterances } from '~/features/memos/utils/transcriptUtils';

// Debug utility
const debug = __DEV__ ? console.debug : () => {};

// Type definitions
interface MemoType {
	id: string;
	title?: string;
	intro?: string;
	created_at: string;
	transcript?: string; // Full transcription text (moved from source for performance)
	location?: string; // PostGIS POINT format
	source?: {
		type?: string;
		content?: string;
		transcript?: string;
		transcription?: string;
		speakers?: Record<string, Array<{ text: string; offset?: number; duration?: number }>>;
		utterances?: Array<{ text: string; offset?: number; duration?: number; speakerId?: string }>;
		duration?: number;
		duration_seconds?: number;
		audio_path?: string;
		additional_recordings?: Array<{
			path: string;
			type: string;
			timestamp: string;
			status: string;
			transcript?: string;
			speakers?: Record<string, Array<{ text: string; offset?: number; duration?: number }>>;
			utterances?: Array<{ text: string; offset?: number; duration?: number; speakerId?: string }>;
			languages?: string[];
		}>;
	};
	metadata?: {
		transcription?: boolean;
		blueprint_id?: string;
		speakerLabels?: Record<string, string>;
		transcript?: string;
		utterances?: Array<{ text: string; offset?: number; duration?: number; speakerId?: string }>;
		location?: {
			latitude: number;
			longitude: number;
			timestamp: number;
		};
		stats?: {
			viewCount: number;
			wordCount?: number;
			lastViewed?: string;
			audioDuration?: number;
		};
	};
}

interface MemoryType {
	id: string;
	title: string;
	content: string;
	metadata?: Record<string, unknown>;
}

interface LoadingStates {
	memo: boolean;
	question: boolean;
	memories: boolean;
	audio: boolean;
	critical: boolean;
}

interface MemoState {
	// Core memo data
	memo: MemoType | null;
	memories: MemoryType[];
	localMemories: MemoryType[];

	// Memo properties
	isPinned: boolean;
	isEditMode: boolean;
	editTitle: string;
	editIntro: string;
	editTranscript: string;
	editUtterances: Array<{
		text: string;
		offset?: number;
		duration?: number;
		speakerId?: string;
	}> | null;

	// Audio and media
	audioUrl: string | null;

	// Loading states
	loadingStates: LoadingStates;

	// Word replacement
	wordToReplace: string;
	replacementWord: string;
	speakerMappings: Record<string, string>;

	// Summary and processing
	summaryError: string | null;
	isGeneratingSummary: boolean;
}

interface MemoActions {
	// Loading state management
	updateLoadingState: (key: keyof LoadingStates, value: boolean) => void;
	isAnyLoading: boolean;

	// Memo operations
	loadMemoData: (memoId: string) => Promise<void>;
	handleEditStart: () => void;
	handleSaveEdit: (memoId: string) => Promise<void>;
	handleCancelEdit: () => void;
	handlePinToggle: (memoId: string) => Promise<void>;

	// Audio operations
	getSignedUrl: (filePath: string) => Promise<string | null>;

	// Memory operations
	setMemories: React.Dispatch<React.SetStateAction<MemoryType[]>>;
	setLocalMemories: React.Dispatch<React.SetStateAction<any[]>>;

	// Memo operations
	setMemo: React.Dispatch<React.SetStateAction<MemoType | null>>;

	// Edit operations
	setEditTitle: (title: string) => void;
	setEditIntro: (intro: string) => void;
	setEditTranscript: (transcript: string) => void;
	setEditUtterances: (
		utterances: Array<{
			text: string;
			offset?: number;
			duration?: number;
			speakerId?: string;
		}> | null
	) => void;
	updateEditUtterance: (index: number, newText: string) => void;

	// Word replacement
	setWordToReplace: (word: string) => void;
	setReplacementWord: (word: string) => void;
	setSpeakerMappings: React.Dispatch<React.SetStateAction<Record<string, string>>>;

	// Summary operations
	setSummaryError: (error: string | null) => void;
	setIsGeneratingSummary: (generating: boolean) => void;
}

export function useMemoState(): MemoState & MemoActions {
	const { t } = useTranslation();

	// Core memo data
	const [memo, setMemo] = useState<MemoType | null>(null);
	const [memories, setMemories] = useState<MemoryType[]>([]);
	const [localMemories, setLocalMemories] = useState<any[]>([]);
	// Removed unused variable - memoryUpdateTimeouts
	// const memoryUpdateTimeouts = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map());

	// Memo properties
	const [isPinned, setIsPinned] = useState(false);
	const [isEditMode, setIsEditMode] = useState(false);
	const [editTitle, setEditTitle] = useState('');
	const [editIntro, setEditIntro] = useState('');
	const [editTranscript, setEditTranscript] = useState('');
	const [editUtterances, setEditUtterances] = useState<Array<{
		text: string;
		offset?: number;
		duration?: number;
		speakerId?: string;
	}> | null>(null);

	// Refs to capture latest values to prevent race conditions
	const editTranscriptRef = useRef('');
	const editUtterancesRef = useRef<Array<{
		text: string;
		offset?: number;
		duration?: number;
		speakerId?: string;
	}> | null>(null);

	// Audio and media
	const [audioUrl, setAudioUrl] = useState<string | null>(null);

	// Loading states
	const [loadingStates, setLoadingStates] = useState<LoadingStates>({
		memo: true,
		question: false,
		memories: false,
		audio: false,
		critical: false,
	});

	// Word replacement
	const [wordToReplace, setWordToReplace] = useState('');
	const [replacementWord, setReplacementWord] = useState('');
	const [speakerMappings, setSpeakerMappings] = useState<Record<string, string>>({});

	// Summary and processing
	const [summaryError, setSummaryError] = useState<string | null>(null);
	const [isGeneratingSummary, setIsGeneratingSummary] = useState(false);

	// Loading state helper
	const updateLoadingState = useCallback((key: keyof LoadingStates, value: boolean) => {
		setLoadingStates((prev) => ({ ...prev, [key]: value }));
	}, []);

	const isAnyLoading = Object.values(loadingStates).some(Boolean);

	// Sync localMemories with memories when not editing
	useEffect(() => {
		if (!isEditMode) {
			setLocalMemories(memories);
		}
	}, [memories, isEditMode]);

	// Cleanup refs on unmount
	useEffect(() => {
		return () => {
			// Clear refs holding potentially large data
			editTranscriptRef.current = '';
			editUtterancesRef.current = null;
		};
	}, []);

	// Generate signed URL for files
	const getSignedUrl = useCallback(async (filePath: string): Promise<string | null> => {
		try {
			// Use authenticated client to ensure proper RLS policy enforcement
			const supabase = await getAuthenticatedClient();

			const { data, error } = await supabase.storage
				.from('user-uploads')
				.createSignedUrl(filePath, 60 * 60); // 1 hour expiration

			if (error) {
				debug('Error generating signed URL:', error.message);
				return null;
			}

			return data.signedUrl;
		} catch (error) {
			debug('Error in getSignedUrl:', error);
			return null;
		}
	}, []);

	// Load memo data with retry logic
	const loadMemoData = useCallback(
		async (memoId: string, retryCount = 0) => {
			// Validate memoId before proceeding
			if (!memoId || memoId === 'undefined' || memoId === 'null' || memoId.length === 0) {
				console.error('MemoState: Invalid memo ID provided:', memoId);
				updateLoadingState('memo', false);
				Alert.alert(t('common.error', 'Fehler'), t('memo.invalid_id', 'Ungültige Memo-ID.'));
				return;
			}

			try {
				debug(`MemoState: Fetching memo with id: ${memoId}, retry attempt: ${retryCount}`);
				updateLoadingState('memo', true);

				// Wait for valid token before proceeding
				const token = await tokenManager.getValidToken({ maxRetries: 3 });

				if (!token) {
					debug('MemoState: Unable to obtain valid authentication token');
					throw new Error('Authentication failed - unable to obtain valid token');
				}

				debug('MemoState: Valid token obtained, proceeding with memo fetch');
				const supabase = await getAuthenticatedClient();

				// Increment view count
				await supabase.rpc('increment_memo_view_count', {
					memo_id: memoId,
				});

				// Parallelize memo and memories loading
				const [memoResult, memoriesResult] = await Promise.all([
					// Load memo
					supabase.from('memos').select('*').eq('id', memoId).single(),
					// Load memories in parallel
					supabase
						.from('memories')
						.select('id, title, content, metadata')
						.eq('memo_id', memoId)
						.order('sort_order', { ascending: true })
						.order('created_at', { ascending: false }),
				]);

				const { data, error } = memoResult;

				if (error) {
					console.error('MemoState: Error fetching memo:', error.message, error);
					// Log more details about the error
					if (error.code) {
						console.error('MemoState: Error code:', error.code);
					}
					if (error.details) {
						console.error('MemoState: Error details:', error.details);
					}
					if (error.hint) {
						console.error('MemoState: Error hint:', error.hint);
					}

					// Check if this might be an authentication issue
					const tokenState = tokenManager.getTokenState();
					const isAuthRelatedError =
						(error.code === 'PGRST116' &&
							error.details?.includes('0 rows') &&
							tokenState !== 'valid') ||
						error.code === 'PGRST301' || // JWT expired
						error.message?.includes('JWT') ||
						error.message?.includes('token');

					// Retry logic for temporary failures and auth issues
					const isRetryableError =
						isAuthRelatedError ||
						error.code === '57014' || // Query canceled
						error.message?.includes('network') ||
						error.message?.includes('fetch');

					if (retryCount < 2 && isRetryableError) {
						debug(
							`MemoState: Retryable error (auth: ${isAuthRelatedError}), retrying in ${1000 * (retryCount + 1)}ms...`,
							error.code
						);
						updateLoadingState('memo', false); // Reset loading state for retry
						setTimeout(
							() => {
								loadMemoData(memoId, retryCount + 1);
							},
							1000 * (retryCount + 1)
						); // Exponential backoff: 1s, 2s (longer for auth issues)
						return;
					}

					// Show user-friendly error message based on error type
					if (
						error.code === 'PGRST116' &&
						error.details?.includes('0 rows') &&
						!isAuthRelatedError
					) {
						// Only show "not found" if we're sure it's not an auth issue
						Alert.alert(
							t('common.error', 'Fehler'),
							t(
								'memo.not_found',
								'Das Memo wurde nicht gefunden. Es wurde möglicherweise gelöscht.'
							)
						);
						// Clear the memo from the store to prevent showing stale data
						setMemo(null);
					} else if (error.message?.includes('permission') || error.code === '42501') {
						Alert.alert(
							t('common.error', 'Fehler'),
							t('memo.no_permission', 'Sie haben keine Berechtigung, dieses Memo anzuzeigen.')
						);
					} else {
						console.log('ERROR LOADING MEMO', error);
						Alert.alert(
							t('common.error', 'Fehler'),
							t('memo.could_not_load', 'Memo konnte nicht geladen werden.')
						);
					}
					return;
				}

				if (!data) {
					console.error('MemoState: No data returned for memo ID:', memoId);
					Alert.alert(
						t('common.error', 'Fehler'),
						t('memo.not_found', 'Das Memo wurde nicht gefunden.')
					);
					return;
				}

				console.log('[useMemoState] Fetched memo data:', data);
				console.log('[useMemoState] Location field in memo:', data.location);
				setMemo(data);
				setIsPinned(data.is_pinned || false);

				// Generate audio URL if audio_path exists
				debug('MemoState: Checking audio data - source.audio_path:', data?.source?.audio_path);
				if (data?.source?.audio_path) {
					updateLoadingState('audio', true);
					const audioPath = data.source.audio_path;
					debug('MemoState: Audio path found:', audioPath);
					if (audioPath) {
						debug('MemoState: Requesting signed URL for audio path:', audioPath);
						const signedUrl = await getSignedUrl(audioPath);
						if (signedUrl) {
							setAudioUrl(signedUrl);
							debug(
								'MemoState: Audio URL generated successfully:',
								signedUrl.substring(0, 100) + '...'
							);
						} else {
							debug('MemoState: Failed to generate audio URL for path:', audioPath);
						}
					} else {
						debug('MemoState: Audio path is empty or null');
					}
					updateLoadingState('audio', false);
				} else {
					debug('MemoState: No audio path found in memo source data');
					setAudioUrl(null);
				}

				// Handle memories result from parallel loading
				const { data: memoriesData, error: memoriesError } = memoriesResult;

				if (memoriesError) {
					debug('Error fetching memories:', memoriesError.message);
				} else if (memoriesData) {
					debug('Fetched memories count:', memoriesData.length);
					setMemories(memoriesData);
				}
			} catch (error: any) {
				debug('MemoState: Error in loadMemoData:', error);

				// Handle authentication errors specifically
				if (error.message?.includes('Authentication failed')) {
					// Don't show alert for auth failures - just retry silently
					if (retryCount < 2) {
						debug('MemoState: Authentication error, retrying...');
						updateLoadingState('memo', false);
						setTimeout(
							() => {
								loadMemoData(memoId, retryCount + 1);
							},
							1000 * (retryCount + 1)
						);
						return;
					}
				}

				// For other errors, show generic error message
				Alert.alert(
					t('common.error', 'Fehler'),
					t(
						'memo.load_error',
						'Das Memo konnte nicht geladen werden. Bitte versuchen Sie es später erneut.'
					)
				);
			} finally {
				updateLoadingState('memo', false);
			}
		},
		[getSignedUrl, updateLoadingState, t]
	);

	// Edit operations
	const handleEditStart = useCallback(() => {
		debug('handleEditStart called:', { isEditMode, hasMemo: !!memo });
		if (!isEditMode && memo) {
			const initialTitle = memo.title || '';
			const initialIntro = memo.intro || '';
			const initialTranscript = getTranscriptText(memo);

			// Handle utterances from different possible locations
			const initialUtterances = getUtterances(memo);

			debug('handleEditStart - Setting initial values:', {
				initialTitle,
				initialIntro,
				initialTranscript,
				initialUtterances,
			});

			setEditTitle(initialTitle);
			setEditIntro(initialIntro);
			setEditTranscript(initialTranscript);
			setEditUtterances(initialUtterances);

			// Also update refs
			editTranscriptRef.current = initialTranscript;
			editUtterancesRef.current = initialUtterances;

			setIsEditMode(true);
			debug('Edit mode activated');
		} else {
			debug('handleEditStart - Skipped, already in edit mode or no memo');
		}
	}, [isEditMode, memo]);

	// Debug memo changes during edit mode
	useEffect(() => {
		if (isEditMode) {
			debug('Memo changed during edit mode:', {
				memoId: memo?.id,
				memoTitle: memo?.title,
				memoTranscript: memo?.transcript || memo?.source?.transcript || memo?.metadata?.transcript,
				currentEditTranscript: editTranscript,
				currentEditUtterances: editUtterances?.length,
			});
		}
	}, [memo, isEditMode, editTranscript, editUtterances]);

	const handleSaveEdit = useCallback(
		async (memoId: string) => {
			if (!memo || !memoId) return;

			try {
				updateLoadingState('memo', true);
				const supabase = await getAuthenticatedClient();

				// Capture current edit values to prevent race conditions (use refs for reliable values)
				const currentEditTitle = editTitle;
				const currentEditIntro = editIntro;
				const currentEditTranscript = editTranscriptRef.current;
				const currentEditUtterances = editUtterancesRef.current;

				debug('handleSaveEdit - Captured current values:', {
					currentEditTitle,
					currentEditIntro,
					currentEditTranscript,
					currentEditUtterances,
					stateTranscript: editTranscript,
					refTranscript: editTranscriptRef.current,
				});

				// Prepare update data
				const updateData: Record<string, unknown> = {
					title: currentEditTitle,
					intro: currentEditIntro,
				};

				// Update transcript and utterances if they changed
				const originalTranscript = getTranscriptText(memo);
				const originalUtterances = getUtterances(memo);

				debug('handleSaveEdit - Checking for changes:', {
					currentEditTranscript,
					originalTranscript,
					currentEditUtterances,
					originalUtterances,
					transcriptChanged: currentEditTranscript !== originalTranscript,
					utterancesChanged:
						JSON.stringify(currentEditUtterances) !== JSON.stringify(originalUtterances),
				});

				if (
					currentEditTranscript !== originalTranscript ||
					JSON.stringify(currentEditUtterances) !== JSON.stringify(originalUtterances)
				) {
					// Determine the utterances to save
					let utterancesToSave = currentEditUtterances;

					// When transcript changes but we have no utterances or just one, create/update the single utterance
					if (
						currentEditTranscript !== originalTranscript &&
						(!currentEditUtterances || currentEditUtterances.length <= 1)
					) {
						// If transcript changed and we have no utterances or just one, create a single utterance
						utterancesToSave = [
							{
								text: currentEditTranscript,
								speakerId: currentEditUtterances?.[0]?.speakerId || 'default',
								offset: currentEditUtterances?.[0]?.offset || 0,
								duration: currentEditUtterances?.[0]?.duration || 0,
							},
						];
					}

					// Update source with utterances only (no transcript field)
					if (memo.source && utterancesToSave) {
						const updatedSource = {
							...memo.source,
							utterances: utterancesToSave,
						};

						// Remove any legacy transcript fields
						delete updatedSource.transcript;
						delete updatedSource.content;
						delete updatedSource.transcription;

						updateData.source = updatedSource;
					}

					// Also remove transcript from top level if it exists
					updateData.transcript = null;
				}

				const { data, error } = await supabase
					.from('memos')
					.update(updateData)
					.eq('id', memoId)
					.select('id, title, intro, created_at, source, metadata, is_pinned')
					.single();

				if (error) {
					debug('Error updating memo:', error.message);
					Alert.alert(
						t('common.error', 'Fehler'),
						t('memo.update_error', 'Das Memo konnte nicht aktualisiert werden.')
					);
					return;
				}

				debug('Memo updated successfully:', data);
				debug('New memo utterances:', data.source?.utterances);
				debug('New memo transcript:', data.source?.transcript || data.metadata?.transcript);
				debug('New memo speakerMap:', (data.source as any)?.speakerMap);
				debug('Full new memo source:', data.source);
				debug('Full new memo metadata:', data.metadata);
				setMemo(data);

				// Clear edit states when leaving edit mode
				setEditTranscript('');
				setEditUtterances(null);
				editTranscriptRef.current = '';
				editUtterancesRef.current = null;

				setIsEditMode(false);
			} catch (error) {
				debug('Error in handleSaveEdit:', error);
				Alert.alert(
					t('common.error', 'Fehler'),
					t('common.unexpected_error', 'Ein unerwarteter Fehler ist aufgetreten.')
				);
			} finally {
				updateLoadingState('memo', false);
			}
		},
		[memo, editTitle, editIntro, updateLoadingState, t]
	);

	const handleCancelEdit = useCallback(() => {
		setIsEditMode(false);
		debug('Edit mode canceled');
	}, []);

	// Pin toggle operation
	const handlePinToggle = useCallback(
		async (memoId: string) => {
			if (!memoId) return;

			const newPinnedState = !isPinned;

			try {
				updateLoadingState('memo', true);
				const supabase = await getAuthenticatedClient();

				const { error } = await supabase
					.from('memos')
					.update({ is_pinned: newPinnedState })
					.eq('id', memoId);

				if (error) {
					debug('Error updating pin status:', error.message);
					Alert.alert(
						t('common.error', 'Fehler'),
						t('memo.pin_error', 'Der Pin-Status konnte nicht aktualisiert werden.')
					);
					return;
				}

				setIsPinned(newPinnedState);
				debug('Pin status updated successfully');
			} catch (error) {
				debug('Error in handlePinToggle:', error);
			} finally {
				updateLoadingState('memo', false);
			}
		},
		[isPinned, updateLoadingState, t]
	);

	// Helper function to update individual utterance
	const updateEditUtterance = useCallback(
		(index: number, newText: string) => {
			debug('updateEditUtterance called:', { index, newText, hasEditUtterances: !!editUtterances });
			if (!editUtterances) return;

			const updatedUtterances = [...editUtterances];
			if (updatedUtterances[index]) {
				updatedUtterances[index] = {
					...updatedUtterances[index],
					text: newText,
				};
				debug('Setting updated utterances:', updatedUtterances);
				setEditUtterances(updatedUtterances);
				// Also update ref
				editUtterancesRef.current = updatedUtterances;
			}
		},
		[editUtterances]
	);

	// Custom setEditTranscript that also updates ref
	const setEditTranscriptWithRef = useCallback((transcript: string) => {
		debug('setEditTranscriptWithRef called:', transcript);
		setEditTranscript(transcript);
		editTranscriptRef.current = transcript;
	}, []);

	return {
		// State
		memo,
		memories,
		localMemories,
		isPinned,
		isEditMode,
		editTitle,
		editIntro,
		editTranscript,
		editUtterances,
		audioUrl,
		loadingStates,
		wordToReplace,
		replacementWord,
		speakerMappings,
		summaryError,
		isGeneratingSummary,

		// Actions
		updateLoadingState,
		isAnyLoading,
		loadMemoData,
		handleEditStart,
		handleSaveEdit,
		handleCancelEdit,
		handlePinToggle,
		getSignedUrl,
		setMemories,
		setLocalMemories,
		setMemo,
		setEditTitle,
		setEditIntro,
		setEditTranscript: setEditTranscriptWithRef,
		setEditUtterances,
		updateEditUtterance,
		setWordToReplace,
		setReplacementWord,
		setSpeakerMappings,
		setSummaryError,
		setIsGeneratingSummary,
	};
}