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

#define FRAGMENT_NUM 2
#define CHECKSUM 6
#define DATA 10
#define ACK_TYPE 2
#define KAP_TYPE 1
#define MSG_TYPE 0
#define MAX_TWO_CHARS 65535
#define SERVER "127.0.0.1"
#define MAX_FD 2
#define STDIN 0

//--------------------------------------------------------------//


typedef struct fragment{
    int current_number;
    u_char *data;
    struct fragment *next;
    struct fragment *prev;
}Fragment;


//--------------------------------------------------------------//

int debug = 1;

//-------------------------------------------------------------//

int get_size(u_char *datagram);

int type_of_packet(u_char *datagram);

int get_current_number(u_char *datagram);

int settings();

int crc32(u_char *datagram);

int open_socket();

int close_socket();

int send_kap();

int send_ack(int s, struct sockaddr_in *s_client, int slen);

int server(int port);

int client(int ip_address, int port, int *fragment_size);

int send_handshake(int s, int *size, struct sockaddr_in *s_client, int slen);

int recieve_handshake(int s, struct sockaddr_in *s_client, int slen, int *fragment_size);

void main_menu();

void print_s_menu();

void print_c_menu();

//--------------------------------------------------------------//


int main (){
    int fragment_size;
    int port = 10002;
    // int role;
    // int ip_address;
    // Fragment *fragments;
    char control;



    main_menu();

    scanf("%c", &control);
    getchar();
    while(control != 'q'){

        if (control == 's') if (server(port) == 1) printf("chyba");

        if (control == 'c') {
            if (client(0, port, &fragment_size) == 1) printf("chyba");

        }

        main_menu();
        scanf("%c", &control);
        getchar();
    }
    printf("\n\tUkoncenie programu...\n");
    return 0;
}

//--------------------------------------------------------------//


   int get_size(u_char *datagram){

   int size = 0;
   size +=(int)datagram[0];
   size *= 256;
   size +=(int)datagram[1];
   return size;
   }

   int type_of_packet(u_char *datagram){

   if (get_size(datagram) == 0) return ACK_TYPE;
   if (get_size(datagram) == MAX_TWO_CHARS) return KAP_TYPE;
   return MSG_TYPE;
   }

   int get_current_number(u_char *datagram){
   int num = 0;
   num =*(int*)(datagram[FRAGMENT_NUM]);
   return num;
   }

/*
   int settings(){

   return 0;
   }


   int crc32(u_char *datagram){

   return 0;
   }


   int open_socket(){

   return 0;
   }


   int close_socket(){

   return 0;
   }

   int send_kap(){

   return 0;
   }


*/

int server(int port){

    struct sockaddr_in s_server, s_client;
    int sock, recv_len;
    int slen = sizeof(s_client);
    fd_set rset, fds;
    ssize_t n;
    struct timeval tv;
    u_char data[1500], buf[5], control;
    int buflen = 1500;
    int r;
    //int msg_len;
    int frag_size = 1000;
    // nastavenie UDP SOCKETU
    Fragment *last, *first, *cur;


    printf("Pouzivate program ako server\n");

    if ((sock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) return 1;
    //	vynulovanie
    memset((char *) &s_server, 0, sizeof(s_server));

    s_server.sin_family = AF_INET;
    s_server.sin_port = htons(port);
    s_server.sin_addr.s_addr = htonl(INADDR_ANY);

    // bindovanie
    if (bind(sock , (struct sockaddr*)&s_server, sizeof(s_server)) == -1) return 1;

    // pocuvanie

    fflush(stdout);
    /*if ((recv_len = recvfrom(sock, data, buflen, 0, (struct sockaddr*)&s_client, &slen)) == -1){
        return 1;
    }*/


    //frag_size = get_size(data);
    print_s_menu();



    while (control != 'q'){
        buf[0]= 'a';
       FD_ZERO(&fds);
        FD_SET(0, &fds);
        FD_SET(sock, &fds);
        rset = fds;
        tv.tv_sec = 2;
        tv.tv_usec = 0;
        select(sock+1, &rset, NULL, NULL, &tv);

        if( FD_ISSET(STDIN, &rset)){
            // stdin
           r = read(0, buf, sizeof(buf));
            buf[r-1] = '0';
            if (buf[0] =='q') control = buf[0];
            if (buf[0]=='s') {
                fprintf(stdout," Velkost fragmentu je %d B\n", frag_size);
            }
            if (buf[0]=='h') print_s_menu();

            }


        else if (FD_ISSET(sock, &rset)){

            recieve_handshake(sock, &s_client, slen, &frag_size);
            send_handshake(sock, &frag_size, &s_client, slen);
            recvfrom(sock,buf, frag_size, 0, &s_client, slen);
            while (type_of_packet(buf) != ACK_TYPE){
                //crc

                fprintf(stdout,"%s", qbuf+DATA);
                send_ack(sock, &s_client, slen);
                //parse_dgram(buf[DATA],last);
                recvfrom(sock,buf, frag_size, 0, &s_client, slen);
            }

            cur = last;
           /* while (cur->prev != NULL)cur = cur->prev;

            while (cur != NULL) {
                write(1, cur->data, frag_size);
                cur = cur->next;
            }*/

//            write(1, data, recv_len+1);
           // send_ack(sock, buf, recv_len, &s_client, slen);
        }
        //else send_ack(sock, "ACK", 5, &s_client, slen);
     }


    printf("Ukoncili ste pracu servera\n");
    close(sock);
    return 0;
}


int client(int ip_address, int port, int *fragment_size){

    struct sockaddr_in s_server;
    int sock;
    int handshake_control;
    int slen = sizeof(s_server);
    char buf[256];
    int buflen = 256;
    char control ='a';
    fd_set rset, fds;
    ssize_t n;
    struct timeval tv;
    printf("\nPouzivate program ako klient");
    *fragment_size = 2;

    if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) return 1;

    memset((char *) &s_server, 0, sizeof(s_server));
    s_server.sin_family = AF_INET;
    s_server.sin_port = htons(port);

    if ( inet_aton(SERVER, &s_server.sin_addr) == 0 ) {
        printf("ajaj");
        return 1;
    }
    //sendto(sock,"ahoj", 4, 0, (struct sockaddr *) &s_server, slen);
   //rread(0, buf, buflen);
    //while ()


    print_c_menu();

    while (control!='q'){
        control = 'a';
        FD_ZERO(&fds);
        FD_SET(0, &fds);
        FD_SET(sock, &fds);
        rset = fds;
        tv.tv_sec = 2;
        tv.tv_usec = 0;
        select(sock+1, &rset, NULL, NULL, &tv);

        if( FD_ISSET(STDIN, &rset)){
            // stdin
            scanf("%c", &control);
            getchar();

            if (control=='s') {
                fprintf(stdout," Velkost fragmentu je %d B\n", *fragment_size);
            }
            if (control=='h') print_c_menu();
            if (control=='t') {
                FD_ZERO(&fds);
                FD_SET(0, &fds);
                FD_SET(sock, &fds);
                rset = fds;
                tv.tv_sec = 200;
                tv.tv_usec = 0;
                select(sock+1, &rset, NULL, NULL, &tv);
                send_handshake(sock, fragment_size, &s_server, slen);
                recieve_handshake(sock,&s_server, slen, &handshake_control);
               // if (handshake_control == *fragment_size) fprintf(stdout, "\nhandshaked");
                send_text(sock, &s_server, *fragment_size, slen);
            }
            }
    }

//  recvfrom(sock, buf, buflen, 0, (struct sockaddr*)&s_server, &slen);

    //puts(buf);

    close(sock);
    return 0;
}


int send_ack(int s, struct sockaddr_in *s_client, int slen){
    u_char ack[10];
    ack[0] = 0/256;
    ack[1] = 0%256;

    sendto(s, ack, 10 ,0, (struct sockaddr*) s_client, slen);
    return 0;
}


int send_text(int s, struct sockaddr_in *s_client, int fragment_size, int slen){

	char *msg;
    char ack[10];
	msg = (char *) malloc(10+fragment_size*sizeof(char));
    int cur_num=1;
    int r;
     r = read(0, msg+10, fragment_size);
	while ( r != 0 ){
        *(int*)(msg+FRAGMENT_NUM) = cur_num;
        msg[0] = fragment_size/256;
        msg[1] = fragment_size%256;
        // crc
	    while (type_of_packet(ack) != ACK_TYPE) {
            sendto(s, msg, 10 + r, 0, (struct sockaddr *) s_client, slen);
            recvfrom(s, ack, 10, 0, (struct sockaddr *) &s_client, slen);
        }
        ack[0] ='e';
     if (r == fragment_size) r = read(0, msg+10, fragment_size);
        else r = 0;
        cur_num++;
    }

    send_ack(s, &s_client, slen);

return 0;
}

int parse_dgram(u_char *data, Fragment *dgram_arr){
   Fragment *cur;
    int i = 0;
    // if (crc)
            cur = (Fragment *) malloc(sizeof(Fragment));
            if (dgram_arr != NULL) dgram_arr->prev = cur;
            cur->next = dgram_arr;

            cur->data = (u_char *) malloc(get_size(data) * sizeof(u_char));

            for (i; i <= get_size(data); i++) {
                cur->data[i] = data[DATA];
            }
            cur->current_number = get_current_number(data);
            cur->prev = NULL;
            dgram_arr = cur;
    //end if crc
    //else return 1;
return 0;
}



void main_menu(){
    fprintf(stdout,"\nHLAVNE MENU:\n\n");
    fprintf(stdout,"\th -> zobrazenie hlavneho menu\n");
    fprintf(stdout,"\tc -> spustenie klienta\n");
    fprintf(stdout,"\ts -> spustenie servera\n");
    fprintf(stdout,"\tw -> nastavenia\n");
    fprintf(stdout,"\tq -> ukncenie programu\n\n");
    fprintf(stdout,"Vyberte moznost stlacenim klavesy:  \n");


}

void print_s_menu(){
    fprintf(stdout,"\nSERVER MENU:\n\n");
    fprintf(stdout,"\th -> zobrazenie serveroveho menu\n");
    fprintf(stdout,"\ts -> zobrazenie velkosti fragmentu\n");
    fprintf(stdout,"\tq -> zatvorenie servera\n\n");
    fprintf(stdout,"Vyberte moznost stlacenim klavesy:  \n");


}

void print_c_menu(){
     fprintf(stdout,"\nKLIENT MENU:\n\n");
    fprintf(stdout,"\th -> zobrazenie klientoveho menu\n");
    fprintf(stdout,"\ts -> zobrazenie velkosti fragmentu\n");
    fprintf(stdout,"\tt -> poslanie textovej spravy\n");
    fprintf(stdout,"\tq -> zatvorenie klienta\n\n");
    fprintf(stdout,"Vyberte moznost stlacenim klavesy:  \n");


}

int send_handshake(int s, int *size, struct sockaddr_in *s_client, int slen){
    u_char data[]={'0','0','0','0','0','0','0','0','0','0'};
    u_char rec_data[11];
    int recv_len;

    *(int*)(data+FRAGMENT_NUM) = 0;
    data[0] = *size/256;
    data[1] = *size%256;
    //crc
    sendto(s, data, 10, 0, (struct sockaddr *) s_client, slen);
    // recv

    return 0;
}

int recieve_handshake(int s, struct sockaddr_in *s_client, int slen, int *fragment_size){
    u_char data[10];
    u_char ret_data [11];
    if ( recvfrom(s, data, 10, 0, (struct sockaddr*) s_client, &slen) == -1){
        return 1;
    }
    //crc chceck
    *fragment_size = data[0]*256;
    *fragment_size += data[1];


    return 0;
}