import { TTVService, GoogleVeoProvider, TTVProvider } from '@loonylabs/ttv-middleware';

const service = new TTVService();
service.registerProvider(new GoogleVeoProvider({
  projectId: process.env.GOOGLE_CLOUD_PROJECT,
  location: 'us-central1',
}));

const result = await service.generate({
  prompt: 'A cinematic aerial shot of a mountain range at sunrise',
  model: 'veo-3.0-generate-001',
  duration: 8,
  aspectRatio: '16:9',
  resolution: '1080p',
  generateAudio: true,  // Veo 3+ generates audio natively
});

console.log('Video URL:', result.videos[0].url);

const result = await service.generate({
  prompt: 'A futuristic city with flying cars',
  model: 'sora-2',
  duration: 12,
  onProgress: (progress) => {
    console.log(`Status: ${progress.status}`, progress.message || '');
    // Status: queued
    // Status: in_progress
    // Status: completed
  },
});

import * as fs from 'fs';

const result = await service.generate({
  prompt: 'Ocean waves crashing on a rocky shore',
  model: 'sora-2',
  downloadToBuffer: true,  // Download video into memory
});

// Save to disk
fs.writeFileSync('output.mp4', result.videos[0].buffer!);

// Use OpenAI Sora
const soraResult = await service.generate({
  prompt: 'A mountain landscape timelapse',
  model: 'sora-2',
}, TTVProvider.OPENAI_SORA);

// Use Google Veo
const veoResult = await service.generate({
  prompt: 'A mountain landscape timelapse',
  model: 'veo-3.0-generate-001',
}, TTVProvider.GOOGLE_VEO);

import { GoogleVeoProvider } from '@loonylabs/ttv-middleware';

const provider = new GoogleVeoProvider({
  projectId: 'my-project',
  polling: {
    intervalMs: 10000,       // Start polling every 10s (default)
    maxIntervalMs: 30000,    // Cap at 30s between polls
    backoffMultiplier: 1.5,  // Increase interval by 1.5x each time
    timeoutMs: 600000,       // Give up after 10 minutes (default)
  },
});

// Default: 3 retries, exponential backoff (1s -> 2s -> 4s), jitter enabled
const result = await service.generate({
  prompt: 'A sunset over mountains',
  // retry: true (default)
});

// Custom retry configuration
const result = await service.generate({
  prompt: 'A sunset over mountains',
  retry: {
    maxRetries: 5,
    delayMs: 1000,
    backoffMultiplier: 2.0,
    maxDelayMs: 30000,
    jitter: true,
  },
});

// Disable retry
const result = await service.generate({
  prompt: 'A sunset over mountains',
  retry: false,
});

import { setLogLevel } from '@loonylabs/ttv-middleware';

// Set log level programmatically
setLogLevel('warn');  // Only show warnings and errors

// Or via environment variable
// TTV_LOG_LEVEL=error

import { TTVDebugger } from '@loonylabs/ttv-middleware';

// Enable via environment variable
// DEBUG_TTV_REQUESTS=true

// Or programmatically
TTVDebugger.setEnabled(true);
TTVDebugger.setLogsDir('./logs/ttv/requests');

TTVDebugger.configure({
  enabled: true,
  logsDir: './logs/ttv/requests',
  consoleLog: true,
});

import {
  TTVError,
  InvalidConfigError,
  QuotaExceededError,
  ProviderUnavailableError,
  GenerationFailedError,
  NetworkError,
  CapabilityNotSupportedError,
  PollingTimeoutError,
  ContentModeratedError,
} from '@loonylabs/ttv-middleware';

try {
  const result = await service.generate({ prompt: 'test', duration: 8 });
} catch (error) {
  if (error instanceof PollingTimeoutError) {
    console.log('Video generation timed out - try again or increase timeout');
  } else if (error instanceof ContentModeratedError) {
    console.log('Content was blocked by safety filters');
  } else if (error instanceof QuotaExceededError) {
    console.log('Rate limit hit, try again later');
  } else if (error instanceof CapabilityNotSupportedError) {
    console.log('Model does not support this feature');
  } else if (error instanceof TTVError) {
    console.log(`TTV Error [${error.code}]: ${error.message}`);
  }
}

const result = await service.generate({
  prompt: 'A test video',
  duration: 8,
  dry: true,  // No API call, returns placeholder response
});

console.log(result.videos.length);       // 1
console.log(result.metadata.duration);   // 0 (no actual generation)

// Google Veo: seed for deterministic output
const result = await service.generate({
  prompt: 'A sunset timelapse',
  model: 'veo-3.0-generate-001',
  providerOptions: {
    seed: 42,
    personGeneration: 'allow_adult',
    enhancePrompt: true,
    storageUri: 'gs://my-bucket/output/',  // Direct output to GCS
  },
}, TTVProvider.GOOGLE_VEO);

// OpenAI Sora: remix (reinterpret an existing video)
// Use the Sora API directly for remix via providerOptions