import 'package:runanywhere/runanywhere.dart';

static Future<void> initialize({
  String? apiKey,
  String? baseURL,
  SDKEnvironment environment = SDKEnvironment.development,
})

// Development mode (no API key needed)
await RunAnywhere.initialize();

// Production mode
await RunAnywhere.initialize(
  apiKey: 'your-api-key',
  baseURL: 'https://api.runanywhere.ai',
  environment: SDKEnvironment.production,
);

static Future<List<ModelInfo>> availableModels()

final models = await RunAnywhere.availableModels();
for (final model in models) {
  print('${model.name}: ${model.isDownloaded ? "Downloaded" : "Not downloaded"}');
}

static ModelInfo registerModel({
  String? id,
  required String name,
  required Uri url,
  required InferenceFramework framework,
  ModelCategory modality = ModelCategory.language,
  ModelArtifactType? artifactType,
  int? memoryRequirement,
  bool supportsThinking = false,
})

RunAnywhere.registerModel(
  id: 'my-model',
  name: 'My Custom Model',
  url: Uri.parse('https://example.com/model.gguf'),
  framework: InferenceFramework.llamaCpp,
  memoryRequirement: 500000000,
);

static Stream<DownloadProgress> downloadModel(String modelId)

await for (final progress in RunAnywhere.downloadModel('my-model')) {
  print('Progress: ${(progress.percentage * 100).toStringAsFixed(1)}%');
  if (progress.state.isCompleted) break;
}

static Future<void> loadModel(String modelId)

await RunAnywhere.loadModel('smollm2-360m-q8_0');
print('Model loaded: ${RunAnywhere.isModelLoaded}');

static Future<void> unloadModel()

static Future<void> deleteStoredModel(String modelId)

static Future<String> chat(String prompt)

final response = await RunAnywhere.chat('Hello, how are you?');
print(response);

static Future<LLMGenerationResult> generate(
  String prompt, {
  LLMGenerationOptions? options,
})

final result = await RunAnywhere.generate(
  'Explain quantum computing in simple terms',
  options: LLMGenerationOptions(maxTokens: 200, temperature: 0.7),
);
print('Response: ${result.text}');
print('Tokens: ${result.tokensUsed}');
print('Latency: ${result.latencyMs}ms');

static Future<LLMStreamingResult> generateStream(
  String prompt, {
  LLMGenerationOptions? options,
})

final result = await RunAnywhere.generateStream('Tell me a story');

// Consume tokens as they arrive
await for (final token in result.stream) {
  stdout.write(token);  // Real-time output
}

// Get final metrics
final metrics = await result.result;
print('\nTokens: ${metrics.tokensUsed}');

// Or cancel early if needed
// result.cancel();

static Future<void> cancelGeneration()

static Future<void> loadSTTModel(String modelId)

static Future<void> unloadSTTModel()

static Future<String> transcribe(Uint8List audioData)

final text = await RunAnywhere.transcribe(audioBytes);
print('Transcription: $text');

static Future<STTResult> transcribeWithResult(Uint8List audioData)

final result = await RunAnywhere.transcribeWithResult(audioBytes);
print('Text: ${result.text}');
print('Confidence: ${result.confidence}');
print('Language: ${result.language}');

static Future<void> loadTTSVoice(String voiceId)

static Future<void> unloadTTSVoice()

static Future<TTSResult> synthesize(
  String text, {
  double rate = 1.0,
  double pitch = 1.0,
  double volume = 1.0,
})

final result = await RunAnywhere.synthesize('Hello world');
print('Samples: ${result.samples.length}');
print('Sample rate: ${result.sampleRate} Hz');
print('Duration: ${result.durationSeconds}s');

static Future<VoiceSessionHandle> startVoiceSession({
  VoiceSessionConfig config = VoiceSessionConfig.defaultConfig,
})

final session = await RunAnywhere.startVoiceSession();

session.events.listen((event) {
  if (event is VoiceSessionListening) {
    print('Audio level: ${event.audioLevel}');
  } else if (event is VoiceSessionTranscribed) {
    print('User said: ${event.text}');
  } else if (event is VoiceSessionResponded) {
    print('AI response: ${event.text}');
  } else if (event is VoiceSessionTurnCompleted) {
    print('Turn completed');
  }
});

// Later...
session.stop();

static VoiceAgentComponentStates getVoiceAgentComponentStates()

static void cleanupVoiceAgent()

static Future<StorageInfo> getStorageInfo()

static Future<List<StoredModel>> getDownloadedModelsWithInfo()

static void reset()

enum ModelCategory {
  language,           // Language Model (LLM)
  speechRecognition,  // Speech-to-Text
  speechSynthesis,    // Text-to-Speech
  vision,             // Vision Model
  imageGeneration,    // Image Generation
  multimodal,         // Multimodal
  audio,              // Audio Processing
}

enum ModelFormat {
  onnx,    // ONNX format
  ort,     // ONNX Runtime format
  gguf,    // GGUF format (llama.cpp)
  bin,     // Binary format
  unknown,
}

enum InferenceFramework {
  onnx,              // ONNX Runtime
  llamaCpp,          // llama.cpp
  foundationModels,  // Foundation Models
  systemTTS,         // System TTS
  fluidAudio,        // FluidAudio
  builtIn,           // Built-in
  none,
  unknown,
}

class LLMGenerationOptions {
  final int maxTokens;          // Maximum tokens to generate (default: 100)
  final double temperature;     // Randomness (default: 0.8)
  final double topP;           // Nucleus sampling (default: 1.0)
  final List<String> stopSequences;  // Stop sequences
  final bool streamingEnabled;  // Enable streaming
  final InferenceFramework? preferredFramework;
  final String? systemPrompt;   // System prompt
}

const options = LLMGenerationOptions(
  maxTokens: 200,
  temperature: 0.7,
  systemPrompt: 'You are a helpful assistant.',
);

enum DownloadProgressState {
  downloading,  // Currently downloading
  completed,    // Download completed
  failed,       // Download failed
  cancelled,    // Download cancelled
}

Future<void> start()

void stop()

Future<void> sendNow()

void feedAudio(Uint8List data, double audioLevel)

Future<void> dispose()

class VoiceSessionConfig {
  final double silenceDuration;   // Seconds before processing (default: 1.5)
  final double speechThreshold;   // Audio level threshold (default: 0.03)
  final bool autoPlayTTS;         // Auto-play TTS response (default: true)
  final bool continuousMode;      // Resume listening after TTS (default: true)
}

final config = VoiceSessionConfig(
  silenceDuration: 2.0,      // Wait 2 seconds of silence
  speechThreshold: 0.1,      // Higher threshold for noisy environments
  autoPlayTTS: true,
  continuousMode: true,
);

final session = await RunAnywhere.startVoiceSession(config: config);

session.events.listen((event) {
  switch (event) {
    case VoiceSessionListening(:final audioLevel):
      updateMeter(audioLevel);
    case VoiceSessionTranscribed(:final text):
      showUserText(text);
    case VoiceSessionResponded(:final text):
      showAssistantText(text);
    case VoiceSessionTurnCompleted(:final transcript, :final response):
      addToHistory(transcript, response);
    case VoiceSessionError(:final message):
      showError(message);
    default:
      break;
  }
});

final events = RunAnywhere.events;

RunAnywhere.events.allEvents.listen((event) {
  print('Event: ${event.type}');
});

RunAnywhere.events.modelEvents.listen((event) {
  if (event is SDKModelLoadCompleted) {
    print('Model loaded: ${event.modelId}');
  }
});

try {
  await RunAnywhere.loadModel('nonexistent');
} on SDKError catch (e) {
  print('Error: ${e.message}');
  print('Code: ${e.code}');
}

import 'package:runanywhere_llamacpp/runanywhere_llamacpp.dart';

static Future<void> register({int priority = 100})

static void addModel({
  required String id,
  required String name,
  required String url,
  int memoryRequirement = 0,
  bool supportsThinking = false,
})

await LlamaCpp.register();

LlamaCpp.addModel(
  id: 'smollm2-360m-q8_0',
  name: 'SmolLM2 360M Q8_0',
  url: 'https://huggingface.co/.../SmolLM2-360M.Q8_0.gguf',
  memoryRequirement: 500000000,
);

import 'package:runanywhere_onnx/runanywhere_onnx.dart';

static Future<void> register({int priority = 100})

static void addModel({
  required String id,
  required String name,
  required String url,
  required ModelCategory modality,
  int memoryRequirement = 0,
})

await Onnx.register();

// Add STT model
Onnx.addModel(
  id: 'sherpa-onnx-whisper-tiny.en',
  name: 'Whisper Tiny English',
  url: 'https://github.com/.../sherpa-onnx-whisper-tiny.en.tar.gz',
  modality: ModelCategory.speechRecognition,
  memoryRequirement: 75000000,
);

// Add TTS model
Onnx.addModel(
  id: 'vits-piper-en_US-amy-medium',
  name: 'Piper Amy (English)',
  url: 'https://github.com/.../vits-piper-en_US-amy-medium.tar.gz',
  modality: ModelCategory.speechSynthesis,
  memoryRequirement: 50000000,
);

enum SDKEnvironment {
  development,  // Development mode (no API key needed)
  staging,      // Staging environment
  production,   // Production environment
}

import 'package:runanywhere/runanywhere.dart';
import 'package:runanywhere_llamacpp/runanywhere_llamacpp.dart';
import 'package:runanywhere_onnx/runanywhere_onnx.dart';

Future<void> main() async {
  // 1. Initialize SDK
  await RunAnywhere.initialize();

  // 2. Register backends
  await LlamaCpp.register();
  await Onnx.register();

  // 3. Add models
  LlamaCpp.addModel(
    id: 'smollm2',
    name: 'SmolLM2 360M',
    url: 'https://huggingface.co/.../SmolLM2-360M.Q8_0.gguf',
    memoryRequirement: 500000000,
  );

  Onnx.addModel(
    id: 'whisper-tiny',
    name: 'Whisper Tiny',
    url: 'https://github.com/.../sherpa-onnx-whisper-tiny.en.tar.gz',
    modality: ModelCategory.speechRecognition,
    memoryRequirement: 75000000,
  );

  Onnx.addModel(
    id: 'piper-amy',
    name: 'Piper Amy',
    url: 'https://github.com/.../vits-piper-en_US-amy-medium.tar.gz',
    modality: ModelCategory.speechSynthesis,
    memoryRequirement: 50000000,
  );

  // 4. Download models
  await for (final p in RunAnywhere.downloadModel('smollm2')) {
    print('LLM: ${(p.percentage * 100).toStringAsFixed(1)}%');
    if (p.state.isCompleted) break;
  }

  await for (final p in RunAnywhere.downloadModel('whisper-tiny')) {
    print('STT: ${(p.percentage * 100).toStringAsFixed(1)}%');
    if (p.state.isCompleted) break;
  }

  await for (final p in RunAnywhere.downloadModel('piper-amy')) {
    print('TTS: ${(p.percentage * 100).toStringAsFixed(1)}%');
    if (p.state.isCompleted) break;
  }

  // 5. Load models
  await RunAnywhere.loadModel('smollm2');
  await RunAnywhere.loadSTTModel('whisper-tiny');
  await RunAnywhere.loadTTSVoice('piper-amy');

  // 6. Use LLM
  final response = await RunAnywhere.chat('Hello!');
  print('AI: $response');

  // 7. Use Voice Agent
  if (RunAnywhere.isVoiceAgentReady) {
    final session = await RunAnywhere.startVoiceSession();

    session.events.listen((event) {
      if (event is VoiceSessionTurnCompleted) {
        print('User: ${event.transcript}');
        print('AI: ${event.response}');
      }
    });

    // Run for a while...
    await Future.delayed(Duration(seconds: 30));
    session.stop();
  }
}