#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <errno.h>
#include <sys/select.h>
#include <cstdio>
#include <cstdlib>
#include <strings.h>
#include <string.h>
#include <vector>
#include <unistd.h>

using namespace std;
	
vector<int> clients;
int listen_sock;

void close_descriptors()
{
	//Close the listening socket
	close(listen_sock);
	
	//Close sockets for all the clients
	for (int i=0; i<clients.size(); ++i) {
		close(clients[i]);
	}
}

int new_connection(int listen_sock)
{
	//Prepare an address structure to track incoming requests
	struct sockaddr_in addr;
	socklen_t size = sizeof(addr);

	//Clear out the address structure
	bzero(&addr, sizeof(addr));

	//Accept the connection, putting client's address and port information into "addr"
	int new_sock = accept(listen_sock, (struct sockaddr *)&addr, &size);

	//Convert the address structure into a printable string
	char ip_string[INET_ADDRSTRLEN];
	inet_ntop(AF_INET, &addr.sin_addr, ip_string, INET_ADDRSTRLEN);

	//Print out a connection message
	printf("Received a connection from %s on port %d\n", ip_string, ntohs(size));

	//Add to the list of clients
	clients.push_back(new_sock);

	//Return the new descriptor
	return new_sock;
}


int main(int argc, char* argv[])
{
	//Create a socket
	int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
	if (listen_sock < 0) {
		perror("socket");
		exit(-1);
	}	

	//Create an address structure for binding to the "wildcard "ddress
	struct sockaddr_in addr;
	bzero(&addr, sizeof(sockaddr_in));
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = htonl(INADDR_ANY);
	addr.sin_port = htons(7100);

	//Bind the listening socket to the wildcard address
	int result = bind(listen_sock, (struct sockaddr *)&addr, sizeof(addr));
	if (result < 0) {
		perror("bind");
		close(listen_sock);
		exit(-1);
	}
	
	//Enter the "listening" state (queue up to 4 incoming connections)
	result = listen(listen_sock, 4);
	if (result < 0) {
		perror("listen");
		close(listen_sock);
		exit(-1);
	}

	//Initialize a file descriptor set
	fd_set fds;
	FD_ZERO(&fds);

	//Add standard input and the listen socket to the set
	FD_SET(STDIN_FILENO, &fds);
	FD_SET(listen_sock, &fds);

	//Initial maxfd is the listening socket (stdin is usually 0)
	int maxfd = listen_sock;

	//Set the keypress character to an initial default
	char keypress = '\n';

	//Loop until the user presses "q" to quit the server	
	while (keypress != 'q') {

		//Make a copy of the file descriptor set, because select modifieds its parameters
		fd_set copy_fds = fds;

		//Listen for incoming data on any of the sockets (and stdin)
		result = select(maxfd+1, &copy_fds, NULL, NULL, NULL);

		//If an error occurs, print an error message, close the file descriptors, and quit.
		if (result < 0) {
			perror("select");
			close_descriptors();
			exit(-1);
		}

		//If the user pushed a key (and hit enter, since stdin is buffered), close descriptors (and quit, since the loop condition is false).
		if (FD_ISSET(STDIN_FILENO, &copy_fds)) {	
			scanf("%c", &keypress);	
			close_descriptors();
		}

		//If there is data on the listening socket, a new connection has arrived.  Handle it!
		if (FD_ISSET(listen_sock, &copy_fds)) {
			//Call the "new_connection" function
			int new_socket = new_connection(listen_sock);

			//Add the new connection to the fd set
			FD_SET(new_socket, &fds);

			//Update maxfd
			if (new_socket > maxfd)
				maxfd = new_socket;
		}

		//Loop through all the clients to see if they have sent a message.
		for (int i=0; i<clients.size();++i) {
			if (FD_ISSET(clients[i], &copy_fds)) {
				char buf[1024];
				//Read up to 1024 bytes from the client
				int bytes = read(clients[i], buf, 1023);
				if (bytes < 0) {
					//If an error occurs, print a message, but only close THAT client.
					perror("read");
					close(clients[i]);
				}
				//Add the C-string null terminator
				buf[bytes] = 0;

				//If so, loop through all the clients and send them the message.
				for (int j=0;j<clients.size();++j) {
					//Send to all other clients
					bytes = write(clients[j], buf, strlen(buf));
					if (bytes < 0) {
						perror("write");
						close(clients[j]);
					}
				}
			}
		}
	}
}