Girlfriend
AI

// Advanced memory system with semantic search
const storeMemory = async (aiModelId: string, userId: string, content: string) => {
  // Generate high-dimensional embeddings for semantic similarity
  const embedding = await openai.embeddings.create({
    model: "text-embedding-ada-002",
    input: content,
    encoding_format: "float"
  });
  
  // Store in Pinecone with metadata for filtering
  await pinecone.upsert({
    id: `${aiModelId}-${userId}-${Date.now()}`,
    values: embedding.data[0].embedding,
    metadata: { 
      content, 
      timestamp: Date.now(),
      emotional_tone: analyzeSentiment(content),
      topic_tags: extractTopics(content),
      relationship_stage: determineRelationshipStage(userId)
    }
  });
};

const retrieveMemories = async (aiModelId: string, userId: string, query: string) => {
  // Generate query embedding for similarity search
  const queryEmbedding = await openai.embeddings.create({
    model: "text-embedding-ada-002",
    input: query
  });
  
  // Semantic similarity search with contextual filtering
  const results = await pinecone.query({
    vector: queryEmbedding.data[0].embedding,
    topK: 5,
    filter: { 
      aiModelId, 
      userId,
      // Boost recent memories with time decay
      timestamp: { $gte: Date.now() - (30 * 24 * 60 * 60 * 1000) }
    },
    includeMetadata: true
  });
  
  // Apply relevance scoring and memory decay
  const relevantMemories = results.matches
    .filter(match => match.score > 0.8) // High similarity threshold
    .map(match => ({
      content: match.metadata.content,
      relevance: match.score,
      recency: calculateRecencyScore(match.metadata.timestamp),
      emotional_context: match.metadata.emotional_tone
    }))
    .sort((a, b) => (b.relevance + b.recency) - (a.relevance + a.recency));
    
  return relevantMemories.slice(0, 3); // Top 3 most relevant memories
};

// Sophisticated conversation context management
class ConversationManager {
  private contextWindows = new Map<string, ConversationContext>();
  
  async processMessage(message: string, contextId: string): Promise<AIResponse> {
    const context = this.getOrCreateContext(contextId);
    
    // Update conversation state with multi-dimensional analysis
    context.addMessage(message);
    context.updateMood(await analyzeSentiment(message));
    context.extractTopics(await extractNamedEntities(message));
    context.trackRelationshipProgression(message);
    
    // Retrieve contextually relevant memories
    const relevantMemories = await this.retrieveRelevantMemories(context);
    
    // Generate response with personality consistency
    const response = await this.generateResponse({
      message,
      context,
      memories: relevantMemories,
      personality: context.aiModel.personality,
      mood: context.currentMood,
      relationship_stage: context.relationshipStage
    });
    
    // Store new interaction for future reference
    await this.storeConversationMemory(response, context);
    
    return response;
  }
}

// Custom SSE hook with advanced error handling and reconnection
export const useSSEConnection = ({
  url, onMessage, maxRetries = 5, retryDelay = 2000
}: SSEOptions) => {
  const [isConnected, setIsConnected] = useState(false);
  const [retryCount, setRetryCount] = useState(0);
  const [connectionQuality, setConnectionQuality] = useState<'excellent' | 'good' | 'poor'>('excellent');
  
  const eventSourceRef = useRef<EventSource | null>(null);
  const heartbeatTimeoutRef = useRef<NodeJS.Timeout | null>(null);
  const reconnectTimeoutRef = useRef<NodeJS.Timeout | null>(null);
  
  // Exponential backoff with jitter for connection resilience
  const backoffDelay = retryDelay * Math.pow(2, retryCount) + (Math.random() * 1000);
  
  // Advanced connection monitoring with heartbeat
  const resetHeartbeat = useCallback(() => {
    if (heartbeatTimeoutRef.current) {
      clearTimeout(heartbeatTimeoutRef.current);
    }
    
    heartbeatTimeoutRef.current = setTimeout(() => {
      console.warn('SSE heartbeat timeout - reconnecting...');
      setConnectionQuality('poor');
      eventSourceRef.current?.close();
      connect(); // Auto-reconnect on timeout
    }, 30000); // 30 second heartbeat timeout
  }, []);
  
  // Sophisticated connection management
  const connect = useCallback(() => {
    if (eventSourceRef.current) {
      eventSourceRef.current.close();
    }
    
    const eventSource = new EventSource(url);
    eventSourceRef.current = eventSource;
    
    eventSource.onopen = () => {
      setIsConnected(true);
      setRetryCount(0);
      setConnectionQuality('excellent');
      resetHeartbeat();
    };
    
    eventSource.onmessage = (event) => {
      try {
        const data = JSON.parse(event.data);
        
        // Handle different message types
        switch (data.type) {
          case 'heartbeat':
            resetHeartbeat();
            break;
          case 'ai_response_chunk':
            onMessage?.(data);
            break;
          case 'typing_indicator':
            handleTypingIndicator(data);
            break;
          case 'connection_quality':
            setConnectionQuality(data.quality);
            break;
        }
      } catch (error) {
        console.error('Failed to parse SSE message:', error);
      }
    };
    
    eventSource.onerror = (error) => {
      setIsConnected(false);
      setConnectionQuality('poor');
      
      if (retryCount < maxRetries) {
        console.log(`SSE connection failed, retrying (${retryCount + 1}/${maxRetries})...`);
        setRetryCount(prev => prev + 1);
        
        reconnectTimeoutRef.current = setTimeout(() => {
          connect();
        }, backoffDelay);
      } else {
        console.error('Max SSE retry attempts reached');
      }
    };
  }, [url, retryCount, maxRetries, onMessage, resetHeartbeat, backoffDelay]);
  
  // Message queuing during disconnections
  const [messageQueue, setMessageQueue] = useState<any[]>([]);
  
  const sendMessage = useCallback((message: any) => {
    if (isConnected) {
      // Send immediately if connected
      fetch('/api/chat/send', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(message)
      });
    } else {
      // Queue message for retry when reconnected
      setMessageQueue(prev => [...prev, message]);
    }
  }, [isConnected]);
  
  // Process queued messages on reconnection
  useEffect(() => {
    if (isConnected && messageQueue.length > 0) {
      messageQueue.forEach(sendMessage);
      setMessageQueue([]);
    }
  }, [isConnected, messageQueue, sendMessage]);
  
  return {
    isConnected,
    connectionQuality,
    retryCount,
    sendMessage,
    reconnect: connect
  };
};

// Real-time AI response streaming with typing indicators
const processAIResponseStream = async (userMessage: string, contextId: string) => {
  const response = await fetch('/api/ai/stream', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ message: userMessage, contextId })
  });
  
  const reader = response.body?.getReader();
  let aiResponse = '';
  
  // Send typing indicator
  broadcastTypingIndicator(contextId, true);
  
  try {
    while (reader) {
      const { done, value } = await reader.read();
      if (done) break;
      
      const chunk = new TextDecoder().decode(value);
      const lines = chunk.split('\n');
      
      for (const line of lines) {
        if (line.startsWith('data: ')) {
          const data = line.slice(6);
          if (data === '[DONE]') return;
          
          try {
            const parsed = JSON.parse(data);
            if (parsed.choices?.[0]?.delta?.content) {
              const deltaContent = parsed.choices[0].delta.content;
              aiResponse += deltaContent;
              
              // Broadcast incremental response via SSE
              broadcastToRoom(contextId, {
                type: 'ai_response_chunk',
                content: deltaContent,
                full_response: aiResponse,
                timestamp: Date.now()
              });
            }
          } catch (parseError) {
            console.error('Failed to parse AI response chunk:', parseError);
          }
        }
      }
    }
  } finally {
    broadcastTypingIndicator(contextId, false);
  }
};