import PondSocket from "@eleven-am/pondsocket";

// Create a new PondSocket server
const pond = new PondSocket({
    // Optional: Use an existing HTTP server
    server: httpServer,
    // Optional: Use an existing WebSocket server
    socketServer: wsServer,
    // Optional: Whether to create an exclusive server
    exclusiveServer: true,
    // Optional: Distributed backend for scaling
    distributedBackend: new RedisDistributedBackend({
        host: 'localhost',
        port: 6379
    })
});

// Start the server
pond.listen(3000);

// Create an endpoint
const endpoint = pond.createEndpoint('/api/socket', (ctx, next) => {
    // Handle authentication
    const token = ctx.request.query.token;
    
    if (isValidToken(token)) {
        // Accept the connection and assign user data
        ctx.accept({
            userId: getUserIdFromToken(token),
            role: getRoleFromToken(token)
        });
    } else {
        // Reject invalid connections
        ctx.reject('Invalid token', 401);
    }
});

// Endpoints can have middleware
endpoint.use(async (ctx, next) => {
    // Log all connections
    console.log(`New connection from ${ctx.request.ip}`);
    await next();
});

// Create a channel with path parameters
const channel = endpoint.createChannel('/chat/:roomId', async (ctx, next) => {
    const { role } = ctx.user.assigns;
    const { username } = ctx.joinParams;
    const { roomId } = ctx.event.params;

    // Handle join requests
    if (role === 'user') {
        // Accept the join request
        ctx.accept({ username })
            // Track user presence
            .trackPresence({
                username,
                status: 'online',
                joinedAt: Date.now()
            })
            // Send channel history
            .sendToUsers('history', {
                messages: await getChannelHistory(roomId)
            });
    } else {
        ctx.decline('Unauthorized', 403);
    }
});

// Handle channel events
channel.onEvent('message', (ctx, next) => {
    const { text } = ctx.event.payload;
    const { username } = ctx.user.assigns;
    
    // Broadcast to all users in the channel
    ctx.broadcast('message', {
        text,
        username,
        timestamp: Date.now()
    });
});

// Handle user presence
channel.onEvent('presence', (ctx, next) => {
    const { status } = ctx.event.payload;
    ctx.updatePresence({
        status,
        lastSeen: Date.now()
    });
});

// Handle user leaves
channel.onLeave((ctx) => {
    console.log(`User ${ctx.user.assigns.username} left the channel`);
});

import PondClient from "@eleven-am/pondsocket-client";

// Create a client instance
const socket = new PondClient('ws://localhost:3000/api/socket', {
    // Connection parameters (e.g., authentication token)
    token: 'your-auth-token'
});

// Handle connection state
socket.onConnectionChange((connected) => {
    if (connected) {
        console.log('Connected to server');
    } else {
        console.log('Disconnected from server');
    }
});

// Connect to the server
socket.connect();

// Create a channel
const channel = socket.createChannel('/chat/123', {
    // Join parameters
    username: 'user123'
});

// Handle channel state
channel.onChannelStateChange((state) => {
    switch (state) {
        case 'joining':
            console.log('Joining channel...');
            break;
        case 'joined':
            console.log('Joined channel');
            break;
        case 'left':
            console.log('Left channel');
            break;
    }
});

// Handle presence updates
channel.onPresenceChange((presence) => {
    console.log('Presence updated:', presence);
});

// Handle user changes
channel.onUsersChange((users) => {
    console.log('Users in channel:', users);
});

// Join the channel
channel.join();

// Send a message
channel.sendMessage('message', {
    text: 'Hello, World!'
});

// Listen for messages
channel.onMessage('message', (message) => {
    console.log(`${message.username}: ${message.text}`);
});

// Update presence
channel.sendMessage('presence', {
    status: 'away'
});

// Leave the channel
channel.leave();

import express from 'express';
import pondSocket from '@eleven-am/pondsocket-express';

const app = express();
const pondApp = pondSocket(app);

// Create a WebSocket endpoint
const endpoint = pondApp.createEndpoint('/api/socket', (ctx, next) => {
    const token = ctx.request.query.token;
    if (isValidToken(token)) {
        ctx.accept({ role: 'user' });
    } else {
        ctx.reject('Invalid token', 401);
    }
});

// Create a channel
const channel = endpoint.createChannel('/chat/:roomId', (ctx, next) => {
    ctx.accept()
        .trackPresence({
            username: ctx.joinParams.username,
            status: 'online'
        });
});

// Handle messages
channel.onEvent('message', (ctx, next) => {
    ctx.broadcast('message', ctx.event.payload);
});

app.listen(3000);

import { Module } from '@nestjs/common';
import { PondSocketModule } from '@eleven-am/pondsocket-nest';

@Module({
    imports: [
        PondSocketModule.forRoot({
            isGlobal: true,
            guards: [AuthGuard],
            pipes: [ValidationPipe]
        })
    ]
})
export class AppModule {}

// Create a WebSocket endpoint
@Endpoint('/api/socket')
export class SocketController {
    @OnConnection()
    async handleConnection(ctx: Context) {
        const token = ctx.request.query.token;
        if (isValidToken(token)) {
            ctx.accept({ role: 'user' });
        } else {
            ctx.reject('Invalid token', 401);
        }
    }
}

// Create a channel
@Channel('/chat/:roomId')
export class ChatController {
    @OnJoin()
    async handleJoin(ctx: Context) {
        // You can return an object with specific properties to trigger actions
        return {
            // Send an event to the user
            event: 'welcome',
            message: 'Welcome to the channel!',
            
            // Broadcast to all users in the channel
            broadcast: 'user_joined',
            username: ctx.joinParams.username,
            
            // Broadcast to all users except the sender
            broadcastFrom: 'user_joined',
            username: ctx.joinParams.username,
            
            // Update user assigns
            assigns: {
                username: ctx.joinParams.username,
                joinedAt: Date.now()
            },
            
            // Update user presence
            presence: {
                username: ctx.joinParams.username,
                status: 'online',
                lastSeen: Date.now()
            }
        };
    }

    @OnEvent('message')
    async handleMessage(ctx: Context) {
        const { text } = ctx.event.payload;
        
        // Return an object to broadcast the message
        return {
            broadcast: 'message',
            text,
            username: ctx.user.assigns.username,
            timestamp: Date.now()
        };
    }

    @OnEvent('presence')
    async handlePresence(ctx: Context) {
        const { status } = ctx.event.payload;
        
        // Return an object to update presence
        return {
            presence: {
                status,
                lastSeen: Date.now()
            }
        };
    }
}