import { MemoryClient } from '@memra-client/client'

const memory = new MemoryClient({ apiKey: 'mk_mem_...' })

export async function chat(userId: string, userMessage: string) {
  // 1. Get recent conversation + relevant older memories
  const { recentHistory, relevantMemories } = await memory.getContext(
    userId,
    userMessage
  )

  // 2. Build a system prompt that includes BOTH
  let memoryText = ''
  if (recentHistory.length > 0) {
    memoryText += 'Recent conversation:\n'
    memoryText += recentHistory
      .map(m => `[${m.role}]: ${m.content}`)
      .join('\n')
    memoryText += '\n\n'
  }
  if (relevantMemories.length > 0) {
    memoryText += 'Relevant older memories:\n'
    memoryText += relevantMemories
      .map(m => `[${m.role}]: ${m.content}`)
      .join('\n')
  }

  const systemPrompt = memoryText
    ? `You are a helpful assistant with memory.
${memoryText}
Use this to give personalized responses.`
    : 'You are a helpful assistant.'

  // 3. Call your AI provider (works with any: OpenAI, Groq, etc.)
  const aiReply = await yourAI.chat.completions.create({
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user',   content: userMessage  },
    ],
  })

  // 4. Save this exchange so AI remembers it next time
  await memory.save(userId, userMessage, aiReply)

  return aiReply
}

// Complete working example — Next.js API route
import { NextResponse } from 'next/server'
import MemoryClient from '@memra-client/client'

const memory = new MemoryClient({
  apiKey: process.env.MEMRA_API_KEY || '',
})

export async function POST(req: Request) {
  const { query } = await req.json()

  // Step 1: Get memories (recent chat + relevant older ones)
  const { recentHistory, relevantMemories } = await memory.getContext(
    'user_123', query, { limit: 5, recentLimit: 10 }
  )

  // Step 2: Build the system prompt
  let memorySection = ''
  if (recentHistory.length > 0) {
    memorySection += 'Recent conversation:\n'
      + recentHistory.map(m => `[${m.role}]: ${m.content}`).join('\n')
      + '\n\n'
  }
  if (relevantMemories.length > 0) {
    memorySection += 'Relevant older memories:\n'
      + relevantMemories.map(m => `[${m.role}]: ${m.content}`).join('\n')
  }

  const systemPrompt = memorySection
    ? `You are a helpful assistant with memory.\n${memorySection}\nUse ALL of this to answer.`
    : 'You are a helpful assistant.'

  // Step 3: Call any AI provider
  const aiResponse = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'gpt-4',
      messages: [
        { role: 'system', content: systemPrompt },
        { role: 'user', content: query },
      ],
    }),
  })
  const data = await aiResponse.json()
  const reply = data.choices[0].message.content

  // Step 4: Save so AI remembers next time
  await memory.save('user_123', query, reply)

  return NextResponse.json({ reply })
}

import { MemoryClient } from '@memra-client/client'

const memory = new MemoryClient({
  apiKey: 'mk_mem_...',                          // required — from your dashboard
  baseUrl: 'https://memra-rho.vercel.app/api'    // optional — this is the default
})

memory.save(
  userId: string,       // your end-user's identifier
  userMessage: string,  // the user's message text
  aiReply: string,      // the assistant's response text
  options?: {
    agentId?: string    // isolate memory per bot or context (default: 'default')
  }
): Promise<{ success: boolean; saved: number }>

// After your AI replies, save the exchange
const result = await memory.save(
  'user_abc123',
  'What is my current plan?',
  'You are on the Free plan — 500 memory slots available.',
  { agentId: 'support-bot' }
)
// => { success: true, saved: 2 }

memory.getContext(
  userId: string,
  query: string,           // the current message — used for semantic search
  options?: {
    agentId?: string       // filter to a specific agent (default: 'default')
    limit?: number         // max semantic results (default: 5)
    recentLimit?: number   // max recent messages (default: 10)
  }
): Promise<ContextResponse>

interface ContextResponse {
  recentHistory: Memory[]      // last N messages chronologically
  relevantMemories: Memory[]   // semantic matches from older conversations
  context: Memory[]            // backwards compat — same as semantic results
  count: number
  latencyMs: number            // end-to-end latency, added client-side
}

interface Memory {
  id: string
  content: string
  role: 'user' | 'assistant'
  createdAt: string
  similarity?: number  // 0–1 cosine score (only on semantic results)
}

// This is the key method — call it before every AI response
const { recentHistory, relevantMemories } = await memory.getContext(
  'user_abc123',
  'What plan am I on?',
  { limit: 5, recentLimit: 10 }
)

// recentHistory = last 10 messages in order (always includes recent chat)
// relevantMemories = semantically similar older messages (deduplicated)

// Use BOTH in your system prompt:
const systemPrompt = `You remember everything.
Recent: ${recentHistory.map(m => m.content).join(' | ')}
Related: ${relevantMemories.map(m => m.content).join(' | ')}`

memory.getHistory(
  userId: string,
  options?: {
    agentId?: string     // filter by agent (omit = all agents)
    limit?: number       // omit to get ALL messages
    order?: 'asc'|'desc' // default: 'asc' (oldest first)
    before?: string      // ISO date — get messages before this time
    after?: string       // ISO date — get messages after this time
  }
): Promise<{
  history: Memory[]     // every message for this user
  total: number         // total message count
  count: number         // messages in this response
}>

// Get ALL chat history for a user (for showing in your UI)
const { history, total } = await memory.getHistory('user_abc123')

console.log('Total messages stored:', total)
history.forEach(m => {
  console.log('[' + m.role + '] ' + m.content)
})

// With filters:
const recent = await memory.getHistory('user_abc123', {
  agentId: 'support-bot',
  order: 'desc',   // newest first
  limit: 20,       // just the last 20
})

// app/api/history/route.ts — API route to fetch chat history
import { NextResponse } from 'next/server'
import MemoryClient from '@memra-client/client'

const client = new MemoryClient({
  apiKey: process.env.MEMRA_API_KEY || '',
})

export async function GET() {
  // Returns ALL messages for this user, oldest first
  const { history, total } = await client.getHistory('user_123', {
    order: 'asc',
  })
  return NextResponse.json({ history, total })
}

// Then in your frontend:
// const res = await fetch('/api/history')
// const { history, total } = await res.json()
// history.forEach(msg => renderMessage(msg.role, msg.content))

memory.forget(
  userId: string,
  options?: {
    agentId?: string   // omit to delete ALL memories for this user
  }
): Promise<{ success: boolean; deleted: number }>

// Clear only this agent's memory
await memory.forget('user_abc123', { agentId: 'support-bot' })

// Clear ALL memories for a user across every agent
const result = await memory.forget('user_abc123')
// => { success: true, deleted: 124 }

{ "success": true, "saved": 2 }

{
  "recentHistory": [
    { "id": "clx1", "content": "What is my plan?", "role": "user", "createdAt": "..." },
    { "id": "clx2", "content": "You are on Free.", "role": "assistant", "createdAt": "..." }
  ],
  "relevantMemories": [
    { "id": "clx0", "content": "I signed up yesterday", "role": "user", "similarity": 0.72 }
  ],
  "context": [...],
  "count": 1
}

{
  "history": [
    { "id": "clx1", "content": "Hello", "role": "user", "createdAt": "..." },
    { "id": "clx2", "content": "Hi! How can I help?", "role": "assistant", "createdAt": "..." }
  ],
  "total": 142,
  "count": 142
}

{ "success": true, "deleted": 14 }

{
  "error": "Memory limit reached",
  "limit": 100,
  "plan": "free",
  "upgrade": "https://memra-rho.vercel.app/pricing"
}