/**
 * Created by Martin on 08/02/2016.
 */
'use strict';
var express = require('express');
var path = require('path');
var http = require('http');
var ejs = require('ejs');
var morgan = require('morgan');
var cookieparser = require('cookie-parser');
var session = require('express-session');
var methodoverride = require('method-override');
var bodyparser = require('body-parser');
var errorhandler = require('errorhandler');
var mqttConnect = require('./lib/mqtt/mqttConnect');
var log4js = require('log4js');
var logger = log4js.getLogger();


var WebSocketServer = require('websocket').server;

var EventEmitter = require('events');
var busEmitter = new EventEmitter();

var apn = require('apn');

require('sugar-date');

var calendar = require('./lib/office/officeController.js');
var cal = new calendar.officeController(busEmitter);

var lighting_v1 = require('./routes/lighting_v1');
var heating_v1 = require('./routes/heating_v1');
var projector_v1 = require('./routes/projector_v1');
var isProduction = false;


function restartTimer() {
  // Ibm / mqtt things go a bit weird if left on for too long so restart the server
  // at 7:30 ever morning before anyone is using it.
  var tom = Date.create('tomorrow at 7:30am');

  var ms = tom.getTime() - Date.create('now').getTime();


  console.log('Restarting in: ', ms);
  setTimeout(function() {process.exit(1);}, ms);

}
mqttConnect.setEmitter(busEmitter);
mqttConnect.doConnection();

process.env.NODE_ENV = process.env.NODE_ENV || 'development';

if (process.env.NODE_ENV === 'production') {
  isProduction = true;
}

logger.debug('isProduction:', isProduction);

var app = express();

app.set('port', process.env.PORT || 4545);
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.use(morgan('combined'));
app.use(cookieparser('your secret here'));
app.use(session({
  secret: '1234567890QWERTY', resave: false, saveUninitialized: false
}));
/* 'default', 'short', 'tiny', 'dev' */
app.use(methodoverride());

app.use(bodyparser.urlencoded({extended: false}));

// Parse application/json
app.use(bodyparser.json());

app.use(function(req, res, next) {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Headers', 'X-Requested-With');
  next();
});

// Run npm start --production to use dist
var staticDir = isProduction ? 'dist' : 'app';

app.use(express.static(path.join(__dirname, staticDir)));
app.use(errorhandler({dumpExceptions: true, showStack: true}));

lighting_v1.use(mqttConnect);
heating_v1.use(mqttConnect);
projector_v1.use(mqttConnect);

// Calendar handler

busEmitter.on('lightingOn', lighting_v1.doLightsOn);
busEmitter.on('lightingOff', lighting_v1.doLightsOff);

busEmitter.on('heatingOn', mqttConnect.heatingOn);
busEmitter.on('heatingOff', mqttConnect.heatingOff);
busEmitter.on('projectorOn', projector_v1.doProjectorOn);
busEmitter.on('projectorOff', projector_v1.doProjectorOff);


busEmitter.on('connectWS', mqttConnect.connectWS);
busEmitter.on('restartMQTTSocket', mqttConnect.restartMQTTSocket);

mqttConnect.setupPing();
cal.startController(busEmitter);

app.get('/stop', function(request, response) {
    cal.stopController();
    response.sendStatus(200);
  });

app.get('/start', function(request, response) {

    cal.startController();
    response.sendStatus(200);
  });

app.get('/api/calendar', function(req, res) {
    var calJson = cal.returnCalendar();
    logger.info(calJson);
    res.json(calJson);
  });

app.post('/api/calendar/extend', function(req, res) {
    res.json({});
  });




// Events and sockets

busEmitter.on('clientConnected', (socketSet) => {
  logger.info('-=-=-=-=-');
  logger.info(socketSet.getClientStatus());
  heating_v1.setsocket(socketSet).subscribe();
  lighting_v1.setsocket(socketSet).subscribe();
  projector_v1.setsocket(socketSet).subscribe();
});

busEmitter.on('clientStatusUpdated', (v) => {
  logger.info(v);
});



logger.info('Configuring WebSocket Listener...');
var server = http.createServer(function(request, response) {
  logger.info((new Date()) + ' Received request for ' + request.url);
  response.writeHead(404);
  response.end();
});

server.listen(3001, function() {
  logger.info((new Date()) + ' Server is listening on port 3001');
});
var wsServer = new WebSocketServer({
  httpServer: server, // You should not use autoAcceptConnections for production
  // applications, as it defeats all standard cross-origin protection
  // facilities built into the protocol and the browser.  You should
  // *always* verify the connection's origin and decide whether or not
  // to accept it.
  autoAcceptConnections: false
});

function originIsAllowed(origin) {
  // Put logic here to detect whether the specified origin is allowed.
  return true;
}

wsServer.on('request', function(request) {

  if (!originIsAllowed(request.origin)) {
    // Make sure we only accept requests from an allowed origin
    request.reject();
    logger.info((new Date()) + ' Connection from origin ' + request.origin + ' rejected.');
    return;
  }

  var connection = request.accept('stream', request.origin);
  logger.info((new Date()) + ' Connection accepted.');

  var sendSocketHandler = (obj) => {
      try {
        connection.sendUTF(JSON.stringify(obj));
      }
      catch (err) {
        logger.error(err);
        logger.warn('Offending object: ', obj);
      }
    };

  busEmitter.on('sendSocket', sendSocketHandler);

  connection.on('message', function(message) {
    if (message.type === 'utf8') {
      logger.info('Received Message: ' + message.utf8Data);
      connection.sendUTF(message.utf8Data);
    } else if (message.type === 'binary') {
      logger.info('Received Binary Message of ' + message.binaryData.length + ' bytes');
      connection.sendBytes(message.binaryData);
    }
  });

  connection.on('close', function(reasonCode, description) {
    logger.info((new Date()) + ' Peer ' + connection.remoteAddress + ' disconnected.');
    busEmitter.removeListener('sendSocket', sendSocketHandler);
  });
});

mqttConnect.connectWS(function() {
  logger.info('Ready to plug in sockets...');
});

app.post('/api/v1/lighting/off', lighting_v1.turnoff);
app.post('/api/v1/lighting/on', lighting_v1.turnon);
app.post('/api/v1/lighting/cmd', lighting_v1.command);

app.post('/api/v1/heating/off', heating_v1.turnoff);
app.post('/api/v1/heating/on', heating_v1.turnon);

app.post('/api/v1/projector/off', projector_v1.turnoff);
app.post('/api/v1/projector/on', projector_v1.turnon);
app.post('/api/v1/projector/cmd', projector_v1.command);

app.post('/api/v1/register/ios', function(req, res) {

  var body = req.body, registrationId;

  logger.debug(body);

  if (body.hasOwnProperty('registrationId')) {
    registrationId = body['registrationId'];
    logger.debug(registrationId);

    cal.registeriOSToken(registrationId);

  }
});

app.post('/api/v1/extend', function(req, res) {

  var body = req.body, data;

  if (body.hasOwnProperty('extendBy') && body.hasOwnProperty('uid')) {
    data = req.body;

    cal.extendMeeting(data);
    res.sendStatus(200);
  }

});

app.listen(3000, function() {
  logger.info('Express listening on 3000');
  restartTimer();
});