var express = require('express'),
    cluster = require('cluster'),
    net = require('net'),
    sio = require('socket.io'),
    farmhash = require('farmhash'),
    bodyParser = require('body-parser'),
    mysql = require('mysql');

const redis = require('redis').createClient;
const adapter = require('socket.io-redis');
const pub = redis('6379', 'na-redis.pushthis.io', {
    auth_pass: "2V"
});
const sub = redis('6379', 'na-redis.pushthis.io', {
    auth_pass: "y2V"
});


let track = require('./controllers/usagecontroller.js');

var port = 3000,
    num_processes = require('os').cpus().length;

var pool = mysql.createPool({
    connectionLimit: 150,
    host: "",
    user: "na-connections",
    password: "",
    database: "pushthis"
});

if (cluster.isMaster) {
    // This stores our workers. We need to keep them to be able to reference
    // them based on source IP address. It's also useful for auto-restart,
    // for example.
    var workers = [];

    // Helper function for spawning worker at index 'i'.
    var spawn = function(i) {
        workers[i] = cluster.fork();

        // Optional: Restart worker on exit
        workers[i].on('exit', function(code, signal) {
            console.log('respawning worker', i);
            spawn(i);
        });
        workers[i].on('disconnect', function(worker) {
            console.log(workers[i].process.pid + 'disconnected -- rip')
        })

        workers[i].on('online', (worker) => {
            console.log(workers[i].process.pid)
        })
    };

    // Spawn workers.
    for (var i = 0; i < num_processes; i++) {
        spawn(i);
    }

    var worker_index = function(n) {
        return Math.floor(Math.random() * n)
    };

    // Create the outside facing server listening on our port.
    var server = net.createServer({
        pauseOnConnect: true
    }, function(connection) {
        var worker = workers[worker_index(num_processes)];
        worker.send('sticky-session:connection', connection);
    }).listen(port);
} else {
    process.setMaxListeners(0);
    // Note we don't use a port here because the master listens on it for us.
    var app = new express();

    app.use(bodyParser.json({
        limit: 5000
    }))

    app.use(function(req, res, next) {
        res.setHeader('Access-Control-Allow-Origin', '*');
        res.header("Access-Control-Allow-Credentials: true");
        res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
        next();
    });


    // Don't expose our internal server to the outside.
    var server = app.listen(0, 'localhost'),
        io = sio(server);

    // Tell Socket.IO to use the redis adapter. By default, the redis
    // server is assumed to be on localhost:6379. You don't have to
    // specify them explicitly unless you want to change them.
    io.adapter(adapter({
        pubClient: pub,
        subClient: sub
    }));



    // Here you might use Socket.IO middleware for authorization etc.
    io.sockets.on('connection', function(socket) {

        var origin = socket.request.headers['origin'];
        console.log('A client has connected to from: ' + origin);
        if (origin === null || origin === undefined || origin === 'http://localhost') {

            //Emit the JSON data from RESTful API
            socket.on('up3da3teF3romN3od3e0100010039303242##300', function(data) {
                console.log('payload sent out from rest api')
                socket.to(data.channel).emit(data.event, data.data)
            });

            socket.on('authorized032490234uj29jdiofk90d0a', function(data){
                callback = {
                    'status': 'socket-authorized',
                    'channel': data.channel,
                    'origin': data.origin,
                    'socket_id': data.socket_id
                };


                //send back to the customers site
                socket.to(data.channel).emit('info', callback)
                console.log(data);
            });

            socket.on('update-my-apps', function(data) {
                if(data.key === '0010010010010-updateMessages'){
                  socket.to('pushthisNetwork').emit('my-apps', { appID: data.appID, messageTotal: data.messageTotal, messageCycle: data.messageCycle})
                }
            });



            pool.getConnection(function(err, connection) {

                //get connection origin
                var key = socket.handshake.query.key;
                var getAppInformation = "SELECT * FROM `users_app` WHERE `public_key` = ?";

                connection.query(getAppInformation, [key], function(err, result, fields) {
                    if (err) throw err

                    if (result.length < 1) {
                      //trigger callback to origin/pushthis/auth
                      callback = {
                          'status': 'error',
                          'key': key,
                          'socket_id': socket.id,
                          'message': 'Your key is not registered with Pushthis. Please register on pushthis.io to use our service.'
                      };

                      //send back to the customers site
                      return socket.emit('helpMePush-This', callback);
                    }


                  //count connections



                  //Client requesting to join a channel
                  socket.on('join', function(data) {

                      console.log(data);

                      if (!data['channel']) {
                          //error just return nothing and stop
                          return
                      }

                      //Client requesting to join public channel
                      if (!data['presence'] || data['presence'] === false) {
                          publicChannel = data['channel']
                          socket.join(publicChannel)
                      }

                      //Client requesting to join Presence channel
                      if (data['presence'] === true && data['authorize'] === false ||
                          data['presence'] === true && !data['authorize']) {
                          presenceChannel = data['channel']

                          socket.join(presenceChannel)

                          //trigger callback to origin/pushthis/auth
                          callback = {
                              'status': 'connected',
                              'channel': data['channel'],
                              'origin': socket.request.headers['origin'],
                              'socket_id': socket.id
                          };


                          //send back to the customers site
                          io.to(presenceChannel).emit('info', callback);
                      }

                      if (data['authorize'] === true) {
                          presenceChannel = data['channel']
                          //trigger callback to origin/pushthis/auth
                          callback = {
                              'status': 'waiting authorization',
                              'channel': data['channel'],
                              'origin': socket.request.headers['origin'],
                              'socket_id': socket.id
                          };


                          //send back to the customers site
                          io.emit('info', callback);
                      }
                  });
              });
            });
        } else {
            pool.getConnection(function(err, connection) {

                //get connection origin
                var key = socket.request.headers['origin'];
                var getAppInformation = "SELECT * FROM `users_app` WHERE `origin` = ?";

                connection.query(getAppInformation, [key], function(err, result, fields) {
                    if (err) throw err

                    if (result.length < 1) {
                      //trigger callback to origin/pushthis/auth
                      callback = {
                          'status': 'error',
                          'origin': socket.request.headers['origin'],
                          'socket_id': socket.id,
                          'message': 'Your origin is not registered with Pushthis. Please register it to use our service.'
                      };

                      //send back to the customers site
                      socket.emit('helpMePush-This', callback);
                      return socket.disconnect();
                    }


                    //tally customer connections


                    //Client requesting to join a channel
                    socket.on('join', function(data) {

                        console.log(data);

                        if (!data['channel']) {
                            //error just return nothing and stop
                            return
                        }

                        //Client requesting to join public channel
                        if (!data['presence'] || data['presence'] === false) {
                            publicChannel = data['channel']
                            socket.join(publicChannel)
                        }

                        //Client requesting to join Presence channel
                        if (data['presence'] === true && data['authorize'] === false ||
                            data['presence'] === true && !data['authorize']) {
                            presenceChannel = data['channel']

                            socket.join(presenceChannel)

                            //trigger callback to origin/pushthis/auth
                            callback = {
                                'status': 'connected',
                                'channel': data['channel'],
                                'origin': socket.request.headers['origin'],
                                'socket_id': socket.id
                            };


                            //send back to the customers site
                            console.log(result[0]['callback_url'];
                            request.post({url: result[0]['callback_url'],
                            form: {key:'value'}},
                            function(err,httpResponse,body){
                            console.log(httpResponse + ' and ' + body)})

                            io.to(presenceChannel).emit('info', callback);
                        }

                        if (data['authorize'] === true) {
                            presenceChannel = data['channel']
                            //trigger callback to origin/pushthis/auth
                            callback = {
                                'status': 'waiting authorization',
                                'channel': data['channel'],
                                'origin': socket.request.headers['origin'],
                                'socket_id': socket.id
                            };


                            //send back to the customers site
                            io.emit('info', callback);
                        }
                    });

                    var status = "connection";
                    var identifier = result[0]['users_app_id'];
                    //var identifier = result['users_app_id'];
                    track.customersConnections(identifier, status, pool, socket);;
                });
                // And done with the connection.
                connection.release();
            });

            socket.once('disconnect', function(reason, socketID, channels) {
                //let the customer know someone left their channels
                for (var channel in channels) {
                    if (channel === socketID) {
                        //ignore
                    } else {
                        //trigger callback to customer
                        callback = {
                            'status': 'disconnected',
                            'channel': channel,
                            'origin': socket.request.headers['origin'],
                            'socket_id': socketID
                        };

                        io.to(channel).emit('info', callback);
                    }
                }





                var origin = socket.request.headers['origin'];
                console.log('A client has disconnected from from: ' + origin);
                if (origin === null || origin === undefined) {

                  //do nothing

                }else{
                  pool.getConnection(function(err, connection) {
                    var status = "disconnection";
                    var key = socket.request.headers['origin'];
                    if(key === null || undefined){

                    }else{
                      var getAppInformation = "SELECT * FROM `users_app` WHERE `origin` = ?";

                      connection.query(getAppInformation, [key], function(err, result, fields) {
                          if (err) throw error
                          if(result.length < 1){
                            return
                          }

                          io.emit('demo-2', 'Authorized.')
                          var status     = "disconnection";
                          var identifier = result[0]['users_app_id'];
                          track.customersConnections(identifier, status, pool, socket);;
                      });
                    }
                  // And done with the connection.
                  connection.release();
                  });
                }
            });
        }
    });

    // Listen to messages sent from the master. Ignore everything else.
    process.on('message', function(message, connection) {
        if (message !== 'sticky-session:connection') {
            return;
        }

        // Emulate a connection event on the server by emitting the
        // event with the connection the master sent us.
        server.emit('connection', connection);

        connection.resume();
    });
}