// Browser or Node.js (with ws package)

const apiKey = 'YOUR_API_KEY'
const ws = new WebSocket(`wss://staging-api.tryenvoyx.com/api/v1/ws?api_key=${apiKey}`)

ws.onopen = () => {
  console.log('Connected to EnvoyX WebSocket')

  // Send ping every 30 seconds to keep connection alive
  setInterval(() => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.send('ping')
    }
  }, 30000)
}

ws.onmessage = (event) => {
  const data = JSON.parse(event.data)

  console.log('Event received:', data)

  // Handle different event types
  switch (data.event) {
    case 'invoice.processed':
      handleInvoiceProcessed(data.data)
      break
    case 'invoice.flagged':
      handleInvoiceFlagged(data.data)
      break
    case 'pong':
      console.log('Pong received')
      break
    default:
      console.log('Unknown event:', data.event)
  }
}

ws.onerror = (error) => {
  console.error('WebSocket error:', error)
}

ws.onclose = (event) => {
  console.log('WebSocket closed:', event.code, event.reason)

  // Implement reconnection logic
  setTimeout(() => {
    console.log('Reconnecting...')
    connectWebSocket()
  }, 5000)
}

// Graceful shutdown
window.addEventListener('beforeunload', () => {
  ws.close(1000, 'Client disconnecting')
})

import asyncio
import websockets
import json

async def connect_websocket(api_key):
    uri = f"wss://staging-api.tryenvoyx.com/api/v1/ws?api_key={api_key}"

    async with websockets.connect(uri) as websocket:
        print("Connected to EnvoyX WebSocket")

        # Send ping every 30 seconds
        async def send_ping():
            while True:
                await asyncio.sleep(30)
                await websocket.send("ping")

        # Start ping task
        ping_task = asyncio.create_task(send_ping())

        try:
            # Receive messages
            async for message in websocket:
                data = json.loads(message)
                print(f"Event received: {data['event']}")

                # Handle different event types
                if data['event'] == 'invoice.processed':
                    handle_invoice_processed(data['data'])
                elif data['event'] == 'invoice.flagged':
                    handle_invoice_flagged(data['data'])

        except websockets.exceptions.ConnectionClosed:
            print("WebSocket closed")
            ping_task.cancel()

# Run
asyncio.run(connect_websocket("YOUR_API_KEY"))

package main

import (
    "encoding/json"
    "log"
    "time"

    "github.com/gorilla/websocket"
)

type Event struct {
    Event string                 `json:"event"`
    Data  map[string]interface{} `json:"data"`
}

func main() {
    apiKey := "YOUR_API_KEY"
    url := "wss://staging-api.tryenvoyx.com/api/v1/ws?api_key=" + apiKey

    conn, _, err := websocket.DefaultDialer.Dial(url, nil)
    if err != nil {
        log.Fatal("WebSocket connection error:", err)
    }
    defer conn.Close()

    log.Println("Connected to EnvoyX WebSocket")

    // Send ping every 30 seconds
    go func() {
        ticker := time.NewTicker(30 * time.Second)
        defer ticker.Stop()

        for range ticker.C {
            if err := conn.WriteMessage(websocket.TextMessage, []byte("ping")); err != nil {
                log.Println("Ping error:", err)
                return
            }
        }
    }()

    // Receive messages
    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            log.Println("Read error:", err)
            break
        }

        var event Event
        if err := json.Unmarshal(message, &event); err != nil {
            log.Println("JSON parse error:", err)
            continue
        }

        log.Printf("Event received: %s\n", event.Event)

        switch event.Event {
        case "invoice.processed":
            handleInvoiceProcessed(event.Data)
        case "invoice.flagged":
            handleInvoiceFlagged(event.Data)
        }
    }
}