#include <sys/socket.h>
#include <fcntl.h>
#include "includes/sock.hpp"
#include "includes/server.hpp"
#include "includes/exception_consts.hpp"
#include "includes/easysock.hpp"

/* Destructor - closes any open sockets */
Server::~Server() {
	close(this->other_socket);
	close(this->sock_fd);
}

/* Sends given data through the peer socket - This method is overriden from the
base method, because a different socket must be used. In the server's case, the
'peer' socket i.e. the socket returned after calling 'accept', must be used. */

void Server::sendAll(std::string to_send) {
	Sock::sendAll(to_send, this->other_socket);
}

/* Receives data from socket, and returns it. This function works differently
based on the Transport layer protocol used. For TCP, it calls the parent method
with the peer socket. As mentioned above, this is the socket returned after
calling the accept function. With UDP, there is no concept of a peer socket, and
so the regular server socket (the one created in create_socket() ) is used
instead. */

std::string Server::recvAll() {
	if (this->protocol == 'T') {
		return Sock::recvAll(this->other_socket);
	} else {
		return Sock::recvAll(this->sock_fd);
	}
}

/* FOR TCP ONLY - Waits for a peer to connect to the server socket. It stores
the return value of the accept() function i.e. the peer socket. This method does
nothing if your server socket is a UDP socket. If the accept function fails, the errno
is thrown as an exception. */

void Server::wait_for_peer() {
	if (this->protocol == 'T') {
		this->other_socket = accept(this->sock_fd, NULL, NULL);
		if (this->other_socket < 0) {
			throw errno;
		}
	}
}

/* Creates a server socket. This method extends the parent method, and should be
called immediately after the constructor. If the socket is TCP, it also sets the
socket to listen for incoming connections. This function throws an exception if
the socket could not be created. The excpetion is an integer corresponding to the errno
of the failing function, and enables the caller to print a corresponding error message by
'catching' the thrown exception and using strerror(). */

void Server::create_socket() {
	Sock::create_socket();
        this->sock_fd = create_local(this->ip_ver, this->protocol, this->address.data(), this->port, dest);
	if (this->sock_fd < 0) {
		throw (this->sock_fd * -1);
	}
	if (protocol == 'T') {
		listen(sock_fd, 10);
	}
}