#include "connection_handler.h"
#include <utility>
#include <NGLLogger/NGLLoggerBootstrap.h>

#include "client_connection.h"

#include <QtWebSockets/QWebSocketServer>
#include <QtWebSockets/QWebSocket>

using namespace CombatNetRadio::WebSocketInterface::Connection;

ConnectionHandler::ConnectionHandler() : m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
  , m_server(nullptr) {
}

ConnectionHandler::~ConnectionHandler()
{
  for (auto s : std::as_const(m_connections))
    s->disconnect(this);
  qDeleteAll(m_connections);
}

bool ConnectionHandler::init()
{
  if (m_server != nullptr)
  {
    m_server->disconnect();
    delete m_server;
  }
  
  
  m_server = new QWebSocketServer(QStringLiteral("RDE-EXC"), QWebSocketServer::NonSecureMode, this);

  connect(m_server, &QWebSocketServer::newConnection, this, &ConnectionHandler::onNewConnection);
  connect(m_server, &QWebSocketServer::serverError, this, &ConnectionHandler::onServerError);

  
  quint16 port = 2081;
  DEBUG_LOG(m_logger) << "Trying to listen to port " << port;
  if (!m_server->listen(QHostAddress::Any, port))
  {
    ERROR_LOG(m_logger) << "Not possible to listen to port " << port;
    return false;
  }
  DEBUG_LOG(m_logger) << "... ok";

  return true;
}

void ConnectionHandler::onUpdate()
{
  emit clearFrequencyPlanningStatus();
  for (ClientConnection *currentConnection : std::as_const(m_connections))
    currentConnection->addMessage(Messages::UpdateMessage());
}

void ConnectionHandler::onNewMessage(CombatNetRadio::WebSocketInterface::Messages::MessageTransmitter *transmitter, const QString &message)
{
  emit newTextMessageFromClient(transmitter, message);
}

void ConnectionHandler::onServerError(QWebSocketProtocol::CloseCode closeCode)
{
  ERROR_LOG(m_logger) << "Got server error with close code " << closeCode;
}

void ConnectionHandler::onNewConnection()
{
  while (m_server->hasPendingConnections())
  {
    QWebSocket       *socket = m_server->nextPendingConnection();
    ClientConnection *newConnection = new ClientConnection(socket, this);

    if (!newConnection->init())
    {
      ERROR_LOG(m_logger) << "Failed to initialise new client";
      delete newConnection;
      newConnection = nullptr;
      continue;
    }

    connect(newConnection, &ClientConnection::newTextMessage, this, &ConnectionHandler::onNewMessage);
    connect(newConnection, &ClientConnection::disconnected, this, &ConnectionHandler::onDisconnected);

    m_connections.append(newConnection);
    DEBUG_LOG(m_logger) << "New client with ip " << newConnection->ip().toString() << " connected";
    emit newClientConnection((qint64) static_cast<WebSocketInterface::Connection::ClientConnection::MessageTransmitter*>(newConnection));
  }
}

void ConnectionHandler::onDisconnected(ClientConnection *conn)
{
  bool   removeCount = m_connections.removeOne(conn);
  Q_ASSERT(removeCount == 1);
  conn->deleteLater(); 

  emit clientConnectionClosed((qint64) static_cast<WebSocketInterface::Connection::ClientConnection::MessageTransmitter*>(conn));
  if (m_connections.empty())
    emit lastConnectionClosed();
}

void ConnectionHandler::onPositions(const CombatNetRadio::WebSocketInterface::Messages::ReplyMessage &positionsCnr)
{
  for (ClientConnection *currentConnection : std::as_const(m_connections))
    currentConnection->addMessage(positionsCnr);
}