import { createClient } from '@dotdo/client'

// Define your DO methods and events
interface MyMethods {
  getUser(id: string): { name: string; email: string }
  updateUser(id: string, data: { name: string }): void
  getOrders(userId: string): Order[]
}

interface MyEvents {
  userUpdated: { id: string; name: string }
  orderCreated: Order
}

// Create a type-safe client
const client = createClient<MyMethods, MyEvents>('https://api.example.com.ai')

// Make RPC calls
const user = await client.getUser('123')
console.log(user.name)

// Chain methods with promise pipelining
const orders = await client.getUser('123').getOrders()

const client = createClient<MyMethods, MyEvents>(url, {
  // Request timeout in milliseconds (default: 30000)
  timeout: 30000,

  // Enable request batching (default: true)
  batching: true,

  // Batch window in milliseconds (default: 0 - batch on microtask)
  batchWindow: 10,

  // Maximum requests per batch (default: 100)
  maxBatchSize: 100,

  // Maximum queued requests when offline (default: 1000)
  offlineQueueLimit: 1000,

  // Reconnection settings
  reconnect: {
    maxAttempts: Infinity,  // Keep trying forever
    baseDelay: 1000,        // Start with 1 second
    maxDelay: 30000,        // Cap at 30 seconds
    jitter: 0.1,            // 10% randomization
  },

  // Authentication
  auth: {
    token: 'your-auth-token',
  },
})

client.on('connectionStateChange', (state) => {
  // 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'failed'
  console.log('Connection:', state)
})

// Check current state
console.log(client.connectionState)

// These execute as one request, not three
const result = await client
  .getUser('123')
  .getProfile()
  .getSettings()

// These three calls are sent as a single batch
const [user, orders, settings] = await Promise.all([
  client.getUser('123'),
  client.getOrders('123'),
  client.getSettings('123'),
])

const subscription = client.subscribe('userUpdated', (data) => {
  console.log('User updated:', data.id, data.name)
})

// Later, unsubscribe
subscription.unsubscribe()

// Monitor queue changes
client.on('queueChange', (count) => {
  console.log('Queued requests:', count)
})

// Check queue size
console.log(client.queuedCallCount)

// Clear the queue if needed
client.clearQueue()

interface TaskMethods {
  create(task: { title: string; done: boolean }): Task
  get(id: string): Task | null
  list(filter?: { done?: boolean }): Task[]
  update(id: string, data: Partial<Task>): Task
  delete(id: string): void
}

interface TaskEvents {
  taskCreated: Task
  taskUpdated: Task
  taskDeleted: { id: string }
}

const client = createClient<TaskMethods, TaskEvents>(url)

// Full autocomplete and type checking
const task = await client.create({ title: 'Hello', done: false })
//    ^? Task

client.subscribe('taskCreated', (task) => {
  //                             ^? Task
})

// Connection state changes
client.on('connectionStateChange', (state) => { ... })

// Queue size changes
client.on('queueChange', (count) => { ... })

// Connection closed
client.on('close', (reason) => { ... })

// Errors
client.on('error', (error) => { ... })

// Remove listener
client.off('connectionStateChange', handler)