import { useMemo } from 'react';
import { useTranslation } from 'react-i18next';
import { RecordingStatus } from '~/features/audioRecordingV2';
import { useMemoStore } from '../store/memoStore';
import { hasTranscript } from '../utils/transcriptUtils';

// Constants for default memo titles
export const DEFAULT_MEMO_TITLES = {
	UNNAMED: 'Unbenanntes Memo',
	NEW_RECORDING: 'Neue Aufnahme',
	MEMO: 'Memo',
};

// Processing status enum
export enum MemoProcessingStatus {
	UPLOADING = 'uploading',
	TRANSCRIBING = 'transcribing',
	GENERATING_HEADLINE = 'generating_headline',
	COMPLETED = 'completed',
	ERROR = 'error',
	NO_TRANSCRIPT = 'no_transcript',
}

// Status display text mapping - now using translations
const getProcessingStatusText = (t: any) => ({
	[MemoProcessingStatus.UPLOADING]: t('memo.status.memo_uploading'),
	[MemoProcessingStatus.TRANSCRIBING]: t('memo.status.memo_transcribing'),
	[MemoProcessingStatus.GENERATING_HEADLINE]: t('memo.status.headline_generating'),
	[MemoProcessingStatus.COMPLETED]: '', // Empty string - we'll use the actual title for completed memos
	[MemoProcessingStatus.ERROR]: t('memo.status.error_processing_memo'),
	[MemoProcessingStatus.NO_TRANSCRIPT]: t('memo.status.no_transcript'),
});

interface MemoProcessingProps {
	memo: {
		id: string;
		title?: string;
		source?: {
			audio_path?: string;
			transcript?: string;
		};
		metadata?: {
			processing?: {
				transcription?: {
					status?: string;
					timestamp?: string;
				};
				headline?: {
					status?: string;
					timestamp?: string;
				};
				headline_and_intro?: {
					status?: string;
					updated_at?: string;
				};
			};
			transcriptionStatus?: string;
			recordingStatus?: string; // Added to track recording status
		};
	};
	recordingStatus?: RecordingStatus; // Optional recording status from recording store
}

/**
 * Custom hook to handle memo processing status and display title
 */
export function useMemoProcessing({ memo, recordingStatus }: MemoProcessingProps) {
	const { t } = useTranslation();
	// Get the latest memo ID reactively from the store
	const latestMemoId = useMemoStore((state) => state.latestMemo?.id);

	// Only apply recording status to the latest memo (the one being recorded)
	// This prevents all memos from showing "Recording in progress..."
	const isLatestMemo = useMemo(() => {
		// Check if this is the latest memo by comparing IDs
		return latestMemoId === memo.id;
	}, [memo.id, latestMemoId]);

	// Only use recording status for the latest memo AND when recordingStatus is provided
	const effectiveRecordingStatus = isLatestMemo && recordingStatus ? recordingStatus : undefined;
	// Determine the processing status of the memo
	const processingStatus = useMemo((): MemoProcessingStatus => {
		// Priority 1: Active recording status (only for latest memo)
		// Note: RecordingStatus.UPLOADING doesn't exist in the enum, removed invalid check
		if (
			effectiveRecordingStatus === RecordingStatus.RECORDING ||
			effectiveRecordingStatus === RecordingStatus.PAUSED
		) {
			return MemoProcessingStatus.UPLOADING;
		}

		// Priority 2: Check memo metadata recording status if recording status was provided
		// Skip checking for UPLOADING since it doesn't exist in RecordingStatus enum
		if (recordingStatus !== undefined && !effectiveRecordingStatus) {
			if (
				memo.metadata?.recordingStatus === RecordingStatus.RECORDING ||
				memo.metadata?.recordingStatus === RecordingStatus.PAUSED
			) {
				return MemoProcessingStatus.UPLOADING;
			}
		}

		// Priority 3: Check for no transcript state
		if (
			memo.metadata?.processing?.transcription?.status === 'completed_no_transcript' ||
			memo.metadata?.processing?.headline_and_intro?.status === 'completed_no_transcript'
		) {
			return MemoProcessingStatus.NO_TRANSCRIPT;
		}

		// Priority 4: Check if we have a real, meaningful title - if so, we're done
		const hasRealTitle =
			memo.title &&
			memo.title !== DEFAULT_MEMO_TITLES.UNNAMED &&
			memo.title !== DEFAULT_MEMO_TITLES.NEW_RECORDING &&
			memo.title !== DEFAULT_MEMO_TITLES.MEMO &&
			memo.title !== 'Titel wird generiert...' &&
			memo.title.trim() !== '';

		if (hasRealTitle) {
			return MemoProcessingStatus.COMPLETED;
		}

		// Priority 5: Check for completed headline generation
		if (memo.metadata?.processing?.headline_and_intro?.status === 'completed') {
			// If headline is completed but no real title exists, this is the edge case
			// where headline generation produced fallback values
			// Keep showing generating status to avoid confusing "ready" message
			return MemoProcessingStatus.GENERATING_HEADLINE;
		}

		// Priority 5: Check for errors
		if (memo.metadata?.processing?.transcription?.status === 'error') {
			return MemoProcessingStatus.ERROR;
		}

		// Priority 6: Check for processing states
		// Check for ongoing transcription (both old and new metadata structure)
		if (
			memo.metadata?.transcriptionStatus === 'processing' ||
			memo.metadata?.processing?.transcription?.status === 'processing' ||
			memo.metadata?.processing?.transcription?.status === 'pending'
		) {
			return MemoProcessingStatus.TRANSCRIBING;
		}

		// Check for ongoing headline generation
		if (
			memo.metadata?.processing?.headline?.status === 'processing' ||
			memo.metadata?.processing?.headline_and_intro?.status === 'processing' ||
			memo.metadata?.processing?.headline_and_intro?.status === 'pending'
		) {
			return MemoProcessingStatus.GENERATING_HEADLINE;
		}

		// Priority 7: Check for completed transcription but no headline yet
		if (memo.metadata?.processing?.transcription?.status === 'completed') {
			// If transcription is done but no headline status or it's not started, we're generating headline
			if (
				!memo.metadata?.processing?.headline_and_intro?.status ||
				memo.metadata?.processing?.headline_and_intro?.status === 'pending'
			) {
				return MemoProcessingStatus.GENERATING_HEADLINE;
			}
		}

		// Priority 8: Check for transcript without title (should generate headline)
		if (hasTranscript(memo) && !hasRealTitle) {
			return MemoProcessingStatus.GENERATING_HEADLINE;
		}

		// Priority 9: Check for audio_path without transcript (still transcribing)
		if (memo.source?.audio_path && !memo.transcript && !memo.source?.transcript) {
			return MemoProcessingStatus.TRANSCRIBING;
		}

		// Priority 10: Check if we have an audio_path but no processing metadata (still uploading)
		if (memo.source?.audio_path && !memo.metadata?.processing) {
			return MemoProcessingStatus.UPLOADING;
		}

		// Priority 11: Check if we have no title at all
		if (!memo.title || memo.title.trim() === '') {
			// If we have any source data, we're at least transcribing
			if (memo.source?.audio_path || memo.source?.duration) {
				return MemoProcessingStatus.TRANSCRIBING;
			}
			// If we have processing metadata, check the status
			if (
				memo.metadata?.processing?.transcription?.status === 'pending' ||
				memo.metadata?.processing?.headline_and_intro?.status === 'pending'
			) {
				return MemoProcessingStatus.TRANSCRIBING;
			}
			// Otherwise, we're in a generic processing state
			return MemoProcessingStatus.UPLOADING;
		}

		// Default: If nothing else applies, consider it completed
		return MemoProcessingStatus.COMPLETED;
	}, [memo, effectiveRecordingStatus, recordingStatus]);

	// Determine the display title based on the processing status
	// We use a more stable dependency array to prevent unnecessary recalculations
	const displayTitle = useMemo((): string => {
		// For recording in progress, only show the recording status for the latest memo
		// Only show recording status if there's an active effectiveRecordingStatus (not IDLE)
		if (
			effectiveRecordingStatus === RecordingStatus.RECORDING ||
			effectiveRecordingStatus === RecordingStatus.PAUSED
		) {
			console.debug('Showing "Recording in progress..." for memo:', memo.id);
			return t('memo.status.recording_in_progress');
		}

		// Note: Removed check for RecordingStatus.UPLOADING as it doesn't exist in the enum
		// The uploading state is now handled by the processingStatus logic below

		// Priority 1: Show processing status during transcription and headline generation
		// This ensures users see "Transcribing..." and "Generating title..." even if memo has a title
		const statusText = getProcessingStatusText(t);
		if (
			processingStatus === MemoProcessingStatus.TRANSCRIBING ||
			processingStatus === MemoProcessingStatus.GENERATING_HEADLINE ||
			processingStatus === MemoProcessingStatus.UPLOADING
		) {
			return statusText[processingStatus];
		}

		// Priority 2: If a real title exists (not default/placeholder), show it
		// This prevents flickering during processing state changes
		if (
			memo.title &&
			memo.title !== DEFAULT_MEMO_TITLES.UNNAMED &&
			memo.title !== DEFAULT_MEMO_TITLES.NEW_RECORDING &&
			memo.title !== DEFAULT_MEMO_TITLES.MEMO &&
			memo.title !== 'Titel wird generiert...' &&
			memo.title.trim() !== ''
		) {
			return memo.title;
		}

		// Priority 3: Show error status if applicable
		if (processingStatus === MemoProcessingStatus.ERROR) {
			return statusText[processingStatus];
		}

		// Priority 4: Show no transcript status if applicable
		if (processingStatus === MemoProcessingStatus.NO_TRANSCRIPT) {
			return statusText[processingStatus];
		}

		// Default fallback: show processing message
		if (!memo.title || memo.title.trim() === '') {
			// No title at all, show appropriate processing status
			if (memo.source?.audio_path) {
				return t('memo.status.memo_transcribing');
			}
			return t('memo.status.memo_processing', 'Processing memo...');
		}

		return memo.title &&
			memo.title !== DEFAULT_MEMO_TITLES.UNNAMED &&
			memo.title !== DEFAULT_MEMO_TITLES.NEW_RECORDING &&
			memo.title !== DEFAULT_MEMO_TITLES.MEMO
			? memo.title
			: t('memo.status.memo_processing', 'Processing memo...');
	}, [memo.title, processingStatus, effectiveRecordingStatus, isLatestMemo, t]);

	return {
		processingStatus,
		displayTitle,
	};
}