import { createCallStateMachine } from '@/lib/calls'

const machine = createCallStateMachine({
  initialState: 'idle',
  onTransition: (event) => {
    console.log(`${event.from} -> ${event.to}`)
  },
})

// Transition states
machine.transition('initiating')
machine.transition('ringing')
machine.transition('connected')

// Check state
if (machine.isState('connected')) {
  console.log('Call is active')
}

// Get durations
const totalDuration = machine.getTotalDuration()
const connectedDuration = machine.getConnectedDuration()

import { createInvitationManager } from '@/lib/calls'

const manager = createInvitationManager({
  ringToneUrl: '/sounds/ringtone.mp3',
  ringVolume: 0.8,
  timeout: 30000, // 30 seconds
  onInvitation: (invitation) => {
    console.log('Incoming call from', invitation.callerName)
  },
})

// Create invitation
const invitation = manager.createInvitation('call-123', 'user-456', 'Alice Smith', 'video', {
  callerAvatarUrl: '/avatars/alice.jpg',
})

// Accept/decline
manager.acceptInvitation(invitation.id)
manager.declineInvitation(invitation.id)

// Cleanup
manager.cleanup()

import { createStatusManager } from '@/lib/calls'

const manager = createStatusManager({
  awayTimeout: 5 * 60 * 1000, // 5 minutes
  enableCallWaiting: true,
  maxConcurrentCalls: 1,
})

// Initialize user
manager.initializeUser('user-123', 'online')

// Update status
manager.setStatus('user-123', 'dnd', 'In a meeting')

// Check availability
if (manager.isAvailable('user-123')) {
  console.log('User can receive calls')
} else {
  const reason = manager.getUnavailabilityReason('user-123')
  console.log(reason) // "User is in Do Not Disturb mode"
}

// Mark in call
manager.startCall('user-123', 'call-456')
manager.endCall('user-123')

// Update activity (prevents auto-away)
manager.updateActivity('user-123')

import { createQualityMonitor } from '@/lib/calls'

const monitor = createQualityMonitor({
  interval: 2000, // 2 seconds
  enableAlerts: true,
  onMetrics: (metrics) => {
    console.log('Quality:', metrics.overallQuality)
    console.log('Audio bitrate:', metrics.audioReceiveBitrate)
    console.log('Packet loss:', metrics.audioPacketLoss)
  },
  onAlert: (alert) => {
    console.warn(alert.message)
    alert.suggestions.forEach((s) => console.log('-', s))
  },
})

// Start monitoring
monitor.start(peerConnection)

// Get current quality
const quality = monitor.getQuality() // 'excellent' | 'good' | ...
const metrics = monitor.getMetrics()

// Stop monitoring
monitor.stop()

import { getCallEventEmitter, subscribeToCallEvents } from '@/lib/calls'

// Get global emitter
const emitter = getCallEventEmitter()

// Subscribe to specific event
emitter.onCallEvent('call:connected', (event) => {
  console.log('Call connected:', event.callId)
})

// Subscribe to multiple events
const cleanup = subscribeToCallEvents({
  'call:created': (event) => console.log('Created'),
  'call:ended': (event) => console.log('Ended'),
  'call:quality-changed': (event) => {
    console.log(`Quality: ${event.from} -> ${event.to}`)
  },
})

// Cleanup
cleanup()

// Listen to all events
emitter.onAnyEvent((event) => {
  console.log(event.type, event)
})

// Get event history
const history = emitter.getHistory({ callId: 'call-123' })

import { useCallState } from '@/hooks/use-call-state'

function CallComponent() {
  const {
    state,
    isConnected,
    displayName,
    connectedDuration,
    transition,
    canTransitionTo,
  } = useCallState({
    initialState: 'idle',
    autoLog: true
  })

  const handleConnect = () => {
    if (canTransitionTo('connected')) {
      transition('connected')
    }
  }

  return (
    <div>
      <p>State: {displayName}</p>
      {isConnected && <p>Duration: {connectedDuration}ms</p>}
    </div>
  )
}

import { useCallInvitation } from '@/hooks/use-call-invitation'

function IncomingCallsComponent() {
  const {
    activeInvitations,
    hasInvitations,
    isRinging,
    accept,
    decline,
  } = useCallInvitation({
    ringVolume: 0.8,
    timeout: 30000,
    onInvitationReceived: (invitation) => {
      console.log('Incoming call from', invitation.callerName)
    }
  })

  return (
    <div>
      {isRinging && <p>Ringing...</p>}
      {activeInvitations.map((invitation) => (
        <div key={invitation.id}>
          <p>{invitation.callerName} is calling</p>
          <button onClick={() => accept(invitation.id)}>Accept</button>
          <button onClick={() => decline(invitation.id)}>Decline</button>
        </div>
      ))}
    </div>
  )
}

import { useCallQuality } from '@/hooks/use-call-quality'

function QualityMonitorComponent({ peerConnection }) {
  const {
    quality,
    metrics,
    isExcellent,
    isPoor,
    lastAlert,
    start,
    stop,
  } = useCallQuality({
    interval: 2000,
    showAlerts: true
  })

  useEffect(() => {
    if (peerConnection) {
      start(peerConnection)
      return () => stop()
    }
  }, [peerConnection, start, stop])

  return (
    <div>
      <p>Quality: {quality}</p>
      {metrics && (
        <div>
          <p>Bitrate: {metrics.audioReceiveBitrate.toFixed(0)} kbps</p>
          <p>Packet Loss: {metrics.audioPacketLoss.toFixed(1)}%</p>
          <p>RTT: {metrics.rtt.toFixed(0)}ms</p>
        </div>
      )}
      {lastAlert && isPoor && (
        <div>
          <p>{lastAlert.message}</p>
          {lastAlert.suggestions.map((s, i) => (
            <p key={i}>• {s}</p>
          ))}
        </div>
      )}
    </div>
  )
}

import { useUserStatus } from '@/hooks/use-user-status'

function StatusComponent() {
  const {
    status,
    isAvailable,
    inCall,
    setOnline,
    setBusy,
    setDND,
    isUserAvailable,
    getStatusDisplay,
  } = useUserStatus({
    autoInitialize: true,
    awayTimeout: 5 * 60 * 1000
  })

  return (
    <div>
      <p>Your status: {status}</p>
      <button onClick={setOnline}>Set Online</button>
      <button onClick={setBusy}>Set Busy</button>
      <button onClick={() => setDND('In a meeting')}>Set DND</button>

      {isAvailable && <p>You can receive calls</p>}
      {inCall && <p>You are in a call</p>}
    </div>
  )
}

import { CallInvitation } from '@/components/calls/CallInvitation'

function App() {
  const [invitation, setInvitation] = useState(null)

  return invitation && (
    <CallInvitation
      invitation={invitation}
      onAccept={() => acceptCall(invitation.id)}
      onDecline={() => declineCall(invitation.id)}
      open={true}
    />
  )
}

import { CallStateIndicator } from '@/components/calls/CallStateIndicator'

<CallStateIndicator
  state="connected"
  duration={45000}
  displayName="Connected"
  showIcon={true}
  showDuration={true}
  size="md"
/>

import { CallQualityIndicator } from '@/components/calls/CallQualityIndicator'

<CallQualityIndicator
  quality="good"
  metrics={metrics}
  variant="detailed"
  showLabel={true}
  showMetrics={true}
/>

import { UserStatusIndicator } from '@/components/calls/UserStatusIndicator'

<UserStatusIndicator
  status="online"
  variant="badge"
  size="md"
  showTooltip={true}
/>

interface CallEvent {
  type: CallEventType
  callId: string
  timestamp: Date
  userId?: string
  metadata?: Record<string, any>
}

// Get all events
const allEvents = emitter.getHistory()

// Filter by call
const callEvents = emitter.getHistory({ callId: 'call-123' })

// Filter by type
const qualityEvents = emitter.getHistory({
  type: ['call:quality-changed', 'call:quality-alert'],
})

// Filter by user
const userEvents = emitter.getHistory({ userId: 'user-456' })

// Filter by time
const recentEvents = emitter.getHistory({
  since: new Date(Date.now() - 60000), // Last minute
})

import {
  createCallStateMachine,
  createInvitationManager,
  createStatusManager,
  createQualityMonitor,
  getCallEventEmitter,
} from '@/lib/calls'

// Initialize managers
const stateMachine = createCallStateMachine()
const invitationManager = createInvitationManager()
const statusManager = createStatusManager()
const qualityMonitor = createQualityMonitor()
const eventEmitter = getCallEventEmitter()

// Subscribe to events
eventEmitter.onCallEvent('call:created', (event) => {
  console.log('Call created:', event.callId)
  stateMachine.transition('initiating')
})

eventEmitter.onCallEvent('call:connected', (event) => {
  console.log('Call connected')
  stateMachine.transition('connected')
  statusManager.startCall(userId, event.callId)
  qualityMonitor.start(peerConnection)
})

eventEmitter.onCallEvent('call:ended', (event) => {
  console.log('Call ended:', event.reason)
  stateMachine.transition('ending')
  stateMachine.transition('ended')
  statusManager.endCall(userId)
  qualityMonitor.stop()
})

// Initiate call
async function initiateCall(targetUserId: string) {
  const callId = generateCallId()

  // Check availability
  if (!statusManager.isAvailable(targetUserId)) {
    const reason = statusManager.getUnavailabilityReason(targetUserId)
    alert(reason)
    return
  }

  // Create call
  eventEmitter.emitCallEvent({
    type: 'call:created',
    callId,
    callType: 'video',
    initiatorId: currentUserId,
    targetUserId,
    timestamp: new Date(),
  })

  // Transition states
  stateMachine.transition('initiating')

  // Get media
  const stream = await getVideoStream()

  // Create peer connection
  const pc = new RTCPeerConnection()
  stream.getTracks().forEach((track) => pc.addTrack(track, stream))

  // Create offer
  const offer = await pc.createOffer()
  await pc.setLocalDescription(offer)

  // Send offer to target
  await sendOffer(targetUserId, offer)

  stateMachine.transition('ringing')
}

// Handle incoming call
function handleIncomingCall(callId: string, callerId: string) {
  const invitation = invitationManager.createInvitation(callId, callerId, callerName, 'video')

  // Show UI
  showIncomingCallModal(invitation)
}

// Accept call
async function acceptCall(invitationId: string) {
  invitationManager.acceptInvitation(invitationId)
  stateMachine.transition('connecting')

  // Get media
  const stream = await getVideoStream()

  // Create peer connection
  const pc = new RTCPeerConnection()
  stream.getTracks().forEach((track) => pc.addTrack(track, stream))

  // Create answer
  const answer = await pc.createAnswer()
  await pc.setLocalDescription(answer)

  // Send answer
  await sendAnswer(callerId, answer)

  stateMachine.transition('connected')

  // Start quality monitoring
  qualityMonitor.start(pc)
}

// End call
async function endCall(callId: string) {
  stateMachine.transition('ending')

  // Close peer connection
  pc.close()

  // Stop media streams
  localStream.getTracks().forEach((track) => track.stop())

  // Emit event
  eventEmitter.emitCallEvent({
    type: 'call:ended',
    callId,
    reason: 'completed',
    duration: stateMachine.getConnectedDuration(),
    timestamp: new Date(),
  })

  stateMachine.transition('ended')
  qualityMonitor.stop()
  statusManager.endCall(currentUserId)
}

class CallStateMachine {
  getState(): CallState
  getPreviousState(): CallState | null
  canTransitionTo(targetState: CallState): boolean
  transition(targetState: CallState, reason?: string, metadata?: Record<string, any>): boolean
  reset(): void
  isState(state: CallState): boolean
  isAnyState(...states: CallState[]): boolean
  isActive(): boolean
  isInProgress(): boolean
  getStateDisplayName(): string
  getCurrentStateDuration(): number
  getTotalDuration(): number
  getConnectedDuration(): number
  getHistory(): StateTransitionEvent[]
}

class CallInvitationManager {
  createInvitation(id: string, callerId: string, callerName: string, type: 'voice' | 'video', options?: {...}): CallInvitation
  getInvitation(id: string): CallInvitation | undefined
  getActiveInvitations(): CallInvitation[]
  hasActiveInvitations(): boolean
  acceptInvitation(id: string): boolean
  declineInvitation(id: string): boolean
  cancelInvitation(id: string): boolean
  isRinging(): boolean
  updateConfig(config: Partial<InvitationConfig>): void
  cleanup(): void
  getStats(): {...}
}

class CallStatusManager {
  initializeUser(userId: string, initialStatus?: UserStatus): void
  getStatus(userId: string): UserCallStatus | undefined
  setStatus(userId: string, status: UserStatus, customMessage?: string): boolean
  updateActivity(userId: string): void
  startCall(userId: string, callId: string): boolean
  endCall(userId: string): boolean
  isAvailable(userId: string): boolean
  isBusy(userId: string): boolean
  isDND(userId: string): boolean
  setCallWaiting(userId: string, enabled: boolean): boolean
  getUnavailabilityReason(userId: string): string | null
  getStatusDisplay(userId: string): string
  getAllStatuses(): UserCallStatus[]
  getUsersByStatus(status: UserStatus): UserCallStatus[]
  getAvailableUsers(): UserCallStatus[]
  getBusyUsers(): UserCallStatus[]
  removeUser(userId: string): void
  cleanup(): void
  updateConfig(config: Partial<StatusManagerConfig>): void
  getStats(): {...}
}

class CallQualityMonitor {
  start(peerConnection: RTCPeerConnection): void
  stop(): void
  getMetrics(): QualityMetrics | null
  getQuality(): QualityLevel
  getHistory(): QualityMetrics[]
  getAverageMetrics(count?: number): Partial<QualityMetrics> | null
  cleanup(): void
}

class CallEventEmitter {
  emitCallEvent<T extends AnyCallEvent>(event: T): void
  getHistory(filter?: {...}): AnyCallEvent[]
  getCallHistory(callId: string): AnyCallEvent[]
  clearHistory(): void
  setMaxHistory(max: number): void
  onCallEvent<K extends CallEventType>(event: K, handler: CallEventHandlers[K]): void
  onceCallEvent<K extends CallEventType>(event: K, handler: CallEventHandlers[K]): void
  offCallEvent<K extends CallEventType>(event: K, handler: CallEventHandlers[K]): void
  onAnyEvent(handler: CallEventHandler): void
  offAnyEvent(handler: CallEventHandler): void
}

const { isInCall, callState, initiateVoiceCall, endCall } = useCall()

// Import new hooks
import { useCallState } from '@/hooks/use-call-state'
import { useCallInvitation } from '@/hooks/use-call-invitation'
import { useUserStatus } from '@/hooks/use-user-status'
import { useCallQuality } from '@/hooks/use-call-quality'

// Use separately or together
const { state, isConnected, transition } = useCallState()
const { activeInvitations, accept, decline } = useCallInvitation()
const { isAvailable, setStatus } = useUserStatus()
const { quality, metrics } = useCallQuality()