/*
 * Connection.cpp
 *
 * Copyright (C) 2008 Matthias Schiffer <matthias@gamezock.de>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "Connection.h"
#include "IPAddress.h"
#include <cstring>
#include <sys/socket.h>

namespace Mad {
namespace Net {

void Connection::doHandshake() {
  if(state != HANDSHAKE)
    return;

  int ret = gnutls_handshake(session);
  if(ret < 0) {
    if(ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN)
      return;

    // TODO: Error
    doDisconnect();
    return;
  }

  state = CONNECTION_HEADER;
  connectionHeader();
}

void Connection::doBye() {
  if(state != BYE)
    return;

  int ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
  if(ret < 0) {
    if(ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN)
      return;

    // TODO: Error
    doDisconnect();
    return;
  }

  doDisconnect();
}

void Connection::packetHeaderReceiveHandler(const void *data, unsigned long length) {
  if(state != PACKET_HEADER)
      return;

  if(length != sizeof(Packet::Data)) {
    // TODO: Error
    doDisconnect();
    return;
  }

  header = *reinterpret_cast<const Packet::Data*>(data);

  if(header.length == 0) {
    signal(this, Packet(static_cast<Packet::Type>(header.type), header.requestId));

    enterReceiveLoop();
  }
  else {
    state = PACKET_DATA;
    rawReceive(header.length, sigc::mem_fun(this, &Connection::packetDataReceiveHandler));
  }
}

void Connection::packetDataReceiveHandler(const void *data, unsigned long length) {
  if(state != PACKET_DATA)
    return;

  if(length != header.length) {
    // TODO: Error
    doDisconnect();
    return;
  }

  signal(this, Packet(static_cast<Packet::Type>(header.type), header.requestId, data, length));

  enterReceiveLoop();
}

void Connection::doReceive() {
  if(!isConnected())
    return;

  if(receiveComplete())
    return;

  ssize_t ret = gnutls_record_recv(session, transR.data+transR.transmitted, transR.length-transR.transmitted);

  if(ret < 0) {
    if(ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN)
      return;

    // TODO: Error
    doDisconnect();
    return;
  }

  transR.transmitted += ret;

  if(receiveComplete()) {
    // Save data pointer, as transR.notify might start a new reception
    unsigned char *data = transR.data;
    transR.data = 0;

    transR.notify(data, transR.length);

    delete [] data;
  }
}

bool Connection::rawReceive(unsigned long length,
    const sigc::slot<void,const void*,unsigned long> &notify)
{
  if(!isConnected())
    return false;

  if(!receiveComplete())
    return false;

  transR.data = new unsigned char[length];
  transR.length = length;
  transR.transmitted = 0;
  transR.notify = notify;

  return true;
}

void Connection::doSend() {
  if(!isConnected())
    return;

  while(!sendQueueEmpty()) {
    ssize_t ret = gnutls_record_send(session, transS.front().data+transS.front().transmitted,
        transS.front().length-transS.front().transmitted);

    if(ret < 0) {
      if(ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN)
        return;

      // TODO: Error
      doDisconnect();
      return;
    }

    transS.front().transmitted += ret;

    if(transS.front().transmitted == transS.front().length) {
      delete [] transS.front().data;
      transS.pop();
    }
  }
}

bool Connection::rawSend(const unsigned char *data, unsigned long length) {
  if(!isConnected())
    return false;

  Transmission trans = {length, 0, new unsigned char[length], sigc::slot<void,const void*,unsigned long>()};
  std::memcpy(trans.data, data, length);
  transS.push(trans);

  return true;
}

void Connection::sendReceive(short events) {
  if(events & POLLHUP || events & POLLERR) {
    doDisconnect();
    return;
  }

  if(state == HANDSHAKE) {
    doHandshake();
    return;
  }

  if(state == BYE) {
    doBye();
    return;
  }

  if(events & POLLIN)
    doReceive();

  if(events & POLLOUT)
    doSend();

  if(state == DISCONNECT && sendQueueEmpty())
    bye();
}

void Connection::doDisconnect() {
  if(!isConnected())
    return;

  shutdown(sock, SHUT_RDWR);
  close(sock);

  gnutls_deinit(session);

  if(peer)
    delete peer;
  peer = 0;

  state = DISCONNECTED;
}

struct pollfd Connection::getPollfd() const {
  struct pollfd fd = {sock, (receiveComplete() ? 0 : POLLIN) | (sendQueueEmpty() ? 0 : POLLOUT), 0};

  if(state == HANDSHAKE || state == BYE)
    fd.events = ((gnutls_record_get_direction(session) == 0) ? POLLIN : POLLOUT);

  return fd;
}

}
}