import Ogg from '@discere-os/ogg.wasm'

const ogg = new Ogg()
await ogg.initialize()

console.log(`SIMD support: ${ogg.isSIMDAvailable()}`)

// Parse OGG file
const stats = await ogg.parseFile(oggData)
console.log(`Found ${stats.streamCount} streams, ${stats.totalPages} pages`)

ogg.cleanup()

interface OggOptions {
  simdOptimizations?: boolean  // Enable SIMD acceleration (default: true)
  maxMemoryMB?: number        // Memory limit (default: 64MB)
  debug?: boolean             // Debug logging (default: false)
}

class Ogg {
  constructor(options?: OggOptions)

  // Lifecycle
  async initialize(): Promise<void>
  isInitialized(): boolean
  cleanup(): void
  reset(): void

  // Data Processing
  feedData(data: Uint8Array): OggSyncResult
  extractPage(): OggPageResult
  initStream(serialno: number): boolean
  feedPageToStream(serialno: number, page: OggPage): boolean
  extractPacketFromStream(serialno: number): OggPacketResult

  // High-level Operations
  async parseFile(data: Uint8Array): Promise<OggStats>
  async validateFile(data: Uint8Array): Promise<OggValidationResult>

  // Performance
  isSIMDAvailable(): boolean
  getPerformanceMetrics(): OggPerformanceMetrics
}

interface OggPage {
  header: Uint8Array    // Page header data
  body: Uint8Array      // Page body data
  headerLen: number     // Header length
  bodyLen: number       // Body length
}

interface OggPacket {
  packet: Uint8Array    // Packet data
  bytes: number         // Packet length
  bos: boolean          // Beginning of stream
  eos: boolean          // End of stream
  granulepos: bigint    // Granule position
  packetno: number      // Packet sequence number
}

interface OggStats {
  fileSize: number      // Total file size
  streamCount: number   // Number of streams
  totalPages: number    // Total pages processed
  totalPackets: number  // Total packets extracted
  processingTime: number // Processing time in ms
  throughput: number    // Processing speed in MB/s
  simdUsed: boolean     // Whether SIMD was used
}

import Ogg from '@discere-os/ogg.wasm'

async function parseOggFile(oggData: Uint8Array) {
  const ogg = new Ogg({ simdOptimizations: true })
  await ogg.initialize()

  // Parse entire file
  const stats = await ogg.parseFile(oggData)

  console.log(`File: ${stats.fileSize} bytes`)
  console.log(`Streams: ${stats.streamCount}`)
  console.log(`Pages: ${stats.totalPages}`)
  console.log(`Packets: ${stats.totalPackets}`)
  console.log(`Speed: ${stats.throughput.toFixed(1)} MB/s`)

  ogg.cleanup()
  return stats
}

import Ogg from '@discere-os/ogg.wasm'

async function processOggStream(oggData: Uint8Array) {
  const ogg = new Ogg()
  await ogg.initialize()

  // Feed data
  const feedResult = ogg.feedData(oggData)
  if (!feedResult.success) {
    throw new Error(`Feed failed: ${feedResult.error}`)
  }

  // Extract pages
  while (true) {
    const pageResult = ogg.extractPage()
    if (!pageResult.success) break

    if (pageResult.bos) {
      console.log(`New stream: ${pageResult.serialno}`)
      ogg.initStream(pageResult.serialno!)
    }

    // Process packets from this page
    if (pageResult.page && pageResult.serialno) {
      ogg.feedPageToStream(pageResult.serialno, pageResult.page)

      while (true) {
        const packet = ogg.extractPacketFromStream(pageResult.serialno)
        if (!packet.success) break

        console.log(`Packet: ${packet.packet!.bytes} bytes`)

        if (packet.packet!.eos) {
          console.log(`Stream ${pageResult.serialno} ended`)
        }
      }
    }
  }

  ogg.cleanup()
}

import Ogg from '@discere-os/ogg.wasm'

async function validateOggFile(oggData: Uint8Array) {
  const ogg = new Ogg()
  await ogg.initialize()

  const result = await ogg.validateFile(oggData)

  console.log(`Valid OGG: ${result.isValid}`)
  console.log(`Streams: ${result.formatDetails.streams}`)
  console.log(`Pages: ${result.formatDetails.pages}`)

  if (result.errors.length > 0) {
    console.log('Errors:')
    result.errors.forEach(error => console.log(`  • ${error}`))
  }

  if (result.warnings.length > 0) {
    console.log('Warnings:')
    result.warnings.forEach(warning => console.log(`  • ${warning}`))
  }

  ogg.cleanup()
  return result
}