import { ae_util } from '$lib/ae_utils/ae_utils';
import type { ae_JournalEntry, ae_Journal } from '$lib/types/ae_types';

/**
 * Result structure for decryption operations.
 */
export interface DecryptionResult {
    success: boolean;
    content?: string;
    history?: string;
    error?: string;
}

/**
 * Decrypts a journal entry's content and history using the provided or stored passcode.
 *
 * @param entry The journal entry object to decrypt.
 * @param journal The parent journal object (provides base passcode and private_passcode).
 * @param typed_passcode Optional: A user-entered passcode override.
 * @returns A Promise resolving to a DecryptionResult.
 */
export async function decrypt_journal_entry(
    entry: ae_JournalEntry,
    journal: ae_Journal,
    typed_passcode?: string
): Promise<DecryptionResult> {
    // Safety check: if not encrypted, return as-is
    if (!entry.content_encrypted) {
        return {
            success: true,
            content: entry.content ?? '',
            history: entry.history ?? ''
        };
    }

    // Determine which key to use
    let journal_key = typed_passcode;
    let key_source = 'user_typed';

    // If no override, try the private passcode stored on the journal object
    if (!journal_key?.length) {
        journal_key = journal.private_passcode;
        key_source = 'journal_private_passcode';
    }

    if (!journal_key) {
        console.warn(
            'decrypt_journal_entry: No key available. Source:',
            key_source
        );
        return {
            success: false,
            error: 'No passcode provided or available for decryption.'
        };
    }

    // Aether standard: combine the journal's public passcode with the private key
    const decrypt_key = `${journal.passcode ?? ''}:${journal_key}`;

    console.log(
        `decrypt_journal_entry: Attempting decryption. Source: ${key_source}`
    );
    // console.log(`decrypt_journal_entry: Key: ${decrypt_key}`); // Log ONLY for deep debugging

    try {
        // Decrypt Primary Content
        const result = await ae_util.decrypt_wrapper(
            entry.content_encrypted,
            decrypt_key
        );

        if (result === false) {
            console.error(
                'decrypt_journal_entry: Decryption wrapper returned false.'
            );
            return {
                success: false,
                error: 'Decryption failed. Incorrect passcode or corrupted data.'
            };
        }

        const decrypted_text = typeof result === 'string' ? result : '';
        let decrypted_history = '';

        // Decrypt History (if it exists)
        if (entry.history_encrypted) {
            const h_res = await ae_util.decrypt_wrapper(
                entry.history_encrypted,
                decrypt_key
            );
            if (h_res !== false) {
                decrypted_history = typeof h_res === 'string' ? h_res : '';
            }
        }

        console.log(
            `decrypt_journal_entry: SUCCESS. Source: ${key_source}, Content length: ${decrypted_text.length}. Preview: ${decrypted_text.substring(0, 30).replace(/\n/g, ' ')}...`
        );
        return {
            success: true,
            content: decrypted_text,
            history: decrypted_history
        };
    } catch (err: any) {
        console.error('decrypt_journal_entry error:', err);
        return {
            success: false,
            error: `System error during decryption: ${err.message}`
        };
    }
}
