import { Maxim } from '@maximai/maxim-js';

// Create logger through Maxim instance
const maxim = new Maxim({ apiKey: 'your-api-key' });
const logger = await maxim.logger({ id: 'my-app' });

// Usually created through Maxim.logger() method
const logger = new MaximLogger({
  config: { id: 'my-app', autoFlush: true },
  apiKey: 'your-api-key',
  baseUrl: 'https://app.getmaxim.ai',
  cache: new MaximInMemoryCache(),
  raiseExceptions: false
});

// Cleanup before app shutdown
process.on('SIGTERM', async () => {
  await logger.cleanup();
  process.exit(0);
});

// Force flush before critical operation
logger.flush();

logger.generationAddMessage('gen-123', [
  { role: 'user', content: 'Can you clarify that?' }
]);

logger.generationAddTag('gen-123', 'type', 'chat_completion');
logger.generationAddTag('gen-123', 'use_case', 'customer_support');

logger.generationEnd('gen-123');

logger.generationError('gen-123', {
  message: 'API request timed out',
  code: 'TIMEOUT_ERROR',
  type: 'NetworkError'
});

logger.generationEvaluate('gen-123')
  .withEvaluators('bias', 'toxicity')
  .withVariables({ expected_output: 'The correct answer' });

logger.generationMetadata('gen-123', {
  requestId: 'req-789',
  latency: 1200,
  tokensPerSecond: 15.5
});

logger.generationResult('gen-123', {
  id: 'cmpl-456',
  object: 'chat.completion',
  created: Date.now(),
  model: 'gpt-4',
  choices: [{
    index: 0,
    message: { role: 'assistant', content: 'Hello! How can I help?' },
    finish_reason: 'stop',
    logprobs: null
  }],
  usage: { prompt_tokens: 10, completion_tokens: 8, total_tokens: 18 }
});

logger.generationSetModel('gen-123', 'gpt-4-turbo');

logger.generationSetModelParameters('gen-123', {
  temperature: 0.9,
  max_tokens: 500,
  top_p: 0.95
});

logger.retrievalAddTag('retrieval-123', 'source', 'knowledge_base');
logger.retrievalAddTag('retrieval-123', 'query_type', 'semantic');

logger.retrievalEnd('retrieval-123');

logger.retrievalEvaluate('retrieval-123')
  .withEvaluators('relevance', 'recall')
  .withVariables({ context: 'user_query', expected: 'ground_truth' });

logger.retrievalInput('retrieval-123', 'How do I troubleshoot network issues?');

logger.retrievalMetadata('retrieval-123', {
  searchTime: 150,
  resultsCount: 5,
  similarityThreshold: 0.85
});

// Single result
logger.retrievalOutput('retrieval-123', 'Network troubleshooting guide: First, check cables...');

// Multiple results
logger.retrievalOutput('retrieval-123', [
  'Document 1: Basic troubleshooting steps...',
  'Document 2: Advanced network diagnostics...'
]);

const session = logger.session({
  id: 'user-session-123',
  name: 'Customer Support Chat',
});

// Add feedback to the session
session.feedback({ score: 5, comment: 'Very helpful!' });
session.end();

logger.sessionEnd('session-123');

logger.sessionEvaluate('session-123')
  .withEvaluators('bias', 'toxicity')
  .withVariables({ context: 'session_context' });

logger.sessionFeedback('session-123', {
  score: 5,
  comment: 'Excellent customer service!'
});

logger.sessionTag('session-123', 'environment', 'production');
logger.sessionTag('session-123', 'user_type', 'premium');

const trace = logger.sessionTrace('session-123', {
  id: 'query-trace-001',
  name: 'User Query Processing'
});

logger.spanEnd('span-123');

const error = logger.spanError('span-123', {
  id: 'error-001',
  message: 'Validation failed',
  code: 'VALIDATION_ERROR',
  type: 'ValidationError'
});

logger.spanEvaluate('span-123')
  .withEvaluators('performance', 'accuracy')
  .withVariables({ expected_output: 'target_result' });

logger.spanEvent(
  'span-123',
  'validation-complete',
  'Data Validation Complete',
  { status: 'success', records: '1000' },
  { validationTime: 250, errorsFound: 0 }
);

const generation = logger.spanGeneration('span-123', {
  id: 'gen-001',
  provider: 'openai',
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Process this data' }],
  modelParameters: { temperature: 0.1 }
});

logger.spanMetadata('span-123', {
  processingTime: 500,
  itemsProcessed: 250,
  memoryUsage: '128MB'
});

const retrieval = logger.spanRetrieval('span-123', {
  id: 'retrieval-001',
  name: 'Context Database Lookup'
});

const childSpan = logger.spanSpan('span-123', {
  id: 'child-span-001',
  name: 'Data Validation Step'
});

logger.spanTag('span-123', 'phase', 'preprocessing');
logger.spanTag('span-123', 'status', 'in_progress');

const toolCall = logger.spanToolCall('span-123', {
  id: 'tool-001',
  name: 'api_call',
  description: 'Fetch data from external service',
  args: JSON.stringify({ endpoint: '/users', id: 123 })
});

logger.toolCallAddTag('tool-123', 'category', 'database');
logger.toolCallAddTag('tool-123', 'priority', 'high');

logger.toolCallError('tool-123', {
  message: 'Database connection failed',
  code: 'DB_CONNECTION_ERROR',
  type: 'DatabaseError'
});

logger.toolCallMetadata('tool-123', {
  executionTime: 350,
  apiEndpoint: '/api/v1/users',
  responseSize: 1024
});

logger.toolCallResult('tool-123', JSON.stringify({
  userId: '12345',
  name: 'John Doe',
  email: '[email protected]'
}));

const trace = logger.trace({
  id: 'query-trace-456',
  name: 'Document Analysis',
});

// Add input and output to the trace
trace.input('Analyze this contract document');
// ...Log other operations
trace.output('Contract analysis complete: 3 issues found');
trace.end();

logger.traceAddToSession('trace-123', 'session-456');

logger.traceEnd('trace-123');

const error = logger.traceError('trace-123', {
  id: 'error-001',
  message: 'Failed to process request',
  code: 'PROCESSING_ERROR',
  type: 'ProcessingError'
});

logger.traceEvaluate('trace-123')
  .withEvaluators('bias', 'toxicity')
  .withVariables({ context: 'user_query', expected: 'gold_standard' });

logger.traceEvent(
  'trace-123',
  'checkpoint-1',
  'Processing Milestone',
  { phase: 'preprocessing', status: 'complete' },
  { itemsProcessed: 1000, timeElapsed: 5.2 }
);

logger.traceFeedback('trace-123', {
  score: 4,
  comment: 'Good results but could be faster'
});

const generation = logger.traceGeneration('trace-123', {
  id: 'gen-001',
  provider: 'openai',
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Hello!' }],
  modelParameters: { temperature: 0.7 }
});

logger.traceInput('trace-123', 'Analyze customer sentiment from reviews');

logger.traceMetadata('trace-123', {
  requestId: 'req-456',
  userAgent: 'Mozilla/5.0...',
  processingTime: 1500
});

logger.traceOutput('trace-123', 'The analysis is complete: 95% confidence');

const retrieval = logger.traceRetrieval('trace-123', {
  id: 'retrieval-001',
  name: 'Knowledge Base Search'
});

const span = logger.traceSpan('trace-123', {
  id: 'span-001',
  name: 'Data Processing Phase'
});

logger.traceTag('trace-123', 'operation', 'analysis');
logger.traceTag('trace-123', 'priority', 'high');

const toolCall = logger.traceToolCall('trace-123', {
  id: 'tool-001',
  name: 'search_database',
  description: 'Search the product database',
  args: JSON.stringify({ query: 'laptop' })
});