var prod = process.env.NODE_ENV === 'production';
var app = require('express').createServer();
var ws = require('ws-rpc').extend(require('ws'));
var wss = new ws.Server({ server: app });
var wsflash = require('ws-flash-client');
require('policyfile').createServer().listen(prod ? 843 : 10843, app);
 
app.configure(function() {
    // configure other stuff like express globals, jade, stylus, etc.
    // ...
    
    // configure the ws-rpc middleware:
    app.use(wss.middleware(express));
    
    // configure the ws-flash-client middleware:
    app.use(wsflash.middleware(express));
    
    // static file handling must come afterwards:
    app.use(express.static(pub));
    
    // bind node to a port
    app.listen(prod ? 80 : 1234);
});
 
// create/get a named room (channel)
var myRoom = wss.room('myRoom');
 
// handle a new client connection
wss.on('connect', function(client) {
 
    // add client to a room
    myRoom.add(client);
    
    // message the client
    client.message('some message', args);
    
    // message the client with callback
    client.message('some message', args, function(err, args) {
        if(err)
            // ...
    });
    
    // Note:
    // you can hook your listener actions on every client separately, but if you 
    // have the same handler for every client, you should consider doing it the way
    // below*, as with large number of clients, that will save you a lot of resources.
    
    // handle message from a client without a callback
    client.on('some message', function(args) {
        
        // ...
    });
    
    // handle message from a client with a callback
    client.on('some message', function(args, cb) {
        
        // ...
 
        // call the callback (should use node convention but not mandatory)
        cb(null, 'ok');
    });
    
});
 
// *handle message from a client without a callback
wss.on('some message', function(client, args) {
 
    // ...
});
 
// *handle message from a client with a callback
wss.on('some message', function(client, args, cb) {
 
    // ...
    
    // call the callback (should use node convention but not mandatory)
    cb(null, 'ok');
});
 
// handle client disconnection
wss.on('disconnect', function(client) {
 
    //myRoom.remove(client); <- not necessary, this is done automatically
 
    // example: broadcast to all client's rooms
    for(id in client.rooms)
        client.rooms[id].message('some message', args);
});
 
// message all clients connected to the server
wss.message('some message', args);
 
// message all clients in a room
myRoom.message('some message', args);
 
// and don't forget this if you don't want your Node to crash on an error:
// if the error comes from a client, the client is passed as second parameter
wss.on('error', function(e, client) {
    console.log(client ? 'client' : 'server', e);
});

var prod = process.env.NODE_ENV === 'production';
var app = require('express').createServer();
var ws = require('ws-rpc').extend(require('ws'));
var wsflash = require('ws-flash-client');
require('policyfile').createServer().listen(prod ? 843 : 10843, app);
 
var httpsOptions = {
    key: fs.readFileSync('https/www.yourdomain.com.key'),
    cert: fs.readFileSync('https/www.yourdomain.com.crt')
};
 
var httpServer = http.createServer(app.handle.bind(app)).listen(port);
var httpsServer = https.createServer(httpsOptions, app.handle.bind(app))
    .listen(httpsPort);
 
var wss = new ws.Server({ server: new ws.ServerHub([ httpServer, httpsServer ]) });
 
app.configure(function() {
    // continue as in the above example
    // ...

$(function() {
 
    $.wsFlashClientInit({}, function(err) {
        if(err)
            return log('no websocket support');
            
        var WebSocketRPC = InitWebSocketRPC(WebSocket);
 
        // create the client (will use WebSocket object on the background)
        // param1: url
        // param2 (optional): protocols, see http://dev.w3.org/html5/websockets/#websocket
        // param3 (optional): connection timeout in ms (default 4s), use -1 to disable auto-reconnect
        // param4 (optional): reconnection wait timeout in ms (default 1s)
        var ws = new WebSocketRPC('ws://' + window.location.host + '/');
        
        // handle a message from the server
        ws.on('some message', function(args) {
            
            // ...
        });
 
        // handle a message from the server with a callback
        ws.on('some message', function(args, cb) {
 
            // ...
            
            cb(null, 'hello from client');
            
            // or, in the case of an error:
            
            cb(new Error('some problem'));
        });
        
        // message the server
        ws.message('some message', args);
        
        // message the server with a callback
        ws.message('some message', args, function(err, args) {
            if(err)
                // ...
        });
        
        // disconnect from the server
        // param1 (optional): disable automatic reconnection
        ws.disconnect(true);
 
        // connected event
        ws.on('open', function() {
            log('connected');
            
            // access the WebSocket if needed:
            //ws.socket ... <- will be null when disconnected, and then a new one created
        });
 
        // disconnected event
        ws.on('close', function() {
            log('disconnected');
        });
        
        // error event
        ws.on('error', function(e) {
            log(e.stack || e);
        });
    });
 
    // just an example
    function log(s) {
        var m = $('#msg');
        m.text(m.text()  + '\n' + s);
    }
});

 
var WebSocketRPC = InitWebSocketRPC(WebSocket);
var ws = new WebSocketRPC('ws://' + window.location.host + '/');
 
// ..and the same operations as above..
 

var ws = require('ws-rpc').extend(require('ws'));
var wsc = new ws.RPCWebSocket('ws://127.0.0.1:1144/');
 
wsc.on('message 1', function(arg1, arg2, cb) {
    log('message 1: ' + arg1 + ', ' + arg2);
    cb(null, 'message1 response from client', 'arg2');
});
 
// etc.