/**
 **      ==================================
 **      OOOO   OOOO OOOO  O      O   OOOO
 **      O   O  O    O     O     O O  O   O
 **      O   O  O    O     O     O O  O   O
 **      OOOO   OOOO OOOO  O     OOO  OOOO
 **      O   O     O    O  O    O   O O   O
 **      O   O     O    O  O    O   O O   O
 **      OOOO   OOOO OOOO  OOOO O   O OOOO
 **      ==================================
 **      BSSLAB, Dr. Stefan Bosse http://www.bsslab.de
 **
 **      COPYRIGHT: THIS SOFTWARE, EXECUTABLE AND SOURCE CODE IS OWNED
 **                 BY THE AUTHOR.
 **                 THIS SOURCE CODE MAY NOT BE COPIED, EXTRACTED,
 **                 MODIFIED, OR OTHERWISE USED IN A CONTEXT
 **                 OUTSIDE OF THE SOFTWARE SYSTEM.
 **
 **    $AUTHORS:     Stefan Bosse
 **    $INITIAL:     (C) 2006-2016 BSSLAB
 **    $CREATED:     3/28/15 by sbosse.
 **    $VERSION:     1.1.6
 **
 **    $INFO:
 **
 **  DOS: Broker Server Connection Module (HTTP connection).
 **
 *
 * Notes:
 * Superfluous? All http function callback computations are wrapped by scheduler callbacks 
 * to avoid main thread preemption!
 * Is event queuing always guaranteed in JS?
 *
 **    $ENDOFINFO
 */
"use strict";
var log = 0;

var Io = Require('com/io');
var Net = Require('dos/network');
var Buf = Require('dos/buf');
var Rpc = Require('dos/rpc');
var util = require('util');
var http = require('http');
var xmldoc = Require('dos/ext/xmldoc');
var Sch = Require('dos/scheduler');
var Comp = Require('com/compat');
var Perv = Comp.pervasives;
var String = Comp.string;
var Array = Comp.array;
var Filename = Comp.filename;
var trace = Io.tracing;
var div = Perv.div;
var Conn = Require('dos/connection');

var isNode = Comp.isNodeJS();


/**************************
 ** HTTP Broker SERVER
 **************************/
/**
 *
 * @param {port} hostport
 * @param {string} srv_url
 * @param {string} srv_ipport
 * @param {rpcrouter} router
 * @constructor
 */
var Server = function(hostport,srv_url,srv_ipport,router,verbose,env) {
  this.env=env||{};
  this.srv_url=srv_url;               // URL
  this.srv_ipport=srv_ipport;         // URL:port
  this.hostport=hostport;               // Public communication Net.Port == Host port
  this.status = Net.Status.STD_OK;
  this.router=router;
  this.app=undefined;
  this.https=undefined;
  this.client_queue=[];
  this.lock=false;
  this.rpccon=Rpc.RpcConn(
      Net.uniqport(),
      /*
      ** Connection Forward and Deliver Operation
       */
      undefined,
      // Passive client conenctions: Notheing to do here, already handled by the router
      function(rpcio) {
          return true;
      }
  )
  this.verbose=verbose||0;
  this.env={};
};

/*
**  Schedule all pending client-side requests if there is matching input.
**  Called from router function. Lock required!
*/

Server.prototype.schedule = function () {
  var self = this;
  var i;
  if (self.lock) return;
  this.rpccon.stats.op_schedule++;
  Io.trace(trace || ('[BTTP] server schedule: '));
  self.lock = true;
  self.client_queue = Array.filter(self.client_queue, function (client) {
      var msgn = 0;
      var body = '';
      var trans, hdr, buf;
      /*
       * Forward all matching pending transaction requests and replies...
       */
      Io.log((self.router.monitor < 2) || ('[BTTP] schedule for client host ' + Net.Print.port(client.hostport)+
          ' #trans='+ Array.length(self.router.trans_queue)+' #lookup='+Array.length(self.router.lookup_queue)));
      do {
          trans = self.router.lookup_trans_for_host(client.hostport);
          Io.log(((log+self.verbose) < 10) || ('[BTTP] schedule: lookup_trans_for_host=' + util.inspect(trans)));
          if (trans != undefined) {
              hdr = trans.header;

              Io.log(((log+self.verbose) < 2) || ('[BTTP] schedule: found trans=' + Rpc.Print.rpcio(trans)));
              Io.trace(trace || ('[BTTP] schedule: found trans=' + Rpc.Print.rpcio(trans)));

              if (trans.operation == Rpc.Operation.TRANSREQ) {
                  // Forward transtion request
                  body = body + trans.to_xml('rpc');
                  msgn++;
                  self.router.pkt_discard(trans);
              } else if (trans.operation == Rpc.Operation.TRANSREP) {
                  // Transaction reply!
                  body = body + trans.to_xml('rpc');
                  msgn++;
                  self.router.pkt_discard(trans);
              }
          }
      } while (trans != undefined);
      /*
      ** Add all pending server port LOOKUP requests...
      ** Forward a LOOKUP of a server port search only once to a client host!
      */
      for (i in self.router.lookup_queue) {
          var lookup = self.router.lookup_queue[i];
          var cache = self.router.lookup_cache[i];
          Io.log((self.router.monitor < 2) || ('[BTTP] schedule: lookup '+Rpc.Print.rpcio(lookup)));
          if (cache[client.hostport]==undefined) {
              cache[client.hostport]=1;
              buf = Buf.Buffer();
              Buf.buf_put_port(buf, lookup.header.h_port);
              body = body + '<rpc operation="LOOKUP" hostport="' + Net.port_to_str(self.hostport) + '">' +
              Buf.buf_to_hex(buf) + '</rpc>';
              msgn++;
          }
      }
      if (msgn > 0) {
          self.rpccon.stats.op_messages=self.rpccon.stats.op_messages+msgn;
          body = '<xml>' + body + '</xml>';
          self.send(client.respond, body);
          return false;
      } else if (client.timeout <= 0) {
          body = 'ENOENTR';
          self.send(client.respond, body);
          return false;
      } else return true;
  });
  self.lock = false;
};

Server.prototype.send = function (response, data) {
  //response.writeHead(200, {'Content-Type': 'text/plain; charset=utf8'});
  //response.writeHead(200);
  this.rpccon.stats.op_send++;
  Io.log(((log+this.verbose)<10)||('[BHTP] send ['+data.length+']'));
  if (response.origin!=undefined)
      response.writeHead(200,{'Access-Control-Allow-Origin': response.origin,
                              'Access-Control-Allow-Credentials': 'true',
                              'Content-Type': 'text/plain'});
  else
      response.writeHead(200,{'Content-Type': 'text/plain'});
  response.write(data);
  response.end();
};

Server.prototype.forward = function (self, params, res) {   // HTTP Callback handler
  var hostport, hdr, buf,i;
  this.rpccon.stats.op_forward++;
  hostport = Net.port_of_param(params.hostport);
  /*
   ** 1. Forward TRANS message requests if there are pending requests for the host port.
   ** 2. Forward LOOKUP messages (broadcast)
   ** If there are actually no messages, add this request to the request queue (if timeout <>0).
   */
  var msgn = 0;
  var body = '';
  var timeout = (params.timeout != undefined) ? (Perv.int_of_string(params.timeout)) : 0;
  /*
  ** Forward all pending transaction requests and replies...
   */
  Io.log((self.router.monitor < 2) || ('[BTTP] forward for host ' + Net.Print.port(hostport)+
      ' #trans='+ Array.length(self.router.trans_queue)+' #lookup='+Array.length(self.router.lookup_queue)));
  do {
      var trans = self.router.lookup_trans_for_host(hostport);
      Io.log(((log+this.verbose) < 10) || ('[BTTP] server get: lookup_trans_for_host=' + util.inspect(trans)));
      if (trans != undefined) {
          hdr = trans.header;

          Io.log(((log+self.verbose) < 2) || ('[BTTP] server get: found trans=' + Rpc.Print.rpcio(trans)));

          if (trans.operation == Rpc.Operation.TRANSREQ) {
              // Forward transtion request
              body = body + trans.to_xml('rpc');
              msgn++;
              self.router.pkt_discard(trans);
          } else if (trans.operation == Rpc.Operation.TRANSREP) {
              // Transaction reply!
              body = body + trans.to_xml('rpc');
              msgn++;
              self.router.pkt_discard(trans);
          }
      }
  } while (trans != undefined);
  /*
  ** Add all pending server port LOOKUP requests...
  ** Forward a LOOKUP of a server port search only once to a client host!
  */
  for (i in self.router.lookup_queue) {
      var lookup = self.router.lookup_queue[i];
      var cache = self.router.lookup_cache[i];
      Io.log((self.router.monitor < 2 ) || ('[BTTP] forward: +lookup '+util.inspect(lookup)+' cache '+util.inspect(cache)));
      if (cache[hostport]==undefined) {
          cache[hostport] = 1;
          buf = Buf.Buffer();
          Buf.buf_put_port(buf, lookup.header.h_port);
          body = body + '<rpc operation="LOOKUP" hostport="' + Net.port_to_str(self.hostport) + '">' +
          Buf.buf_to_hex(buf) + '</rpc>';
          msgn++;
      }
  }
  if (msgn == 0) {
      if (timeout > 0) {
          self.client_queue.push({timeout: timeout, hostport: hostport, respond: res});
      } else {
          // short reply
          body = 'ENOENTR';
          //res.
          self.send(res, body);
      }
  } else {
      body = '<xml>' + body + '</xml>';
      //res.
      self.send(res, body);
  }
};

Server.prototype.get = function (self, req, res) {
  var i,str,
      hostport, srvport, buf, hdr,
      params = Conn.parseQueryString(req.url);
  this.rpccon.stats.op_get++;
  Io.log(((log+self.verbose) < 2) || ('[BTTP] server get: ' + req.url));
  Io.log(((log+self.verbose) < 10) || ('[BTTP] server get: ' + util.inspect(params)));
  Io.trace(trace || ('[BTTP] server get: ' + req.url));
  res.origin=req.headers.origin;

  if (params.rpc != undefined &&
      params.rpc == 'request' &&
      params.hostport != undefined)
  {
      /**************************************************
       ** RPC request (HTTP Client- /Browser App. collector request)
       *************************************************/
      Sch.ScheduleCallback([Sch.Bind(self,self.forward),self, params,res]);

  } else if (params.rpc != undefined &&
      params.rpc == 'iamhere' &&
      params.hostport != undefined &&
      params.srvport != undefined)
  {
      /********************************
       ** short IAMHERE rpc message
       ********************************/
      hostport = Net.port_of_param(params.hostport);
      srvport = Net.port_of_param(params.srvport);
      {
          if (self.verbose && self.router.lookup_host(hostport)==undefined) 
            Io.out('[BTTP] IAMHERE! Adding remote host ' + 
               Net.Print.port(hostport) + ' ip=' + req.connection.remoteAddress + 
              ((params.port && params.port!='undefined')?(' ipport=' + params.port):''));
          self.router.add_host(hostport, self.rpccon.port);
          var rpcio=self.router.pkt_get();
          rpcio.operation=Rpc.Operation.IAMHERE;
          rpcio.connport=self.rpccon.port;
          rpcio.hostport=hostport;
          rpcio.sendport=self.router.hostport;
          rpcio.header.h_port=srvport;
          self.router.route(rpcio);

      }
      /*
      {
          self.router.add_port(srvport, hostport);
          self.router.add_host(hostport, self.rpccon.port);
          Io.log((log < 1) || ('[BTTP] server get IAMHERE: adding server port ' +
              Net.Print.port(srvport) + ' located on host ' + Net.Print.port(hostport)));
          self.router.remove_lookup(srvport);
          // TBD: search for stalled transactions that must be send to another server capable host!
          // Broker connected client apps. will collect the appropriate transaction on the next request round.
          //res.
      }
      */
      self.send(res, 'STD_OK');
  } else if (params.alive != undefined &&
             params.hostport != undefined)
  {
      /***************************
       ** ALIVE message request
       ***************************/
      this.rpccon.stats.op_alive++;

      buf=Buf.Buffer();
      hostport = Net.port_of_param(params.hostport);

      if (self.verbose && self.router.lookup_host(hostport)==undefined) 
        Io.out('[BTTP] ALIVE! Adding remote host ' + 
               Net.Print.port(hostport) + ' ip=' + params.url + (params.port!='undefined'?(' ipport=' + params.port):''));
      // TODO this.router.add_host(hostport, [params.url, params.port]);
      self.router.add_host(hostport,self.rpccon.port);
      //res.
      Buf.buf_put_port(buf,self.hostport);
      self.send(res, Buf.buf_to_hex(buf));
  } else if (params.ask != undefined &&
             params.xname != undefined)
  {
      /***************************
       ** ASK message request
       ***************************/
      this.rpccon.stats.op_ask++;
      buf=Buf.Buffer();
      //console.log(self.env[params.xname]);
      Buf.buf_put_string(buf,self.env[params.xname]||'undefined');
      self.send(res, Buf.buf_to_hex(buf));
  } else if (params.notify != undefined &&
             params.xname != undefined &&
             params.xvalue !=undefined)
  {
      /***************************
       ** NOTIFY message request
       ***************************/
      this.rpccon.stats.op_notify++;
      self.env[params.xname]=params.xvalue;
      //console.log(self.env[params.xname]);
      self.send(res, '');
  }    // res.
  else
      self.send(res, 'EINVALID');
};

Server.prototype.trans = function (self, params, req, res) {    // HTTP Callback handler
  var body;
  /***************************
   ** Incoming TRANS message
   **************************/
  req.setEncoding('utf8');
  body = '';
  req.on('data', function (chunk) {
      body = body + chunk;
  });
  req.on('end', function () {
      Io.log(((log+self.verbose) < 10) || ('BODY: ' + body));
      // New transaction request from client app., add it to the transaction queue.
      var xml = new xmldoc.XmlDocument(body);
      var header = xml.childNamed('header');
      var data = xml.childNamed('data');
      var rpcio = self.router.pkt_get();
      var hostport = Net.port_of_param(params.hostport);
      var buf = Buf.Buffer(Conn.getData(header));
      Buf.buf_get_hdr(buf, rpcio.header);
      Io.log((log < 2) || (('[BTTP] post: ' + Net.Print.header(rpcio.header))));
      rpcio.init(Rpc.Operation.TRANSREQ, rpcio.header, Conn.getData(data));
      rpcio.context=undefined;  // rpc not from here!
      rpcio.tid = Perv.int_of_string(params.tid);
      rpcio.hostport = hostport;
      // if (local request) service ..
      self.router.add_host(rpcio.hostport,self.rpccon.port);
      self.router.route(rpcio);
      // TBD: Check for local waiting servers in routing_db...
      //res.
      self.send(res, 'EWOULDBLOCK');
  });
};

Server.prototype.reply = function (self, params, req, res) {    // HTTP Callback handler
  /*************************
   * Transaction Reply
   ************************/
  var body;
  /*
   ** Reply for a transaction must be forwarded to the transaction origin collected by the source host application and
   ** the next http get/?rpc=request request.
   */
  req.setEncoding('utf8');
  body='';

  req.on('data', function (chunk) {
      body=body+chunk;
  });

  req.on('end', function () {
      Io.log(((log+self.verbose) < 10)||('BODY: ' + body));
      // New transaction request from client app., add it to the transaction queue.
      var xml = new xmldoc.XmlDocument(body);
      var header = xml.childNamed('header');
      var data = xml.childNamed('data');
      var hostport = Net.port_of_param(params.hostport);
      var sendport = Net.port_of_param(params.sendport);
      var buf = Buf.Buffer(Conn.getData(header));
      var rpcio = self.router.pkt_get();
      Buf.buf_get_hdr(buf,rpcio.header);
      rpcio.init(Rpc.Operation.TRANSREP, rpcio.header, Conn.getData(data));
      rpcio.context=undefined;    // rpc not from here!
      var tid = Perv.int_of_string(params.tid);
      rpcio.tid = tid;
      rpcio.hostport = hostport;
      rpcio.sendport = sendport;

      Io.log(((log+self.verbose) < 2)||('[BTTP] post: got reply, hostport=' +
              Net.Print.port(hostport) + ' tid=' + tid + ' srvport=' + Net.Print.port(rpcio.header.h_port)));
      self.router.route(rpcio);
      //res.
      self.send(res,'STD_OK');
  });
};

Server.prototype.put = function (self, req, res) {
  var params = Conn.parseQueryString(req.url);
  this.rpccon.stats.op_put++;

  Io.log(((log+self.verbose)<10)||('[BTTP] post: ' + util.inspect(params)));
  Io.log((log<10)||('[BTTP] post: STATUS=' + req.statusCode));
  Io.log((log<10)||('[BTTP] post: HEADERS=' + JSON.stringify(req.headers)));
  Io.trace(trace||('[BTTP] server put: ' + req.url));

  res.origin=req.headers.origin;

  if (params.rpc != undefined &&
      params.rpc == 'trans' &&
      params.hostport != undefined &&
      params.tid != undefined) {
      Sch.ScheduleCallback([Sch.Bind(self,self.trans),self,params,req,res]);
   } else if (params.rpc != undefined &&
      params.rpc == 'reply' &&
      params.hostport != undefined &&
      params.tid != undefined) {
      Sch.ScheduleCallback([Sch.Bind(self,self.reply),self,params,req,res]);
  } else
      //res.
      self.send(res,'EINVALID');
};


Server.prototype.init = function () {
  var self = this;
  this.https = http.createServer(function(request, response) {
      //Io.inspect(request);
      String.match(request.method,[
          ['GET',function() {
              self.get(self,request,response);
          }],
          ['POST',function() {
              self.put(self,request,response);
          }]
      ])
  });
  this.https.on("connection", function (socket) {
      socket.setNoDelay(true);
  });
  this.https.on("error", function (er) {
    Io.out('[BTTP] listen: listening on * ' + self.srv_ipport+' failed: '+er);
  });
  this.router.add_conn(self.rpccon);
};

/**
 *
 * @param {number} [interval]
 */
Server.prototype.start = function (interval) {
  var self = this;
  if (!interval) interval=1000;
  /*
  ** Start a client service and garbage collector for blocked client-side transactions (self.client_queue)
   */
  Sch.AddTimer(interval, 'Broker Client Service and Garbage Collector', function (context) {
      Io.log(((log+self.verbose)<4)||('[BTTP] Client Service and Garbage Collector'));
      if (!self.lock) {
          self.lock = true;

          self.client_queue = Array.filter(self.client_queue, function (client) {
              var msgn=0;
              var body='';
              var trans,hdr,buf;
              client.timeout=client.timeout-interval;
              Io.log((self.router.monitor < 2) || ('[BTTP] GC for host ' + Net.Print.port(client.hostport)+
                  ' #trans='+ Array.length(self.router.trans_queue)+' #lookup='+Array.length(self.router.lookup_queue)));
              do {
                  trans = self.router.lookup_trans_for_host(client.hostport);
                  Io.log(((log+self.verbose)<10)||('[BTTP] GC: lookup_trans_for_host=' + util.inspect(trans)));
                  if (trans != undefined) {
                      Io.log(((log+self.verbose)<1)||('[BTTP] GC: found trans=' + Rpc.Print.rpcio(trans)));

                      if (trans.operation == Rpc.Operation.TRANSREQ) {
                          body = body + trans.to_xml('rpc');
                          msgn++;

                      } else if (trans.operation == Rpc.Operation.TRANSREP) {
                          // Transaction reply!
                          body = body + trans.to_xml('rpc');
                          msgn++;
                      }
                  }
              } while (trans != undefined);
              // Add all pending server port LOOKUP requests...
              for (var i in self.router.lookup_queue) {
                  var lookup = self.router.lookup_queue[i];
                  // TODO: should we retransmit lookup requests here?
                  var cache = self.router.lookup_cache[i];
                  if (cache[client.hostport]==undefined) {
                      cache[client.hostport] = 1;
                      buf = Buf.Buffer();
                      Buf.buf_put_port(buf, lookup.header.h_port);
                      body = body + '<rpc operation="LOOKUP" hostport="' + Net.port_to_str(self.hostport) + '">' +
                      Buf.buf_to_hex(buf) + '</rpc>';
                      msgn++;
                  }
              }
              if (msgn>0) {
                  body = '<xml>' + body + '</xml>';
                  self.send(client.respond,body);
                  return false;
              } else if (client.timeout<=0) {
                  body = 'ENOENTR';
                  self.send(client.respond,body);
                  return false;
              } else return true;
          });

          self.lock = false;
      } else {
          context.blocked=false;
          context.timer=Sch.time;
          Sch.ScheduleNext();
      }
  });

  this.https.listen(this.srv_ipport, function () {
        Io.out('[BTTP] listen: listening on *:' + self.srv_ipport);
    });
};
module.exports = {
  /** RCP Broker Server for client-capable-only applications
   *
   */
  // type options = {hostport:port,srv_ip,srv_ipport,router,verbose?,env?:{}}
  Server: function(options) {
      var obj = new Server(options.hostport,options.srv_ip,options.srv_ipport,
                           options.router,options.verbose,options.env);
      Object.preventExtensions(obj);
      return obj;
  }
};