#include "communicate.h"

STD_BLOCKS *initStandardDBlocks(SID *p_sid, unsigned int type, unsigned long long data_size){
    STD_BLOCKS *p_stdb = (STD_BLOCKS *)malloc(sizeof(STD_BLOCKS));
    if(p_sid != NULL){
        p_stdb->sid = s_idToASCIIString(p_sid);
    }
    else p_stdb->sid = NULL;
    p_stdb->if_data = 0;
    unsigned int blocks_num = (unsigned int)(data_size/sizeof(char));
    p_stdb->blocks_num = blocks_num;
    p_stdb->type = type;
    p_stdb->buff = (char *)malloc(sizeof(char) * blocks_num);
    return p_stdb;
}

int dataForStandardDBlock(STD_BLOCKS *p_stdb,void *data){
    char *t_data = (char *)data;
    /*unsigned int data_size = sizeof(data);*/
    for(int i = 0; i < p_stdb->blocks_num; i++){
        p_stdb->buff[i] = t_data[i];
    }
    p_stdb->if_data = 1;
    return 0;
}

STD_CTN *initStandardDConnection(SID *f_sid, SID *s_sid){
    STD_CTN *p_stdc = (STD_CTN *)malloc(sizeof(STD_CTN));
    p_stdc->f_sid = s_idToASCIIString(f_sid);
    p_stdc->s_sid = s_idToASCIIString(s_sid);
    return p_stdc;
}

STD_DATA *initStandardData(unsigned int type){
    STD_DATA *p_std = (STD_DATA *)malloc(sizeof(STD_DATA));
    p_std->pd_blocklst = initList(0);
    p_std->pd_ctnlst = initList(0);
    p_std->lock = 0;
    p_std->type = type;
    p_std->s_id = NULL;
    return p_std;
}

int standardDataAddBlock(STD_DATA *p_std, SID *p_sid ,unsigned int type, void *data, unsigned long long data_size){
    if (p_std->lock) return -1;
    STD_BLOCKS *p_stdb = initStandardDBlocks(p_sid, type,data_size);
    dataForStandardDBlock(p_stdb, data);
    insertInTail(p_std->pd_blocklst, nodeWithPointer(p_stdb,0));
    return 0;
}

int standardDataAddConnection(STD_DATA *p_std, SID *f_sid, SID *s_sid){
    if (p_std->lock) return -1;
    STD_CTN *p_stdb = initStandardDConnection(f_sid, s_sid);
    insertInTail(p_std->pd_ctnlst, nodeWithPointer(p_stdb,0));
    return 0;
}

D_FILE *initDataFileForWrite(char *route){
    D_FILE *p_dfile = (D_FILE *)malloc(sizeof(D_FILE));
    p_dfile->fp = fopen(route, "wb");
    p_dfile->pf_head = (F_HEAD *)malloc(sizeof(F_HEAD));
    strcpy(p_dfile->pf_head->head_test,"ZESTDLIB_STDDFILE");
    p_dfile->pf_head->data_num = 0;
    p_dfile->pf_stdlst = initList(0);
    return p_dfile;
}

D_FILE *initDataFileForRead(char *route){
    D_FILE *p_dfile = (D_FILE *)malloc(sizeof(D_FILE));
    p_dfile->fp = fopen(route, "rb");
    p_dfile->pf_head = (F_HEAD *)malloc(sizeof(F_HEAD));
    p_dfile->pf_head->data_num = 0;
    p_dfile->pf_stdlst = initList(0);
    return p_dfile;
}

int dataFileAddStandardData(D_FILE *p_dfile, STD_DATA *p_std){
    insertInTail(p_dfile->pf_stdlst, nodeWithPointer(p_std,0));
    p_dfile->pf_head->data_num = p_dfile->pf_stdlst->length;
    return 0;
}

int dataFileWriteIn(D_FILE *p_dfile){
    fwrite(p_dfile->pf_head->head_test, sizeof(char), 18, p_dfile->fp);
    fwrite(&p_dfile->pf_head->data_num, sizeof(unsigned long long), 1, p_dfile->fp);
    fwrite("HEAD_END", sizeof(char), 9, p_dfile->fp);
    List *er_list = initList(0);
    insertInTail(er_list, nodeWithPointer(p_dfile->fp,0));
    /*fwrite("STDINFO", sizeof(char), 8, p_dfile->fp);
    listThrough(p_dfile->pf_stdlst, _doStandardDataInfoWrite, er_list);*/
    /*fwrite("STDLST", sizeof(char), 7, p_dfile->fp);*/
    listThrough(p_dfile->pf_stdlst, _doStandardDataWrite, er_list);
    releaseList(er_list);
    return 0;
}

List *_doStandardDataInfoWrite(unsigned int type, void *value, List *er_list){
    List *p_rtnlst = initList(0);
    FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0));
    STD_DATA *p_std = value;
    insertInTail(p_rtnlst, nodeWithInt(0,0));
    int if_sid = 0;
    if(p_std->s_id != NULL){
        if_sid = 1;
        char *string_sid = s_idToASCIIString(p_std->s_id);
        fwrite(&if_sid, sizeof(int), 1, fp);
        fwrite(string_sid, sizeof(char), SID_LEN, fp);
        free(string_sid);
    }
    else{
        fwrite(&if_sid, sizeof(int), 1, fp);
    }
    fwrite(&p_std->type, sizeof(unsigned long), 1, fp);
    fwrite(&p_std->pd_ctnlst->length, sizeof(unsigned long long), 1, fp);
    fwrite(&p_std->pd_blocklst->length, sizeof(unsigned long long), 1, fp);
    return p_rtnlst;
}

List *_doStandardDataWrite(unsigned int type, void *value, List *er_list){
    List *p_rtnlst = initList(0);
    FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0));
    insertInTail(p_rtnlst, nodeWithInt(0,0));
    STD_DATA *p_std = value;
    List *erc_list = initList(0);
    insertInTail(erc_list, nodeWithPointer(fp,0));
    fwrite("STD", sizeof(char), 4, fp);
    fwrite(&p_std->type, sizeof(unsigned int), 1, fp);
    fwrite(&p_std->pd_ctnlst->length, sizeof(unsigned long long), 1, fp);
    fwrite(&p_std->pd_blocklst->length, sizeof(unsigned long long), 1, fp);
    listThrough(p_std->pd_ctnlst, _doStandardDConnectionWrite, erc_list);
    listThrough(p_std->pd_blocklst, _doStandardDBlockWrite, erc_list);
    releaseList(erc_list);
    return p_rtnlst;
}

List *_doStandardDConnectionWrite(unsigned int type, void *value, List *er_list){
    List *p_rtnlst = initList(0);
    insertInTail(p_rtnlst, nodeWithInt(0,0));
    FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0));
    STD_CTN *p_stdc = value;
    fwrite(p_stdc->f_sid, sizeof(char), SID_LEN, fp);
    fwrite(p_stdc->s_sid, sizeof(char), SID_LEN, fp);
    return p_rtnlst;
}

List *_doStandardDBlockWrite(unsigned int type, void *value, List *er_list){
    List *p_rtnlst = initList(0);
    insertInTail(p_rtnlst, nodeWithInt(0,0));
    STD_BLOCKS *p_stdb = value;
    FILE *fp = getByPointerForNode(findByIndexForNode(er_list, 0));
    unsigned long blocks_num = p_stdb->blocks_num;
    int if_sid = 0;
    if(p_stdb->sid != NULL){
        if_sid = 1;
        fwrite(&if_sid, sizeof(int), 1, fp);
        fwrite(p_stdb->sid, sizeof(char), SID_LEN, fp);
    }
    else{
        fwrite(&if_sid, sizeof(int), 1, fp);
    }
    fwrite(&p_stdb->type, sizeof(unsigned int), 1, fp);
    fwrite(&blocks_num, sizeof(unsigned long), 1, fp);
    fwrite(p_stdb->buff, sizeof(char), p_stdb->blocks_num, fp);
    return p_rtnlst;
}

STD_DATA *listToSTD(List *p_list){
    STD_DATA *p_std = initStandardData(LIST);
    Node *p_node = p_list->head;
    if (p_list->s_id != NULL) p_std->s_id = copyS_id(p_list->s_id);
    while (p_node != NULL) {
        if(p_node->type == HOLE) continue;
        unsigned long long data_size = 0;
        if(p_node->type == INT) data_size = sizeof(int);
        else if (p_node->type == DOUBLE) data_size = sizeof(double);
        else if (p_node->type == STRING) data_size = strlen((char *)p_node->value) + 1;
        else data_size = sizeof(void *);
        standardDataAddBlock(p_std, p_node->s_id, p_node->type, p_node->value, data_size);
        p_node = p_node->next;
    }
    return p_std;
}

int dataFileReadOut(D_FILE *p_dfile){
    char test_info[FILE_TSET_LEN],head_test_info[HEAD_TEST_LEN];
    fread(test_info, sizeof(char), FILE_TSET_LEN, p_dfile->fp);
    strcpy(p_dfile->pf_head->head_test, test_info);
    if(!strcmp(test_info, "ZESTDLIB_STDDFILE")){
        unsigned long long std_num = 0;
        fread(&std_num, sizeof(unsigned long long), 1, p_dfile->fp);
        p_dfile->pf_head->data_num = std_num;
        fread(head_test_info, sizeof(char), 9, p_dfile->fp);
        if (!strcmp(head_test_info, "HEAD_END")) {
            for(int i = 0; i < std_num; i++){
                char std_test_info[4];
                fread(std_test_info, sizeof(char), 4, p_dfile->fp);
                if(!strcmp(std_test_info, "STD")){
                    unsigned long long ctn_num = 0, blk_num = 0;
                    int if_sid = 0;
                    unsigned int type = 0;
                    fread(&if_sid, sizeof(int), 1, p_dfile->fp);
                    char *string_sid = NULL;
                    if(if_sid){
                        string_sid = (char *)malloc(sizeof(char) * SID_LEN);
                        fread(string_sid, sizeof(char), SID_LEN, p_dfile->fp);
                    }
                    fread(&type, sizeof(unsigned int), 1, p_dfile->fp);
                    STD_DATA *p_std = initStandardData(type);
                    freeS_id(p_std->s_id);
                    p_std->s_id = asciiStringToS_id(string_sid);
                    dataFileAddStandardData(p_dfile, p_std);
                    if(string_sid != NULL) free(string_sid);
                    fread(&ctn_num, sizeof(unsigned long long), 1, p_dfile->fp);
                    fread(&blk_num, sizeof(unsigned long long), 1, p_dfile->fp);
                    for(int j = 0; j < ctn_num; j++){
                        char *fstring_sid = (char *)malloc(sizeof(char) * SID_LEN);
                        fread(fstring_sid, sizeof(char), SID_LEN, p_dfile->fp);
                        char *sstring_sid = (char *)malloc(sizeof(char) * SID_LEN);
                        fread(sstring_sid, sizeof(char), SID_LEN, p_dfile->fp);
                        SID *fs_id = asciiStringToS_id(fstring_sid), *ss_id = asciiStringToS_id(sstring_sid);
                        standardDataAddConnection(p_std, fs_id,ss_id);
                        freeS_id(fs_id);
                        freeS_id(ss_id);
                        free(fstring_sid);
                        free(sstring_sid);
                    }
                    for(int k = 0; k < blk_num; k++){
                        fread(&if_sid, sizeof(int), 1, p_dfile->fp);
                        char *string_sid = NULL;
                        if(if_sid){
                            string_sid = (char *)malloc(sizeof(char) * SID_LEN);
                            fread(string_sid, sizeof(char), SID_LEN, p_dfile->fp);
                        }
                        unsigned long blk_len = 0;
                        fread(&blk_len, sizeof(unsigned long), 1, p_dfile->fp);
                        char *content = (char *)malloc(sizeof(char) * blk_len);
                        fread(content, sizeof(char), blk_len, p_dfile->fp);
                        SID *s_id = asciiStringToS_id(string_sid);
                        unsigned int type = VOID;
                        fread(&type, sizeof(unsigned int), 1, p_dfile->fp);
                        standardDataAddBlock(p_std, s_id, type, content, blk_len);
                        freeS_id(s_id);
                        if(string_sid != NULL) free(string_sid);
                        free(content);
                    }
                    return  0;
                }
                else break;
            }
        }
        else{
            
        }
    }
    showError(pushError(DATA_FILE, STANDARD, initInfo("dataFileReadOut()", "Datafile not complete.")));
    return -1;
}

int releaseSTDConnection(STD_CTN *p_stdc){
    free(p_stdc->f_sid);
    free(p_stdc->s_sid);
    free(p_stdc);
    return 0;
}

int releaseSTDBlocks(STD_BLOCKS *p_stdb){
    free(p_stdb->buff);
    free(p_stdb->sid);
    free(p_stdb);
    return 0;
}

int releaseStandardData(STD_DATA *p_std){
    releaseListForCustom(p_std->pd_blocklst, (int (*)(void *))releaseSTDBlocks);
    releaseListForCustom(p_std->pd_ctnlst, (int (*)(void *))releaseSTDConnection);
    free(p_std);
    return 0;
}

int releaseDFile(D_FILE *p_dfile){
    releaseListForCustom(p_dfile->pf_stdlst, (int (*)(void *))releaseStandardData);
    fclose(p_dfile->fp);
    free(p_dfile->pf_head);
    free(p_dfile);
    return 0;
}

List *standardDataToList(STD_DATA *p_std){
    List *p_list = initList(0);
    List *er_list = initList(0);
    insertInTail(er_list, nodeWithPointer(er_list,0));
    listThrough(p_std->pd_blocklst, _doStandardDataToList, er_list);
    return p_list;
}

List *_doStandardDataToList(unsigned int type, void *value, List *er_list){
    List *rtn_list = initList(0);
    insertInTail(rtn_list, nodeWithInt(0,0));
    List *p_list = getByPointerForNode(findByIndexForNode(er_list, 0));
    STD_BLOCKS *p_stdb = value;
    Node *p_node = initNode(0);
    p_node->s_id = asciiStringToS_id(p_stdb->sid);
    p_node->type = p_stdb->type;
    p_node->value = malloc(sizeof(p_stdb->blocks_num));
    memcpy(p_node->value, p_stdb->buff, sizeof(p_stdb->blocks_num));
    insertInTail(p_list, p_node);
    return rtn_list;
}

unsigned long calStandardData(STD_DATA *p_std){
    unsigned long size = sizeof(unsigned int) + 9;
    if(p_std->s_id != NULL) size += 32;
    listThrough(p_std->pd_ctnlst, CALLBACK_CALL(calStandardDataCTN), SEND_ARG("%d", size));
    return 0;
}

CALLBACK_DEFINE(calStandardDataCTN){
    
    return C_RETURN;
}

MSG *createMessage(char *title, void *data, unsigned long data_size){
    MSG *p_msg = malloc(sizeof(MSG) + data_size);
    p_msg->p_sid = getS_id(MESSAGE, 1);
    p_msg->time = time(NULL);
    return p_msg;
}

/*int sendMessageIPv4(MSG *p_msg, char *ip, unsigned int port){
    int client_sockfd;
    struct sockaddr_in remote_addr;
    char buf[BUFSIZ];
    memcpy(buf, "ZEMSG", 5);
    memset(&remote_addr,0,sizeof(remote_addr));
    remote_addr.sin_family=AF_INET;
    remote_addr.sin_addr.s_addr=inet_addr(ip);
    remote_addr.sin_port=htons(port);
    client_sockfd=socket(PF_INET,SOCK_STREAM,0);
    connect(client_sockfd,(struct sockaddr *)&remote_addr,sizeof(struct sockaddr));
    send(client_sockfd,buf,strlen(buf),0);
    unsigned long bkmsg_len = 0;
    bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0);
    buf[bkmsg_len] = '\0';
    if(!strcmp(buf, "TITLE_REV_READY")){
        memcpy(buf, p_msg->titile, strlen(p_msg->titile));
        bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0);
        buf[bkmsg_len] = '\0';
        if(!strcmp(buf, "CONTENT_LEN_REV_READY")){
            memcpy(buf, (char *)p_msg->size, sizeof(unsigned int));
            send(client_sockfd,buf,sizeof(unsigned int),0);
            bkmsg_len = recv(client_sockfd, buf, BUFSIZ, 0);
            buf[bkmsg_len] = '\0';
            if(!strcmp(buf, "CONTENT_REV_READY")){
                memcpy(buf, p_msg->content, p_msg->size);
                send(client_sockfd,buf,p_msg->size,0);
                close(client_sockfd);
                return 0;
            }
        }
    }
    close(client_sockfd);
    return -1;
}*/