//client.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>

#define PORT 8080
#define DATA_SIZE 64

void receive_data(void *sockfd)
{
    int *sock = (int *)sockfd;
    char receive[64] = {0};

    //while(1){
    //    recv(*sockfd, &receive, DATA_SIZE, 0);
    //    if(receive != EOF){
    //    printf("From server: %s", receive);
    //    }
    //}
            printf("Test.");
            sleep(5000);
}

void second_thread()
{
    printf("From second thread.");
    sleep(5000);
}

struct packet{
    char hostname[16];
    char msg[64];
};

void exit_error(char *msg)
{
    printf("Failed at stage: %s", msg);
    exit(1);
}

int main(void)
{
    int sockfd;
    struct sockaddr_in serv_addr;

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        exit_error("Failed to create socket.");

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    serv_addr.sin_addr.s_addr = inet_addr("some_ip");

    if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
        exit_error("Failed to connect.");

    char welcome[64] = {0};
    read(sockfd, &welcome, DATA_SIZE);
    printf("%s\n", welcome);
    fflush(stdout);

    pthread_t recv_thread;
    pthread_create(&recv_thread, NULL, receive_data, (void *)&sockfd);
    pthread_t second_thread;
    pthread_create(&second_thread, NULL, second_thread, NULL);
    pthread_join(recv_thread, NULL);
    pthread_join(second_thread, NULL);

    char transmit[64];

    while(1){
        bzero(&transmit, sizeof(transmit));
        printf("You: ");
        fflush(stdout);
        fgets(transmit, DATA_SIZE, stdin);
        send(sockfd, &transmit, sizeof(transmit), 0);
    }

    return 0;
}

//server.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <string.h>
#include <memory.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define SERVER_PORT 8080
#define DATA_SIZE 64

struct packet{
    char hostname[16];
    char msg[64];
};

struct fd_container{
    fd_set readfds;
    int fdsize;
    int state;
};

void error_exit(char *msg)
{
    printf("Failed at stage: %s", msg);
    exit(1);
}

int main()
{
    int serverfd;
    if((serverfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        error_exit("Failed to create socket.");

    struct sockaddr_in serv_addr;
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERVER_PORT);
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    memset(&serv_addr.sin_zero, '\0', 8);
    socklen_t addrlen = sizeof(serv_addr);

    if(bind(serverfd, (struct sockaddr *)&serv_addr, addrlen) < 0)
        error_exit("Failed to bind socket to address.");

    int yes = 1;
    setsockopt(serverfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));

    if((listen(serverfd, 3)) < 0)
        error_exit("Failed to listen.");

    int clientfd1 = accept(serverfd, (struct sockaddr *)&serv_addr, &addrlen);
    int clientfd2 = accept(serverfd, (struct sockaddr *)&serv_addr, &addrlen);

    if(clientfd1 < 0 && clientfd2 < 0){
        error_exit("No clients.");
    }
    else
        printf("Up and running.");

    char welcome[64] = "Connected to server.";
    send(clientfd1, &welcome, DATA_SIZE, 0);
    send(clientfd2, &welcome, DATA_SIZE, 0);

    struct fd_container fdlist;
    FD_SET(serverfd, &fdlist.readfds);
    fdlist.fdsize = clientfd2 + 1;

    char receive[64]; char transmit[64];

    while(1){
        bzero(&receive, DATA_SIZE);
        bzero(&transmit, DATA_SIZE);

        FD_ZERO(&fdlist.readfds);
        FD_SET(clientfd1, &fdlist.readfds);
        FD_SET(clientfd2, &fdlist.readfds);

        fdlist.state = select(fdlist.fdsize, &fdlist.readfds, NULL, NULL, NULL);

        switch(fdlist.state){
            case -1:
                error_exit("Failed to select.");
            case 0:
                printf("No data received in recent time period.");
                break;
            default:
                if(FD_ISSET(clientfd1, &fdlist.readfds)){
                    recv(clientfd1, &receive, DATA_SIZE, 0);
                    printf("Incoming data from client1: %s", receive);
                    strcpy(transmit, receive);
                    transmit[DATA_SIZE-1] = '\0';
                    send(clientfd2, &transmit, DATA_SIZE, 0);
                }
                if(FD_ISSET(clientfd2, &fdlist.readfds)){
                    recv(clientfd2, &receive, DATA_SIZE, 0);
                    printf("Incoming data from client2: %s", receive);
                    strcpy(transmit, receive);
                    transmit[DATA_SIZE-1] = '\0';
                    send(clientfd1, &transmit, DATA_SIZE, 0);
                }
        }
    }

    return 0;
}