#include <string.h>

#include "GlobalConfigFile.h"
#include "SimpleLogFile.h"
#include "CommandDispatcher.h"
#include "ReplyToClient.h"

#include "MultiCast.h"


// The code for the actual multicast reads and writes, in particular the
// initial setup, was inspired by
// https://gist.github.com/hostilefork/f7cae3dc33e7416f2dd25a402857b6c6

// TODO clean up a lot of sendToLogFile() statements.


/////////////////////////////////////////////////////////////////////
//
/////////////////////////////////////////////////////////////////////

// std::string::starts_with() is added in c++20.
static bool isPrefix(std::string const &prefix, std::string const &subject)
{
  char const *p = prefix.c_str();
  char const *s = subject.c_str();
  while (true)
  {
    if (!*p) return true;
    if (*p != *s) return false;
    p++;
    s++;
  }
}


/////////////////////////////////////////////////////////////////////
// MultiCast
/////////////////////////////////////////////////////////////////////

std::string MultiCast::getUserId(PropertyList const &message)
{
  return getPropertyDefault(message, "user_id");
}

void MultiCast::respond(PropertyList const &message)
{
  const std::string originalUserId = getUserId(message);
  sendToLogFile(TclList()<<FLF<<"mtMultiCast"<<originalUserId<<message);
  MultiCast const &multiCast = MultiCast::getInstance();
  PropertyList response = *multiCast.getBasicInfo();
  response[TYPE] = PING_USER + "_response";
  response["user_id"] = originalUserId;
  multiCast.sendResponse(response);
}

const std::string MultiCast::TYPE = "TYPE";

// Originally this was "PING_USER".  But there was a bug in that early
// code, and some of that got out into the wild.  If you send "PING_USER"
// to those old machines they will always respond.  I changed this to
// "PING_User" so we'll just ignore those old machines.
//
// In short:
// Send PING_User and you'll never get a false positive.
// Send PING_USER for any user and you'll get a list of servers with this bug.
const std::string MultiCast::PING_USER = "PING_User";

void MultiCast::addDebugCommands()
{
  CommandDispatcher *const cd = CommandDispatcher::getInstance();
  cd->listenForCommand("multi_cast_ping", this, mtMultiCastPing);
}

void MultiCast::handleRequestInThread(Request *original)
{
  assert(original->callbackId == mtMultiCastPing);
  ExternalRequest *const request =
    dynamic_cast<  ExternalRequest * >(original);
  const std::string userId = request->getProperty("user_id");
  PropertyList toSend;
  if (userId.empty())
    toSend[TYPE] = "PING";
  else
  {
    toSend[TYPE] = PING_USER;
    toSend["user_id"] = userId;
  }
  sendRequest(toSend);
  sendToLogFile(TclList()<<FLF<<"Requested from debug command"<<toSend);
  addToOutputQueue(request->getSocketInfo(),
		   TclList()<<toSend,
		   request->getResponseMessageId());
}

void MultiCast::serialize(std::function< void() > toDo)
{
  doWorkInThread(toDo);
}

static const int REQUEST_PORT = 1488;
static const int RESPONSE_PORT = 1489;
char const *const GROUP = "224.252.155.250";

MultiCast::MultiCast() : _sendHandle(-1), _receiveHandle(-1)
{
  _callbacksForAll.emplace();
  _callbacksByType.emplace();
  _basicInfo.emplace();
  // getConfigItem: disable_multicast=1 will disable any attempts to read
  // getConfigItem: or write to the multicast group.  This is generally not a
  // getConfigItem: good idea.  I added this just in case somehow this code
  // getConfigItem: causes problems and we need to disable it on the live
  // getConfigItem: servers quickly.
  if (getConfigItem("disable_multicast") == "1")
    return;
  addInfo("restart", ntoa(getMicroTime()));
  // getConfigItem: Search the config items for any keys that start with
  // getConfigItem: "multicast_status_".  Copy any and all matching key value
  // getConfigItem: pairs to all multicast messages that we send.  Remove
  // getConfigItem: the "multicast_status_" prefix from the key.

  const std::string PREFIX = "multicast_status_";
  for (auto kvp : getConfigItems())
    if (isPrefix(PREFIX, kvp.first))
      addInfo(std::string(kvp.first, PREFIX.length()), kvp.second);
  addCallback([=](PropertyList const &) {
      PropertyList response = *getBasicInfo();
      response[TYPE] = "PING_response";
      sendResponse(response);
    }, "PING");
  _sendHandle = socket(AF_INET, SOCK_DGRAM, 0);
  if (_sendHandle < 0)
  {
    sendToLogFile(TclList()<<FLF<<errorString()<<"socket()"<<"send");
    return;
  }

  _receiveHandle = socket(AF_INET, SOCK_DGRAM, 0);
  if (_receiveHandle < 0)
  {
    _sendHandle = -1;
    sendToLogFile(TclList()<<FLF<<errorString()<<"socket()"<<"recv");
    return;
  }
  
  // allow multiple sockets to use the same PORT number
  //
  u_int yes = 1;
  if (setsockopt(_receiveHandle, SOL_SOCKET, SO_REUSEADDR,
		 (char*) &yes, sizeof(yes)) < 0)
  {
    _sendHandle = -1;
    _receiveHandle = -1;
    sendToLogFile(TclList()<<FLF<<errorString()<<"SOL_SOCKETSOL_SOCKET"<<"SO_REUSEADDR");
    return;
  }
  
  // set up destination address
  //
  struct sockaddr_in addr;
  memset(&addr, 0, sizeof(addr));
  addr.sin_family = AF_INET;
  addr.sin_addr.s_addr = htonl(INADDR_ANY); // differs from sender
  addr.sin_port = htons(REQUEST_PORT);

  // bind to receive address
  //
  if (bind(_receiveHandle, (struct sockaddr*) &addr, sizeof(addr)) < 0)
  {
    _sendHandle = -1;
    _receiveHandle = -1;
    sendToLogFile(TclList()<<FLF<<errorString()<<"bind()");
    return;
  }

  // use setsockopt() to request that the kernel join a multicast group
  //
  struct ip_mreq mreq;
  mreq.imr_multiaddr.s_addr = inet_addr(GROUP);
  mreq.imr_interface.s_addr = htonl(INADDR_ANY);
  if (setsockopt(_receiveHandle, IPPROTO_IP, IP_ADD_MEMBERSHIP,
		 (char*) &mreq, sizeof(mreq)) < 0)
  {
    _sendHandle = -1;
    _receiveHandle = -1;
    sendToLogFile(TclList()<<FLF<<errorString()
		  <<"setsockopt()"<<"IPPROTO_IP"<<"IP_ADD_MEMBERSHIP");
    return;
  }
  start();
}

MultiCast &MultiCast::getInstance()
{
  static MultiCast *instance = new MultiCast();
  return *instance;
}

void MultiCast::addInfo(std::string const &key, std::string const &value)
{
  _basicInfo.change([key, value](PropertyList &basicInfo)
		    { basicInfo[key] = value; });
  // TODO get rid of this.  Maybe?  At least try to consolidate them so we
  // don't print a series of these.
  sendToLogFile(TclList()<<FLF<<*getBasicInfo());
}

void MultiCast::addCallback(Callback callback)
{
  _callbacksForAll.change([&](Callbacks &callbacks)
			  { callbacks.push_back(callback); });
}

void MultiCast::addCallback(Callback callback, std::string const &messageType)
{
  _callbacksByType.change([&](CallbacksByType &callbacks)
			  { callbacks[messageType].push_back(callback); });
}

void MultiCast::send(std::string const &message, int port) const
{
  if (_sendHandle < 0) return;
  struct sockaddr_in addr;
  memset(&addr, 0, sizeof(addr));
  addr.sin_family = AF_INET;
  addr.sin_addr.s_addr = inet_addr(GROUP);
  addr.sin_port = htons(port);
  int nbytes = sendto(_sendHandle,
		      message.c_str(),
		      message.length(),
		      0,
		      (struct sockaddr*) &addr,
		      sizeof(addr)
		      );
  if (nbytes < 0)
    sendToLogFile(TclList()<<FLF<<nbytes<<message);
  else
    sendToLogFile(TclList()<<FLF<<"success"<<nbytes<<message);
}

void MultiCast::send(PropertyList const &message, int port) const
{
  const std::string outgoing = urlEncode(message);
  send(outgoing, port);
}

void MultiCast::sendRequest(PropertyList const &message) const
{
  send(message, REQUEST_PORT);
}

void MultiCast::sendResponse(PropertyList const &message) const
{
  send(message, RESPONSE_PORT);
}

void MultiCast::beforeSleep(IBeforeSleepCallbacks &callbacks)
{
  if (_receiveHandle >= 0)
    callbacks.waitForRead(_receiveHandle);
}

void MultiCast::awake(std::set< int > const &woken)
{
  if ((_receiveHandle >= 0) && !woken.count(_receiveHandle))
    return;
  int count = 0;
  while (true)
  {
    ssize_t nbytes =
      recv(_receiveHandle, NULL, 0, MSG_DONTWAIT | MSG_PEEK | MSG_TRUNC);
    if (nbytes < 0)
    {
      if (!((errno == EAGAIN ) || (errno == EWOULDBLOCK)))
	sendToLogFile(TclList()<<FLF<<"recv"<<errno<<errorString());
      break;
    }
    std::string bytes(nbytes, 'P');
    nbytes = recv(_receiveHandle, &bytes[0], nbytes, MSG_TRUNC);
    if (nbytes != (ssize_t)bytes.length())
    {
      TclList msg;
      msg<<FLF<<"recv 2"<<nbytes<<bytes.length();
      if (nbytes < 0)
	msg<<errno<<errorString();     
      sendToLogFile(msg);
      break;
    }
    count++;
    sendToLogFile(TclList()<<FLF<<"success"<<nbytes<<bytes);
    onMessageReceived(bytes);
  }
  sendToLogFile(TclList()<<FLF<<"processed"<<count<<"messages");
}

void MultiCast::onMessageReceived(std::string const &raw)
{
  PropertyList request;
  parseUrlRequest(request, raw);
  // Explicitly hold onto the smart pointer until we are done with the
  // underlying data.  I'm not sure how this works for a for loop.  Normally
  // when you call _callbacksForAll.get().doSomething(); you are
  // safe because the smart pointer returned by getPointer() will not be
  // destroyed until the next semicolon.
  auto const callbacksForAll = _callbacksForAll.get();
  for (auto const &callback : *callbacksForAll)
    callback(request);
  const std::string type = getPropertyDefault(request, TYPE);
  //if (type != "")
  //{
    auto const callbacksByType = _callbacksByType.get();
    for (auto const &callback : getPropertyDefault(*callbacksByType, type))
      callback(request);
    //}
  TclList msg;
  msg<<FLF<<"callbacksForAll"<<callbacksForAll->size();
  for (auto const &kvp : *callbacksByType)
    msg<<kvp.first<<kvp.second.size();
  msg<<"[TYPE]"<<getPropertyDefault(*callbacksByType, type).size();
  sendToLogFile(msg);
}