// Set the AI provider (OpenAI, Claude, etc.)
aiService.setProvider(LLMProviderType.OPENAI);

// Generate a simple response
const response = await aiService.generateResponse(
  "You are a helpful sales assistant.",
  "Tell me about your products"
);

// Generate response with conversation context
const response = await aiService.generateResponseWithHistory(
  "You are a helpful sales assistant.",
  [
    { role: "user", content: "Hello" },
    { role: "assistant", content: "Hi! How can I help you?" },
    { role: "user", content: "What products do you have?" }
  ]
);

// Generate response with document context enhancement
const response = await aiService.generateEnhancedResponse(
  basePrompt,
  userMessage,
  organizationId,
  aiAgentId,
  {
    includeDocuments: true,
    maxTokens: 1000,
    temperature: 0.7
  }
);

// Create a new prompt template
const template = await promptTemplateService.create(organizationId, {
  name: "Sales Assistant",
  description: "Template for sales conversations",
  templateContent: "You are a helpful sales assistant for {{companyName}}...",
  inputVariables: ["companyName", "productName"],
  businessInfo: {
    companyName: "Acme Corp",
    industry: "Technology"
  },
  personalitySettings: {
    tone: "professional",
    style: "conversational"
  },
  isActive: true
});

// Find templates with filtering
const templates = await promptTemplateService.findMany(organizationId, {
  page: 1,
  limit: 10,
  campaignId: "campaign_123",
  isActive: true,
  search: "sales",
  sortBy: "createdAt",
  sortOrder: "desc"
});

// Update an existing template
const updatedTemplate = await promptTemplateService.update(templateId, {
  templateContent: "Updated template content...",
  personalitySettings: {
    tone: "friendly",
    style: "casual"
  }
});

// Delete a template
await promptTemplateService.delete(templateId);

// Enhance prompt with document context
const enhancedPrompt = await promptEnhancementService.enhancePrompt(
  basePrompt,
  userMessage,
  organizationId,
  aiAgentId,
  {
    includeDocuments: true,
    maxDocuments: 5,
    similarityThreshold: 0.7,
    includeBusinessInfo: true,
    includeProductInfo: true
  }
);

// Search for relevant documents
const documents = await promptEnhancementService.searchDocuments(
  userMessage,
  organizationId,
  {
    limit: 10,
    threshold: 0.7,
    includeContent: true
  }
);

// Create an AI agent
const agent = await aiAgentService.create(organizationId, {
  name: "Sales Bot",
  description: "Automated sales assistant",
  promptTemplateId: "template_123",
  channels: ["DIRECT_MESSAGE", "COMMENT"],
  autoResponse: true,
  responseDelay: 30,
  maxResponsesPerConversation: 5,
  businessHoursOnly: false
});

// Update agent configuration
const updatedAgent = await aiAgentService.update(agentId, {
  autoResponse: false,
  responseDelay: 60,
  businessHoursOnly: true,
  businessHours: {
    start: "09:00",
    end: "17:00",
    timezone: "America/New_York"
  }
});

// Process incoming message with agent
const response = await aiAgentService.processMessage(
  agentId,
  userMessage,
  conversationHistory,
  {
    includeContext: true,
    trackInteraction: true
  }
);

// Process a conversation with advanced features
const result = await conversationProcessingService.processConversation({
  organizationId,
  aiAgentId,
  userMessage,
  conversationHistory,
  context: {
    userProfile: userProfile,
    businessContext: businessContext,
    sessionData: sessionData
  },
  options: {
    includeSentiment: true,
    includeIntent: true,
    trackMetrics: true
  }
});

// Get conversation analytics
const analytics = await conversationProcessingService.getAnalytics(organizationId, {
  dateRange: {
    start: "2024-01-01",
    end: "2024-01-31"
  },
  metrics: ["response_time", "satisfaction", "conversion_rate"]
});

// Search for relevant documents
const results = await documentVectorService.search(
  query,
  organizationId,
  {
    limit: 10,
    threshold: 0.7,
    includeContent: true,
    documentTypes: ["knowledge_base", "product_info"]
  }
);

// Add document to vector store
const document = await documentVectorService.addDocument({
  organizationId,
  title: "Product Guide",
  content: "Complete product information...",
  metadata: {
    type: "product_info",
    category: "electronics",
    tags: ["guide", "product"]
  }
});

// Update existing document
const updatedDocument = await documentVectorService.updateDocument(documentId, {
  content: "Updated product information...",
  metadata: {
    updated: true,
    version: "2.0"
  }
});

// Complete flow for generating AI responses
async function generateIntelligentResponse(
  organizationId: string,
  aiAgentId: string,
  userMessage: string,
  conversationHistory: ConversationMessage[]
) {
  // 1. Get agent configuration
  const agent = await aiAgentService.getAgent(aiAgentId);
  
  // 2. Get prompt template
  const template = await promptTemplateService.getTemplate(agent.promptTemplateId);
  
  // 3. Enhance prompt with context
  const enhancedPrompt = await promptEnhancementService.enhancePrompt(
    template.templateContent,
    userMessage,
    organizationId,
    aiAgentId,
    {
      includeDocuments: true,
      includeBusinessInfo: true,
      maxDocuments: 5
    }
  );
  
  // 4. Generate response
  const response = await aiService.generateEnhancedResponseWithHistory(
    enhancedPrompt.enhancedPrompt,
    userMessage,
    organizationId,
    aiAgentId,
    conversationHistory,
    {
      maxTokens: 1000,
      temperature: 0.7
    }
  );
  
  // 5. Track interaction
  await conversationProcessingService.trackInteraction({
    agentId: aiAgentId,
    userMessage,
    aiResponse: response,
    metrics: {
      responseTime: Date.now() - startTime,
      tokensUsed: response.length,
      contextDocuments: enhancedPrompt.documents.length
    }
  });
  
  return response;
}

// Template creation and testing workflow
async function createAndTestTemplate(organizationId: string) {
  // 1. Create template
  const template = await promptTemplateService.create(organizationId, {
    name: "Customer Support",
    templateContent: "You are a helpful customer support agent...",
    inputVariables: ["customerName", "issueType"],
    businessInfo: {
      companyName: "Acme Corp",
      supportHours: "24/7"
    }
  });
  
  // 2. Test template
  const testResponse = await aiService.testPrompt(
    template.templateContent,
    "I need help with my order"
  );
  
  // 3. Validate response quality
  const quality = await promptTemplateService.validateResponse(
    template.id,
    testResponse,
    {
      checkTone: true,
      checkCompleteness: true,
      checkRelevance: true
    }
  );
  
  // 4. Activate if quality is good
  if (quality.score > 0.8) {
    await promptTemplateService.update(template.id, { isActive: true });
  }
  
  return { template, testResponse, quality };
}

// Implement caching for frequently used prompts
const cachedPrompt = await promptCache.get(promptId);
if (!cachedPrompt) {
  const prompt = await promptTemplateService.getTemplate(promptId);
  await promptCache.set(promptId, prompt, 3600); // 1 hour cache
}

// Batch process multiple messages
const responses = await Promise.all(
  messages.map(message => 
    aiService.generateEnhancedResponse(
      basePrompt,
      message.content,
      organizationId,
      aiAgentId
    )
  )
);

// Implement rate limiting for AI requests
const rateLimiter = new RateLimiter({
  windowMs: 60000, // 1 minute
  max: 100 // 100 requests per minute
});

// Track AI service performance
const metrics = {
  responseTime: Date.now() - startTime,
  tokensUsed: response.length,
  providerLatency: providerResponseTime,
  cacheHitRate: cacheHits / totalRequests,
  errorRate: errors / totalRequests
};

await analyticsService.track('ai_response_generated', metrics);

// Monitor response quality
const quality = await qualityService.assessResponse(response, {
  checkGrammar: true,
  checkTone: true,
  checkCompleteness: true,
  checkRelevance: true
});

if (quality.score < 0.7) {
  await alertService.sendQualityAlert(agentId, quality);
}