/**
 * useAddMemory Hook
 * Hook for adding memories with loading/error state
 */

import { useState, useCallback } from 'react';
import { useMemoryStackClient } from './useMemoryStack';
import type { Message, CreateMemoryResponse } from '../types';
import { OfflineError } from '../errors';

interface AddMemoryState {
    isAdding: boolean;
    error: Error | null;
    lastResult: CreateMemoryResponse | null;
    isQueued: boolean;
}

interface UseAddMemoryResult extends AddMemoryState {
    /**
     * Add a memory
     * @param content - String or array of messages
     * @param options - Optional user ID, metadata, etc.
     */
    add: (
        content: string | Message[],
        options?: {
            userId?: string;
            metadata?: Record<string, unknown>;
            agentId?: string;
            teamId?: string;
            sessionId?: string;
            conversationId?: string;
        }
    ) => Promise<CreateMemoryResponse | null>;
    /** Reset error and result state */
    reset: () => void;
}

/**
 * Hook for adding memories with state management
 * 
 * @example
 * ```tsx
 * function AddMemoryForm() {
 *   const { add, isAdding, error, lastResult, isQueued } = useAddMemory();
 *   const [text, setText] = useState('');
 * 
 *   const handleSubmit = async () => {
 *     const result = await add(text);
 *     if (result) {
 *       setText('');
 *       Alert.alert('Success', `Created ${result.memories_created} memories`);
 *     }
 *   };
 * 
 *   return (
 *     <View>
 *       <TextInput
 *         value={text}
 *         onChangeText={setText}
 *         placeholder="Enter memory..."
 *       />
 *       <Button
 *         title={isAdding ? 'Adding...' : 'Add Memory'}
 *         onPress={handleSubmit}
 *         disabled={isAdding || !text.trim()}
 *       />
 *       {isQueued && <Text>Queued for sync when online</Text>}
 *       {error && <Text style={{ color: 'red' }}>{error.message}</Text>}
 *     </View>
 *   );
 * }
 * ```
 */
export function useAddMemory(): UseAddMemoryResult {
    const client = useMemoryStackClient();

    const [state, setState] = useState<AddMemoryState>({
        isAdding: false,
        error: null,
        lastResult: null,
        isQueued: false,
    });

    const add = useCallback(async (
        content: string | Message[],
        options?: {
            userId?: string;
            metadata?: Record<string, unknown>;
            agentId?: string;
            teamId?: string;
            sessionId?: string;
            conversationId?: string;
        }
    ): Promise<CreateMemoryResponse | null> => {
        if (!client) {
            setState(prev => ({
                ...prev,
                error: new Error('Client not initialized'),
            }));
            return null;
        }

        try {
            setState(prev => ({
                ...prev,
                isAdding: true,
                error: null,
                isQueued: false,
            }));

            const result = await client.add(content, options);

            setState(prev => ({
                ...prev,
                isAdding: false,
                lastResult: result,
                isQueued: false,
            }));

            return result;
        } catch (err) {
            // Check if queued for offline sync
            if (err instanceof OfflineError && err.queuedForSync) {
                setState(prev => ({
                    ...prev,
                    isAdding: false,
                    error: null,
                    isQueued: true,
                }));
                return null;
            }

            setState(prev => ({
                ...prev,
                isAdding: false,
                error: err instanceof Error ? err : new Error('Failed to add memory'),
            }));
            return null;
        }
    }, [client]);

    const reset = useCallback(() => {
        setState({
            isAdding: false,
            error: null,
            lastResult: null,
            isQueued: false,
        });
    }, []);

    return {
        ...state,
        add,
        reset,
    };
}

export default useAddMemory;