/**
 * Memory Example - Conversation Context and External Memory Providers
 *
 * This example demonstrates:
 * - Agent-level memory (simple conversation history)
 * - External memory providers (Mem0, AWS AgentCore)
 * - Session management for multi-turn conversations
 */

import { v4 as uuidv4 } from 'uuid';
import { Studio } from '../src';

async function main() {
  const studio = new Studio({
    apiKey: process.env.LYZR_API_KEY
  });

  try {
    // Example 1: Simple Agent Memory
    console.log('=== Agent Memory Example ===\n');

    const agent = await studio.createAgent({
      name: 'Chatbot',
      provider: 'gpt-4o',
      role: 'Friendly chatbot',
      goal: 'Remember and respond to users',
      instructions: 'Be conversational and remember what the user told you',
      memory: 30 // Keep last 30 messages
    });

    console.log('✓ Agent created with memory enabled\n');

    const sessionId = uuidv4();
    console.log(`Session ID: ${sessionId}\n`);

    // Multi-turn conversation
    console.log('Turn 1: Introduce yourself');
    let response = await agent.run(
      'My name is Alice and I work as a software engineer',
      { sessionId }
    );
    console.log(`Agent: ${response.response.substring(0, 150)}...\n`);

    console.log('Turn 2: Ask agent to remember');
    response = await agent.run(
      'What did I just tell you about myself?',
      { sessionId }
    );
    console.log(`Agent: ${response.response}\n`);

    console.log('Turn 3: Add more context');
    response = await agent.run(
      'I specialize in TypeScript and have 5 years of experience',
      { sessionId }
    );
    console.log(`Agent: ${response.response.substring(0, 150)}...\n`);

    console.log('Turn 4: Ask about combined context');
    response = await agent.run(
      'Summarize what you know about me',
      { sessionId }
    );
    console.log(`Agent: ${response.response}\n`);

    await agent.delete();

    // Example 2: External Memory Provider (Mem0)
    console.log('\n=== External Memory Provider Example ===\n');

    console.log('Creating memory credential for Mem0...');
    // Note: In real usage, provide actual API key
    const memory = await studio.createMemoryCredential(
      'mem0',
      'My Mem0 Memory',
      {
        mem0_api_key: process.env.MEM0_API_KEY || 'demo-key',
        user_id: 'user_' + uuidv4()
      }
    );

    console.log(`✓ Memory credential created: ${memory.name}`);
    console.log(`  Provider: ${memory.provider}`);
    console.log(`  Status: ${memory.status}\n`);

    // Validate memory
    try {
      console.log('Validating memory credential...');
      const validation = await memory.validate();
      console.log(`✓ Memory validated\n`);
    } catch (error) {
      console.log(`⚠ Memory validation result: ${(error as Error).message}\n`);
    }

    // Check memory status
    const status = await memory.getStatus();
    console.log(`Memory status: ${status}\n`);

    // Clean up memory (optional)
    // await memory.delete();

    // Example 3: AWS AgentCore Memory (with resource management)
    console.log('=== AWS AgentCore Memory Example ===\n');

    console.log('Creating AWS AgentCore memory credential...');
    // Note: Requires actual AWS credentials
    const awsMemory = await studio.createMemoryCredential(
      'aws-agentcore',
      'AWS Agent Memory',
      {
        aws_access_key_id: process.env.AWS_ACCESS_KEY_ID || '',
        aws_secret_access_key: process.env.AWS_SECRET_ACCESS_KEY || '',
        aws_region: 'us-east-1'
      }
    );

    console.log(`✓ AWS memory credential created: ${awsMemory.name}`);
    console.log(`  Memory ID: ${awsMemory.memoryId || 'pending'}`);
    console.log(`  Memory ARN: ${awsMemory.memoryArn || 'pending'}\n`);

    // List available resources (AWS-specific)
    if (awsMemory.provider === 'aws-agentcore') {
      try {
        console.log('Listing AWS memory resources...');
        const resources = await awsMemory.listResources();
        console.log(`  Found ${resources.length} resources`);
        resources.forEach(r => {
          console.log(`    - ${r.name} (${r.status})`);
        });
      } catch (error) {
        console.log('  (Resources not available until memory is active)');
      }
    }

    // Clean up
    console.log('\n✓ Examples completed');
  } catch (error) {
    console.error('Error:', error);
    process.exit(1);
  }
}

main();