#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>

#define PORT 29012
#define SIZE (20 * sizeof(int))
#define FILEPATH "clients.bin"
#define TEXT_SIZE 1024

struct shared_data {
  int data;
  int clients[20];
};

struct queue {
    int number;
    int sent;
    char message[TEXT_SIZE];
};

struct cli_number{
    int n;
};


void goodbye(int client) {



}

int main(){

	int sockfd, ret;
	struct sockaddr_in serverAddr;
	int newSocket;
	struct sockaddr_in newAddr;
	socklen_t addr_size;
	char buffer[1024];
	pid_t childpid;
	int fd, result;
	int number=-1;

	struct shared_data *shared_clients, *child;
    struct queue *shared_queue;
    struct cli_number *ptr;
	const char *shm_name = "projekt", *name = "queue", *ptrname = "nazwa";
	int shm_fd = shm_open(shm_name, O_CREAT | O_RDWR, 0666);
    int queue_fd = shm_open(name, O_CREAT | O_RDWR, 0666);
    int desc = shm_open(ptrname, O_CREAT | O_RDWR, 0666);
	int child_fd;
	ftruncate(shm_fd, sizeof(struct shared_data));
    ftruncate(queue_fd, sizeof(struct queue));
    ftruncate(desc, sizeof(struct cli_number));
	shared_clients = mmap(0, sizeof(struct shared_data), PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
    shared_queue = mmap(0, sizeof(struct queue), PROT_READ | PROT_WRITE, MAP_SHARED, queue_fd, 0);
    ptr = mmap(0, sizeof(struct cli_number), PROT_READ | PROT_WRITE, MAP_SHARED, desc, 0);
	if (shared_clients == MAP_FAILED) {
		printf("mmap - failed.\n");
		return -1;
	}
    if (shared_queue == MAP_FAILED) {
		printf("mmap queue - failed.\n");
		return -1;
	}
    if (ptr == MAP_FAILED) {
		printf("mmap ptr - failed.\n");
		return -1;
	}
	shared_clients->data = -1; //zmieniałam z 0 na -1, żeby pętla zaczęła klientów numerować od 0 jak w normalnej tablicy
    shared_queue->number= -1;
    shared_queue->sent=-1;
    ptr->n = 0;


	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd < 0){
		printf("Error in connection.\n");
		exit(1);
	}
	printf("Server Socket is created.\n");

	memset(&serverAddr, '\0', sizeof(serverAddr));
	serverAddr.sin_family = AF_INET;
	serverAddr.sin_port = htons(PORT);
	serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);

	ret = bind(sockfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
	if(ret < 0){
		printf("Error in binding.\n");
		exit(1);
	}
	printf("Bind to port %d\n", PORT);

	if(listen(sockfd, 10) == 0){
		printf("Listening....\n");
	}else{
		printf("Error in binding.\n");
	}


	while(1){

		newSocket = accept(sockfd, (struct sockaddr*)&newAddr, &addr_size);
		if(newSocket < 0){
			exit(1);
		}
		ptr->n++;

		shared_clients->data++; ///zwiększam liczbę otwartych socketów
        printf("Connection accepted from %s:%d\n", inet_ntoa(newAddr.sin_addr), ntohs(newAddr.sin_port));
		shared_clients->clients[data] = newSocket; //zmieniłam z clients[ptr->n -1] na clients[data], co bardziej logiczne xd
		shared_clients->clients[data+1] = 0; //żeby w algorytmie czyszczenia tablicy po kliencie mogło wszystko działać

		//shared_clients->data = ptr->n;
        printf("socket: %d\n", newSocket);
		if((childpid = fork()) == 0){
            int my_number = ptr->n; //zmieniłam z prt->n na clients[data] (mogłoby tż być newSocket), żeby klient pamiętał swój socket
            int pid;
            close(sockfd);
            child_fd = shm_open(shm_name, O_RDONLY, 0666);
			child = mmap(0, sizeof(struct shared_data), PROT_READ , MAP_SHARED, child_fd, 0);
			if (child == MAP_FAILED) {
				printf("mmap - failed (in child).\n");
				return -1;
			}
            if((pid=fork()) == 0) {
                while(1) {

                    if(my_number == shared_clients->clients[data]) { //było == ptr->n  ma wyświetlić socket ostatniego klienta
                        if(shared_queue->number > shared_queue->sent) {
                        printf("Messages sent: %d\n", shared_queue->sent);
                        int sent = 0;

                            for(int i=0; i < shared_clients->data; i=i+1) {
                                printf("Sending %s to: %d\n", shared_queue->message, shared_clients->clients[i]);
						        sent = send(shared_clients->clients[i], shared_queue->message, 1024, 0);
                                printf("Bytes sent: %d\n", sent);

                            }
                            bzero(shared_queue->message, 1024);
                            shared_queue->sent++;
                        }
                    } else //NIE MOŻE ZRYWAĆ PĘTLI!!!
                        sleep(1);
                }
            }
            else {
                while(1) {
                    bzero(buffer, sizeof(buffer));
                    int received = 0;
                    if ((received = recv(newSocket, buffer, 1024, 0))>0) {
                        printf("Received: %d\n", received);
                        printf("%s\n", buffer);
				        if(strcmp(buffer, ":exit") == 0){
					        printf("Disconnected from %s:%d\n", inet_ntoa(newAddr.sin_addr), ntohs(newAddr.sin_port));
                            //ptr->n--;

							for(int j=0; j < shared_clients->data; j++) {

								if(shared_clients[j] == my_number){

									for (int k = shared_clients[j]; k <= shared_clients[data]; k++)

										shared_clients[k] == shared_clients[k+1];

									break;
								}
							}


							//funkcja zapełniająca dziurę w clients[]
							shared_clients->data--;
                            close(newSocket);
					        break;
				        }else{
                            shared_queue->number++;
                            printf("Will be writing message to memory\n");
                            sprintf(shared_queue->message, "%s", buffer);
                            printf("Message %s writen to memory\n", shared_queue->message);
                        }
                    }
                }
            }
		}
	}

	close(newSocket);

	return 0;
}