import {cyre} from 'cyre'

// 1. Create channel with default payload
cyre.action({id: 'user-login', payload: {status: 'idle'}})

// 2. Subscribe to the channel by it's id
cyre.on('user-login', payload => {
  console.log('User login:', payload)
  return {success: true, timestamp: Date.now()}
})

// 3. send to channel
await cyre.call('user-login', {userId: 123, email: 'user@example.com'})

// Create channels with built-in protections
cyre.action({
  id: 'api-call',
  throttle: 1000, // Rate limiting
  debounce: 300, // Call collapsing
  detectChanges: true, // Skip unchanged payloads
  priority: {level: 'high'}
})

cyre.on('api-call', async payload => {
  const result = await fetch('/api/data', {
    method: 'POST',
    body: JSON.stringify(payload)
  })
  return await result.json()
})

// Calls are automatically protected
await cyre.call('api-call', {query: 'search terms'})

// Precise timing control
cyre.action({
  id: 'health-check',
  delay: 1000, // Initial delay
  interval: 5000, // Repeat interval
  repeat: 10 // Total executions
})

// Timeline: Wait 1s → Execute → Wait 5s → Execute → ... (10 total)

// Automatic chain reactions
cyre.on('validate-data', payload => {
  const isValid = validate(payload)

  // Return IntraLink to trigger next action
  return {
    id: isValid ? 'process-data' : 'handle-error',
    payload: {...payload, isValid}
  }
})

cyre.on('process-data', payload => {
  // Processing logic
  return {processed: true, result: payload}
})

import {useCyre} from 'cyre'

function UserProfile() {
  const userChannel = useCyre({
    name: 'user-profile',
    protection: {
      debounce: 300,
      detectChanges: true
    },
    initialPayload: {userId: null}
  })

  React.useEffect(() => {
    const subscription = userChannel.on(userData => {
      console.log('User updated:', userData)
      return {handled: true}
    })

    return () => subscription.unsubscribe()
  }, [])

  const updateUser = userData => {
    userChannel.call(userData)
  }

  return (
    <button onClick={() => updateUser({id: 123, name: 'John'})}>
      Update User
    </button>
  )
}

cyre.action({
  id: 'batch-upload',
  buffer: {window: 1000, strategy: 'append', maxSize: 10}
})

cyre.on('batch-upload', batch => {
  // batch is an array of payloads collected within 1s or up to 10 items
  uploadBatchToServer(batch)
})

// Calls within 1s are batched
cyre.call('batch-upload', {file: 'a.txt'})
cyre.call('batch-upload', {file: 'b.txt'})

cyre.action({
  id: 'multi-handler',
  dispatch: 'race' // Only the fastest handler result is used
})

cyre.on('multi-handler', async payload => {
  await delay(100)
  return 'slow handler'
})
cyre.on('multi-handler', async payload => {
  await delay(10)
  return 'fast handler'
})

const result = await cyre.call('multi-handler', {data: 1})
// result.payload === 'fast handler'

// Waterfall example
cyre.action({
  id: 'waterfall-demo',
  dispatch: 'waterfall'
})
cyre.on('waterfall-demo', payload => payload + 1)
cyre.on('waterfall-demo', payload => payload * 2)
const res = await cyre.call('waterfall-demo', 3) // (3+1)*2 = 8

const handler = payload => doSomething(payload)
cyre.on('removable', handler)
// ...
cyre.removeHandler('removable', handler) // Removes the handler
const stats = cyre.getHandlerStats('removable')
console.log(stats.handlerCount) // 0 if removed

cyre.action({id: 'user-update', payload: {name: 'Alice'}})

// Get current payload
const current = cyre.payloadState.get('user-update')
// Set new payload
cyre.payloadState.set('user-update', {name: 'Bob'})
// Check if changed
const changed = cyre.payloadState.hasChanged('user-update', {name: 'Bob'})

cyre.action({id: 'step1'})
cyre.action({id: 'step2'})

cyre.on('step1', payload => {
  // ...
  return {id: 'step2', payload: {...payload, step1: true}}
})

// Orchestrate a workflow
await cyre.call('step1', {start: true})

// Register multiple handlers for the same channel
cyre.on('user-login', payload => {
  // Handler 1
  logLogin(payload)
})

cyre.on('user-login', async payload => {
  // Handler 2 (async)
  await sendAnalytics(payload)
})

// By default, async handlers run in parallel. For sequential execution:
cyre.action({
  id: 'user-login',
  sequential: true // Ensures handlers run one after another
})

// Factory handler (pure)
cyre.on('data-validate', payload => validateData(payload))

// Outpost handler (side effect)
cyre.on('data-validate', payload => {
  reportValidation(payload)
  // No return needed
})

import {createStream} from 'cyre'

const stream = createStream()
  .buffer(5) // Collects 5 events before emitting as an array
  .map(batch => processBatch(batch))

stream.subscribe(batchResult => {
  // Handle processed batch
})

// Emit events
stream.next(event1)
stream.next(event2)
// ...

cyre.action({
  id: 'api-request',
  throttle: 1000 // Max 1 request per second
})

// Automatic rate limiting - excess calls rejected gracefully

cyre.action({
  id: 'search-input',
  debounce: 300 // Collapse rapid calls to single execution
})

// 90% call collapsing efficiency with perfect timing accuracy

cyre.action({
  id: 'state-update',
  detectChanges: true // Skip execution if payload unchanged
})

// Automatic payload comparison using deep equality

// Channel-specific metrics
const actionMetrics = cyre.getMetrics()

// Enable debug mode for detailed logging
cyre.action({
  id: 'debug-action',
  log: true // Enable detailed execution logging
})

// Get system health status
const isHealthy = cyre.isHealthy()
const breathingState = cyre.getBreathingState()

// Channel management
cyre.action(config: IO | IO[])           // Register one or more channels
cyre.on(id: string, handler: Function)   // Subscribe handler(s) to a channel
cyre.call(id: string, payload?: any)     // Trigger a channel/action
cyre.forget(id: string)                  // Remove a channel and its handlers
cyre.get(id: string)                     // Get the current channel payload by id. will include {req,res}

// System & State Control
cyre.init()                              // Initialize the system
cyre.clear()                             // Clear all channels, handlers, and state
cyre.reset()                             // Alias for clear, resets all state
cyre.pause(id?: string)                  // Pause all or specific channels
cyre.resume(id?: string)                 // Resume all or specific channels
cyre.lock()               // Lock/unlock the system
cyre.shutdown()                          // Full system shutdown

// Metrics & Monitoring
cyre.getMetrics(channelId?: string)      // Get system or channel-specific metrics
cyre.status()                           // Returns if system is hibernating

// Advanced/Experimental
// cyre.payloadState                       // Direct access to dual payload state system
// cyre.orchestration                      // Orchestration engine for complex workflows
// cyre.schedule                           // Scheduling utility for advanced timing
// cyre.path()                             // Path system for hierarchical channel addressing (stub)

import {useCyre, useGroup, useBranch, useCollective, log} from 'cyre'

interface IO {
  id: string // Channel identifier (required)
  payload?: any // Initial/default payload
  path?: string // Hierarchical path for organization
  group?: string
  tags?: string[]
  description?: string
  version?: string

  // Protections
  required?: boolean
  throttle?: number
  debounce?: number
  maxWait?: number
  detectChanges?: boolean
  block?: boolean
  buffer?: { window: number, strategy?: 'overwrite' | 'append' | 'ignore', maxSize?: number }

  // Scheduling
  interval?: number
  repeat?: number | boolean
  delay?: number

  // Execution
  dispatch?: 'single' | 'parallel' | 'sequential' | 'race' | 'waterfall'
  errorStrategy?: 'fail-fast' | 'continue' | 'retry'
  collectResults?: 'first' | 'last' | 'all' | boolean
  dispatchTimeout?: number

  // Pipeline
  schema?: Schema<any>
  condition?: (payload: any) => boolean
  selector?: (payload: any) => any
  transform?: (payload: any) => any

  // Priority
  priority?: { level: string, ... }

  // Auth
  auth?: { mode: 'token' | 'context' | 'group' | 'disabled', ... }

  // Logging
  log?: boolean
}

// Rate-limited API with automatic retry
cyre.action({
  id: 'api-with-retry',
  throttle: 100, // 10 requests/sec max
  repeat: 3, // Retry up to 3 times
  priority: {level: 'high'}
})

// Stream processing with backpressure
const dataStream = createStream()
  .throttle(16) // 60fps processing rate
  .map(processRealTimeData)
  .filter(data => data.isComplete)
  .subscribe(updateUI)

// Multi-step workflow with error handling
const workflow = cyreCompose(
  [validationChannel, authenticationChannel, processingChannel, auditChannel],
  {
    continueOnError: false,
    timeout: 30000
  }
)