#include "JC_socketWrapper.h"

//#define JC_DEBUG

const static int JC_MAX_MESSAGE_SIZE = 536870900; // 1/2 gibibyte

//IPv4 TCP
int createServerSocket(int portNumber, int *outputServerSocket) {
    int temp;

    *outputServerSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (*outputServerSocket < 0) { perror("tcp server socket() failed."); return -1;}

    struct sockaddr_in serverAddress;
    memset(&serverAddress, 0, sizeof(serverAddress));
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddress.sin_port = htons(portNumber);

    temp = bind(*outputServerSocket, (struct sockaddr*) &serverAddress, sizeof(serverAddress));
    if (temp < 0) { perror("tcp bind() failed."); return -1; }

    temp = listen(*outputServerSocket, LISTENQ);
    if (temp < 0) { perror("listen() failed."); return -1; }

    return 0;
}

int acceptClient(int serverSocketFd, int *clientSocket) {
    ATTEMPT_ACCEPT:
    //                  V &output client address, and &socklen_t (sizeof(addr))
    *clientSocket = accept(serverSocketFd, (struct sockaddr*) NULL, NULL);
    if (*clientSocket < 0) {
        if (errno == EINTR) goto ATTEMPT_ACCEPT;
        perror("accept() failed. "); return -1;
    }

    return 0;
}

int connectToAddress(char *ipAddress, int portNumber, int *outputConnectedSocket) {
    int temp;

    // create socket
    *outputConnectedSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (*outputConnectedSocket < 0) { perror("connecting tcp socket() failed. "); return -1; }

    // initialize serverAddress
    struct sockaddr_in serverAddress;
    memset(&serverAddress, 0, sizeof(serverAddress));
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_port = htons(portNumber);

    temp = inet_pton(AF_INET, ipAddress, &serverAddress.sin_addr); //presentation to numeric
    if (temp <= 0) { perror("inet_pton() failed. "); return -1; }

    // connect to server
    temp = connect(*outputConnectedSocket, (struct sockaddr*) &serverAddress, sizeof(serverAddress));
    if (temp < 0) { perror("connect() failed. "); return -1; }

    return 0;
}

int sendStringToSocket(int socketFd, const unsigned char *buffer, int len) {
    #ifdef JC_DEBUG
        //printf("sendStringToSocket buffer: %s\n", buffer);
        printf("sendStringToSocket len: %d\n", len);
    #endif

    if(writeInt32ToSocket(socketFd, len)) return -1;
    if(writeToSocket(socketFd, buffer, len)) return -1;
    return 0;
}

// malloc(size of incoming string) - must be freed
// can return 1 on connection closed
int recvStringFromSocket(int socketFd, unsigned char **buffer, int *length) {
    #ifdef JC_DEBUG
        *length = 0;
    #endif

    int temp;
    temp = readInt32FromSocket(socketFd, length);
    if (temp) {
        if (temp != 1) printf("readInt32FromSocket() returning error value: %d\n", temp);
    #ifdef JC_DEBUG
        else printf("readInt32FromSocket() returning error value: %d\n (0 is tcp disconnect)", temp);
    #endif

        return temp;
    }
    else if (*length > JC_MAX_MESSAGE_SIZE) {
        printf("Warning: recvStringFromSocket() tried to read a message larger than MAX_MESSAGE_SIZE\n");
        return -1;
    }
    *buffer = malloc(*length);
    temp = readFromSocket(socketFd, *buffer, *length);
    if (temp) {
        free(*buffer);
        *buffer = 0;
        return temp;
    }

    #ifdef JC_DEBUG
        //printf("recvStringFromSocket buffer: %s\n", *buffer);
        printf("recvStringFromSocket len: %d\n", *length);
    #endif

    return 0;
}

int closeSocket(int *socketFd) {
    int temp = close(*socketFd);
    if (temp < 0) { perror("close() failed. "); return -1; }

    *socketFd = 0;

    return 0;
}

int shutdownSocket(int socketFd, int option) {
    int temp = shutdown(socketFd, option);
    if (temp < 0) { perror("shutdown() failed"); return -1; }

    // This lead to bugs given that it wasn't obvious I was changing the value
    // Although it "should" be from the pointer value its too easy to overlook
    //*socketFd = 0;

    return 0;
}

int readFromSocket(int socketFd, unsigned char *buffer, int bytesLeftToRead) {
    int bytesJustRead;

    while (bytesLeftToRead) {
        bytesJustRead = read(socketFd, buffer, bytesLeftToRead);

        if (!bytesJustRead) {
            // Tcp connection closed.
            return 1;
        }
        else if (bytesJustRead < 0) {
            if (errno == EINTR) bytesJustRead = 0;
            else { perror("read() failed. "); return -1; }
        }

        buffer += bytesJustRead;
        bytesLeftToRead -= bytesJustRead;
    }

    return 0;
}

int writeToSocket(int socketFd, const unsigned char *buffer, int bytesToWrite) {
    int bytesJustWritten;

    while (bytesToWrite) {
        bytesJustWritten = write(socketFd, buffer, bytesToWrite);

        if (bytesJustWritten < 1) {
            if (errno == EINTR && bytesJustWritten < 0) bytesJustWritten = 0;
            else { perror("write() failed. "); return -1; }
        }

        buffer += bytesJustWritten;
        bytesToWrite -= bytesJustWritten;
    }

    return 0;
}

int writeInt32ToSocket(int socketFd, int32_t numberToWrite) {
    union {
        unsigned char asChar[sizeof(int32_t)];
        int32_t asInt32;
    } result;
    result.asInt32 = htonl(numberToWrite);
    return writeToSocket(socketFd, (const char *) result.asChar, sizeof(int32_t));
}

int readInt32FromSocket(int socketFd, int32_t *numberRead) {
    union {
        unsigned char asChar[sizeof(int32_t)];
        int32_t asInt32;
    } result;
    int temp = readFromSocket(socketFd, result.asChar, sizeof(int32_t));
    *numberRead = ntohl(result.asInt32);

    return temp;
}

// UDP
int bindUDPPort(int portNumber, int *outputSocket) {
    *outputSocket = socket(AF_INET, SOCK_DGRAM, 0);
    if (*outputSocket < 0) { perror("UDP socket() failed. "); return -1; }

    struct sockaddr_in serverAddress;
    memset(&serverAddress, 0, sizeof(serverAddress));
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddress.sin_port = htons(portNumber);

    int temp = bind(*outputSocket, (struct sockaddr*) &serverAddress, sizeof(serverAddress));
    if (temp < 0) { perror("udp bind() failed."); return -1; }

    return 0;
}

// Linux Stuff
int setSignalHandler(int signalType, void (*handler) (int)) {
    int temp;

    struct sigaction action;
    action.sa_handler = handler;
    action.sa_flags = 0;
    sigemptyset(&action.sa_mask);

    temp = sigaction(signalType, &action, NULL);
    if (temp < 0) {perror("sigaction() failed. "); return -1; }
}

void basic_SIGCHLD_Handler(int signo) {
    int pid, status;
    // -1 is first child to terminate, WNOHANG means don't block if theres no children to wait for
    do {
        pid = waitpid(-1, &status, WNOHANG);
        //if (pid != -1) printf("Child %d terminated, returning %d\n", pid, status);
    } while (pid > 0);
    return;
}

int wrappedSelect(int *numberSocketsReady, int maxfd, fd_set *setForSelect) {
    SELECT_ATTEMPT:
    *numberSocketsReady = select(maxfd + 1, setForSelect, NULL, NULL, NULL);
    if (*numberSocketsReady < 0) {
        if (errno == EINTR) goto SELECT_ATTEMPT;
        perror("select() failed. ");
        return -1;
    }
}