import { BaseLLM, ChatParams } from '@memberjunction/ai';
import { MJGlobal } from '@memberjunction/global';

// Required to stop tree-shaking of the MistralLLM - since there's no static code path to this class when using Class Factory pattern, you need this to prevent some bundlers from tree-shaking optimization on this class.
import { LoadMistralLLM } from '@memberjunction/ai-mistral';
LoadMistralLLM(); 

// Get an implementation of BaseLLM by provider name
const llm = MJGlobal.Instance.ClassFactory.CreateInstance<BaseLLM>(
  BaseLLM, 
  'MistralLLM',  // Provider class name
  'your-api-key'
);

// Use the abstracted interface
const params: ChatParams = {
  model: 'mistral-large-latest',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'What is AI abstraction?' }
  ]
};

const result = await llm.ChatCompletion(params);

import { BaseLLM } from '@memberjunction/ai';
import { MJGlobal } from '@memberjunction/global';
import dotenv from 'dotenv';

// Required to stop tree-shaking of the OpenAILLM - since there's no static code path to this class when using Class Factory pattern, you need this to prevent some bundlers from tree-shaking optimization on this class.
import { LoadOpenAILLM } from '@memberjunction/ai-openai';
LoadOpenAILLM(); 

dotenv.config();

const providerName = process.env.AI_PROVIDER || 'OpenAILLM';
const apiKey = process.env.AI_API_KEY;

const llm = MJGlobal.Instance.ClassFactory.CreateInstance<BaseLLM>(
  BaseLLM, 
  providerName,
  apiKey
);

import { OpenAILLM } from '@memberjunction/ai-openai';

// Note with direct use of the OpenAILLM class no need for the LoadOpenAILLM call to prevent tree shaking since there is a static code path to the class
// Create an instance with your API key
const llm = new OpenAILLM('your-openai-api-key');

// Use the provider-specific implementation
const result = await llm.ChatCompletion({
  model: 'gpt-4',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'What is AI abstraction?' }
  ]
});

console.log(result.data.choices[0].message.content);

import { ChatParams, ChatResult, ChatMessage } from '@memberjunction/ai';

const params: ChatParams = {
  model: 'your-model-name',
  messages: [
    { role: 'system', content: 'System instruction' },
    { role: 'user', content: 'User message' },
    { role: 'assistant', content: 'Assistant response' }
  ],
  temperature: 0.7,
  maxOutputTokens: 1000
};

const result: ChatResult = await llm.ChatCompletion(params);

import { ChatParams, ChatResult, ChatMessage, StreamingChatCallbacks } from '@memberjunction/ai';

// Define the streaming callbacks
const callbacks: StreamingChatCallbacks = {
  // Called when a new chunk arrives
  OnContent: (chunk: string, isComplete: boolean) => {
    if (isComplete) {
      console.log("\nStream completed!");
    } else {
      // Print chunks as they arrive (or add to UI)
      process.stdout.write(chunk);
    }
  },
  
  // Called when the complete response is available
  OnComplete: (finalResponse: ChatResult) => {
    console.log("\nFull response:", finalResponse.data.choices[0].message.content);
    console.log("Total tokens:", finalResponse.data.usage.totalTokens);
  },
  
  // Called if an error occurs during streaming
  OnError: (error: any) => {
    console.error("Streaming error:", error);
  }
};

// Create streaming chat parameters
const params: ChatParams = {
  model: 'gpt-4',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Write a short poem about AI, one line at a time.' }
  ],
  streaming: true, // Enable streaming
  streamingCallbacks: callbacks
};

// The ChatCompletion API remains the same, but will stream results
await llm.ChatCompletion(params);

import { ChatParams, BaseLLM } from '@memberjunction/ai';

async function cancellableAIChat() {
  // Create the cancellation controller (the "boss")
  const controller = new AbortController();
  
  // Set up automatic timeout cancellation
  const timeout = setTimeout(() => {
    controller.abort(); // Cancel after 30 seconds
  }, 30000);

  try {
    const params: ChatParams = {
      model: 'gpt-4',
      messages: [
        { role: 'user', content: 'Write a very long story...' }
      ],
      cancellationToken: controller.signal // Pass the signal token
    };

    const result = await llm.ChatCompletion(params);
    clearTimeout(timeout); // Clear timeout if completed successfully
    return result;
    
  } catch (error) {
    if (error.message.includes('cancelled')) {
      console.log('Operation was cancelled');
    } else {
      console.error('Operation failed:', error);
    }
  }
}

class AIInterface {
  private currentController: AbortController | null = null;

  async startAIConversation() {
    // Create new controller for this conversation
    this.currentController = new AbortController();
    
    try {
      const result = await llm.ChatCompletion({
        model: 'gpt-4',
        messages: [{ role: 'user', content: 'Generate a detailed report...' }],
        cancellationToken: this.currentController.signal
      });
      
      console.log('AI Response:', result.data.choices[0].message.content);
    } catch (error) {
      if (error.message.includes('cancelled')) {
        console.log('User cancelled the conversation');
      }
    } finally {
      this.currentController = null;
    }
  }

  // Called when user clicks "Cancel" button
  cancelConversation() {
    if (this.currentController) {
      this.currentController.abort(); // Instant cancellation
    }
  }
}

async function smartAIExecution() {
  const controller = new AbortController();
  const signal = controller.signal;

  // 1. User cancel button
  document.getElementById('cancel')?.addEventListener('click', () => {
    controller.abort(); // User cancellation
  });

  // 2. Resource limit cancellation  
  if (await checkMemoryUsage() > MAX_MEMORY) {
    controller.abort(); // Resource limit cancellation
  }

  // 3. Window unload cancellation
  window.addEventListener('beforeunload', () => {
    controller.abort(); // Page closing cancellation
  });

  // 4. Timeout cancellation
  setTimeout(() => controller.abort(), 60000); // 1 minute timeout

  try {
    const result = await llm.ChatCompletion({
      model: 'gpt-4',
      messages: [{ role: 'user', content: 'Complex analysis task...' }],
      cancellationToken: signal // One token, many cancel sources!
    });
    
    return result;
  } catch (error) {
    // The AI operation doesn't know WHY it was cancelled - just that it should stop
    console.log('AI operation was cancelled:', error.message);
  }
}

// Internal implementation example (simplified)
async ChatCompletion(params: ChatParams): Promise<ChatResult> {
  // Check if already cancelled before starting
  if (params.cancellationToken?.aborted) {
    throw new Error('Operation was cancelled');
  }

  // For providers with native cancellation support
  if (this.hasNativeCancellation) {
    return await this.callProviderAPI({
      ...params,
      signal: params.cancellationToken // Native fetch cancellation
    });
  }

  // Fallback: Promise.race pattern for other providers
  const promises = [
    this.callProviderAPI(params) // The actual AI call
  ];

  if (params.cancellationToken) {
    promises.push(
      new Promise<never>((_, reject) => {
        params.cancellationToken!.addEventListener('abort', () => {
          reject(new Error('Operation was cancelled'));
        });
      })
    );
  }

  return await Promise.race(promises);
}

import { SummarizeParams, SummarizeResult } from '@memberjunction/ai';

const params: SummarizeParams = {
  text: 'Long text to summarize...',
  model: 'your-model-name',
  maxWords: 100
};

const result: SummarizeResult = await llm.SummarizeText(params);
console.log(result.summary);

import { ClassifyParams, ClassifyResult } from '@memberjunction/ai';

const params: ClassifyParams = {
  text: 'Text to classify',
  model: 'your-model-name',
  classes: ['Category1', 'Category2', 'Category3']
};

const result: ClassifyResult = await llm.ClassifyText(params);
console.log(result.classification);

const params: ChatParams = {
  // ...other parameters
  responseFormat: 'JSON',  // 'Any', 'Text', 'Markdown', 'JSON', or 'ModelSpecific'
};

// For provider-specific response formats
const customFormatParams: ChatParams = {
  // ...other parameters
  responseFormat: 'ModelSpecific',
  modelSpecificResponseFormat: {
    // Provider-specific format options
  }
};

const result = await llm.ChatCompletion(params);

if (!result.success) {
  console.error('Error:', result.errorMessage);
  console.error('Status Text:', result.statusText);
  console.error('Exception:', result.exception);
  console.error('Time Elapsed:', result.timeElapsed, 'ms');
} else {
  console.log('Success! Response time:', result.timeElapsed, 'ms');
}

const result = await llm.ChatCompletion(params);

if (!result.success && result.errorInfo) {
  const { errorInfo } = result;
  
  console.log(`Error Type: ${errorInfo.errorType}`);
  console.log(`HTTP Status: ${errorInfo.httpStatusCode}`);
  console.log(`Severity: ${errorInfo.severity}`);
  console.log(`Can Failover: ${errorInfo.canFailover}`);
  
  // Handle based on error type
  switch (errorInfo.errorType) {
    case 'RateLimit':
      // Wait and retry or switch providers
      const delay = errorInfo.suggestedRetryDelaySeconds || 30;
      console.log(`Rate limited. Retry after ${delay} seconds`);
      break;
      
    case 'Authentication':
      // Fatal error - check API keys
      console.error('Authentication failed. Check API key configuration.');
      break;
      
    case 'ServiceUnavailable':
      // Try another provider
      if (errorInfo.canFailover) {
        console.log('Service unavailable. Switching to backup provider...');
      }
      break;
  }
}

import { ErrorAnalyzer } from '@memberjunction/ai';

try {
  // Provider API call
} catch (error) {
  const errorInfo = ErrorAnalyzer.analyzeError(error, 'OpenAI');
  // errorInfo now contains structured error details
}

import { BaseLLM, ChatParams, AIErrorInfo } from '@memberjunction/ai';

class ResilientAIClient {
  private providers: Array<{ name: string; llm: BaseLLM }> = [];
  
  async chatWithFailover(params: ChatParams): Promise<ChatResult> {
    for (const provider of this.providers) {
      try {
        const result = await provider.llm.ChatCompletion(params);
        
        if (result.success) {
          return result;
        }
        
        // Check if we should try another provider
        if (result.errorInfo?.canFailover) {
          console.log(`Provider ${provider.name} failed. Trying next...`);
          continue;
        } else {
          // Fatal error - don't try other providers
          return result;
        }
        
      } catch (error) {
        console.error(`Provider ${provider.name} threw exception:`, error);
      }
    }
    
    throw new Error('All providers failed');
  }
}

async function retryWithBackoff(
  operation: () => Promise<ChatResult>,
  maxRetries: number = 3
): Promise<ChatResult> {
  let lastResult: ChatResult;
  
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    lastResult = await operation();
    
    if (lastResult.success) {
      return lastResult;
    }
    
    const errorInfo = lastResult.errorInfo;
    if (!errorInfo || errorInfo.severity === 'Fatal') {
      // Don't retry fatal errors
      return lastResult;
    }
    
    // Calculate delay
    const delay = errorInfo.suggestedRetryDelaySeconds ||
                  Math.pow(2, attempt - 1) * 1000; // Exponential backoff
    
    console.log(`Retry ${attempt}/${maxRetries} after ${delay}s...`);
    await new Promise(resolve => setTimeout(resolve, delay * 1000));
  }
  
  return lastResult!;
}

const result = await llm.ChatCompletion(params);
console.log('Prompt Tokens:', result.data.usage.promptTokens);
console.log('Completion Tokens:', result.data.usage.completionTokens);
console.log('Total Tokens:', result.data.usage.totalTokens);

// Import base model classes
import { BaseLLM, BaseEmbeddings, BaseAudioGenerator } from '@memberjunction/ai';

// Import result types
import { ChatResult, ModelUsage, BaseResult } from '@memberjunction/ai';

// Import parameter types
import { ChatParams, ChatMessage, StreamingChatCallbacks } from '@memberjunction/ai';

// Import utility classes
import { AIAPIKeys, GetAIAPIKey } from '@memberjunction/ai';

class BaseResult {
    success: boolean;
    startTime: Date;
    endTime: Date;
    errorMessage: string;
    exception: any;
    errorInfo?: AIErrorInfo; // Enhanced error details (v2.47.0+)
    timeElapsed: number; // Computed getter
}

// Enhanced error information structure
interface AIErrorInfo {
    httpStatusCode?: number;              // HTTP status code (429, 500, etc.)
    errorType: AIErrorType;               // Categorized error type
    severity: ErrorSeverity;              // Transient, Retriable, or Fatal
    suggestedRetryDelaySeconds?: number;  // Provider-suggested retry delay
    canFailover: boolean;                 // Whether switching providers might help
    providerErrorCode?: string;           // Original provider error code
    context?: Record<string, any>;        // Additional error context
}

class ChatResult extends BaseResult {
    data: {
        choices: Array<{
            message: ChatCompletionMessage;
            index: number;
            finishReason?: string;
        }>;
        usage: ModelUsage;
    };
    statusText?: string;
}

type ChatMessage = {
    role: 'system' | 'user' | 'assistant';
    content: string | ChatMessageContentBlock[];
}

type ChatMessageContentBlock = {
    type: 'text' | 'image_url' | 'video_url' | 'audio_url' | 'file_url';
    content: string; // URL or base64 encoded content
}

interface StreamingChatCallbacks {
    OnContent?: (chunk: string, isComplete: boolean) => void;
    OnComplete?: (finalResponse: ChatResult) => void;
    OnError?: (error: any) => void;
}

interface ParallelChatCompletionsCallbacks {
    OnCompletion?: (response: ChatResult, index: number) => void;
    OnError?: (error: any, index: number) => void;
    OnAllCompleted?: (responses: ChatResult[]) => void;
}

import { GetAIAPIKey } from '@memberjunction/ai';

// Get API key for a specific provider
const apiKey = GetAIAPIKey('OpenAI');

import { AIAPIKeys, RegisterClass } from '@memberjunction/ai';

@RegisterClass(AIAPIKeys, 'CustomAPIKeys', 2) // Priority 2 overrides default
export class CustomAPIKeys extends AIAPIKeys {
  public GetAPIKey(AIDriverName: string): string {
    // Your custom logic here
    // Could retrieve from database, vault, etc.
    return super.GetAPIKey(AIDriverName); // Fallback to default
  }
}

import { OpenAILLM } from '@memberjunction/ai-openai';

const llm = new OpenAILLM('sk-your-runtime-api-key');

import { BaseLLM } from '@memberjunction/ai';
import { MJGlobal } from '@memberjunction/global';

const llm = MJGlobal.Instance.ClassFactory.CreateInstance<BaseLLM>(
  BaseLLM,
  'OpenAILLM',
  'sk-your-runtime-api-key' // Runtime API key
);

export interface AIAPIKey {
  /**
   * The driver class name (e.g., 'OpenAILLM', 'AnthropicLLM', 'GroqLLM')
   * This should match the exact driver class name used by the AI provider
   */
  driverClass: string;
  
  /**
   * The API key value for the specified driver class
   */
  apiKey: string;
}

const llm = new SomeLLM('api-key');
llm.SetAdditionalSettings({
    baseURL: 'https://custom-endpoint.com',
    organization: 'my-org',
    // Provider-specific settings
});