#include "sender.h"
#include "converter.h"

int main(int argc, char *argv[])
{
    if (argc < 4)
    {
        printf("usage: %s file payload_size forwarders(host:port)\n", argv[0]);
        return -1;
    }

    char *file_path = argv[1];

    FILE *pFile = fopen(file_path, "rb");
    if (!pFile)
    {
        printf("error: can't find the file\n");
        return -1;
    }

    unsigned int payload_size = atol(argv[2]);
    unsigned int file_size = get_file_size(pFile);

    printf("File size %i bytes.\n", file_size);

    unsigned int buffer_size = HEADER_SIZE + payload_size;

    // Creando buffer ¿estático?
    char *buffer = malloc(buffer_size);
    memset(buffer, 0, buffer_size);

    // Campos del header
    int header_segment_size = HEADER_SIZE / 3;

    char offset_header[header_segment_size];
    char file_size_header[header_segment_size];
    char payload_size_header[header_segment_size];

    // Llenamos los segmentos del header con los datos que correspondan
    unsigned int offset = 0;

    // Guardamos los datos para el header en nuestro formato especial de 4 bytes
    convert_to_4_bytes(offset, offset_header);
    convert_to_4_bytes(file_size, file_size_header);
    convert_to_4_bytes(payload_size, payload_size_header);

    // Insertamos los segmentos en el buffer
    for(int i = 0; i < header_segment_size; i++){
        buffer[i] = offset_header[i];
        buffer[i + 4] = file_size_header[i];
        buffer[i + 8] = payload_size_header[i];
    }

    // Guardar todos los forwarder
    int number_forwarders = argc - 3;
    printf("#Forwarders: %i\n", number_forwarders);

    forwarder forwarders[number_forwarders];

    for (int i = 0; i < number_forwarders; i++)
    {
        get_host_and_port_from_string(argv[i + 3], &forwarders[i]);
    }

    int number_of_packets = 0;

    // Empezar a enviar
    int total_bytes_sent = 0;
    while (total_bytes_sent < file_size)
    {
        for (int i = 0; i < number_forwarders; i++)
        {
            forwarder frw = forwarders[i];
            printf("Sending to %s:%i\n", frw.host, frw.port);

            struct sockaddr_in stSockAddr;
            int Res;
            int SocketFD = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

            if (-1 == SocketFD)
            {
                perror("cannot create socket");
                exit(EXIT_FAILURE);
            }

            memset(&stSockAddr, 0, sizeof(struct sockaddr_in));

            stSockAddr.sin_family = AF_INET;
            stSockAddr.sin_port = htons(frw.port);
            Res = inet_pton(AF_INET, frw.host, &stSockAddr.sin_addr);

            if (0 > Res)
            {
                perror("error: first parameter is not a valid address family");
                close(SocketFD);
                exit(EXIT_FAILURE);
            }
            else if (0 == Res)
            {
                perror("char string (second parameter does not contain valid ipaddress");
                close(SocketFD);
                exit(EXIT_FAILURE);
            }

            if (-1 == connect(SocketFD, (const struct sockaddr *)&stSockAddr, sizeof(struct sockaddr_in)))
            {
                perror("connect failed");
                close(SocketFD);
                exit(EXIT_FAILURE);
            }

            // Actualizamos el tamaño del paquete
            if (payload_size > file_size - total_bytes_sent)
            {
                payload_size = file_size - total_bytes_sent;
                printf("Updating fragment size to %i...\n", payload_size);

                buffer_size = HEADER_SIZE + payload_size;

                convert_to_4_bytes(payload_size, payload_size_header);
                for(int i = 0; i < header_segment_size; i++)
                    buffer[i + 8] = payload_size_header[i];
            }

            printf("Trying to send %i Bytes to %s:%d...\n", buffer_size, frw.host, frw.port);

            int total_bytes_sent_from_fragment = 0;

            get_buffer(&buffer, payload_size, pFile, file_size, total_bytes_sent);

            while (total_bytes_sent_from_fragment < buffer_size)
            {
                int actBytesSent = send(SocketFD, buffer, buffer_size, 0);

                total_bytes_sent_from_fragment += actBytesSent;
            }

            total_bytes_sent += total_bytes_sent_from_fragment - HEADER_SIZE;

            // Actualizamos el offset
            offset += total_bytes_sent_from_fragment - HEADER_SIZE;

            convert_to_4_bytes(offset, offset_header);
            for(int i = 0; i < header_segment_size; i++){
                buffer[i] = offset_header[i];
            }

            double percentage = ((double)total_bytes_sent / file_size) * 100;
            printf("Total bytes sent: %d  %f percent\n", total_bytes_sent, percentage);

            shutdown(SocketFD, SHUT_RDWR);
            close(SocketFD);

            printf("%i. Done by now!\n", ++number_of_packets);
        }
    }

    printf("File sending completed\n");

    free(buffer);
    fclose(pFile);

    return 0;
}

long get_file_size(FILE *pFile)
{
    fseek(pFile, 0, SEEK_END);
    return ftell(pFile);
}

int get_buffer(char **buffer, int bufferSize, FILE *pFile, int file_size, int total_bytes_sent)
{
    int actBufferSize = min(file_size - total_bytes_sent, bufferSize);
    fseek(pFile, total_bytes_sent, SEEK_SET);
    fread(*buffer + HEADER_SIZE, sizeof(char), actBufferSize, pFile);
    return actBufferSize;
}

int min(int a, int b)
{
    if (a > b)
        return b;

    return a;
}

void get_host_and_port_from_string(char *arg, forwarder *frw)
{
    const char delim[] = ":";

    // La función strtok permite separar un string en varios tokens con un delimitador
    frw->host = strtok(arg, delim);

    // Con el parámetro null indicamos que queremos el siguiente token
    frw->port = atoi(strtok(NULL, delim));
}