#define _GNU_SOURCE
#include <stdio.h>
#include <stdbool.h>
#include <stdarg.h>
#include <string.h>
#include <netdb.h>
#include <sys/socket.h>
#include <errno.h>
#include "global.h"
#include "memory.h"
#include "tcp.h"

i64 tcp_read_line(int sock,char **buf,i64 *bufsz){
	if(*bufsz==0||*buf==NULL){
		*bufsz=512;
		*buf=malloc(*bufsz,char);
	}
	i64 len=0;
	while(true){
		if(len==*bufsz-1){
			*bufsz*=2;
			*buf=realloc(*buf,*bufsz,char);
		}
		i64 ret=recv(sock,*buf+len,1,0);
		if(ret<=0)return -1;
		if((*buf)[len]=='\n'){
			(*buf)[len]='\0';
			return len;
		}
		len++;
	}
}

i64 tcp_read_data(int sock,char *buf,i64 length){
	i64 got=0;
	while(got<length){
		i64 ret=recv(sock,buf+got,length-got,0);
		if(ret<=0)return -1;
		got+=ret;
	}
	return 0;
}

i64 tcp_send_data(int sock,const char *buf,i64 length){
	i64 sent=0;
	while(sent<length){
		i64 ret=send(sock,buf+sent,length-sent,0);
		if(ret==-1){
			if(errno==EINTR)continue;
			return -1;
		}
		sent+=ret;
	}
	return 0;
}

i64 tcp_send_str(int sock,const char *str){
	return tcp_send_data(sock,str,strlen(str));
}

i64 tcp_send_line(int sock,const char *str){
	if(tcp_send_str(sock,str)==-1)return -1;
	return tcp_send_str(sock,"\n");
}

__attribute__((format (printf,2,3)))
i64 tcp_send_line_f(int sock,const char *format,...){
	va_list ap;
	va_start(ap,format);
	char *buf;
	vasprintf(&buf,format,ap);
	va_end(ap);
	if(buf==NULL)throw("vasprintf: allocation failure");
	i64 ret=tcp_send_line(sock,buf);
	free(buf);
	return ret;
}


i64 tcp_send_list(int sock,const char *tag,const char *const *list,i64 len){
	char *buf;
	asprintf(&buf,"list %s %" PRIi64,tag,len);
	if(buf==NULL)throw("asprintf: allocation failure");
	if(len==0){
		i64 ret=tcp_send_line(sock,buf);
		free(buf);
		return ret;
	}

	if(tcp_send_str(sock,buf)==-1){free(buf); return -1;}
	for(i64 i=0;i<len;i++){
		if(tcp_send_str(sock," ")==-1){free(buf); return -1;}
		if(tcp_send_str(sock,list[i])==-1){free(buf); return -1;}
	}
	return tcp_send_str(sock,"\n");
}

//Returns -1 on error or connection closure.
i64 tcp_send_int(int sock,const char *tag,i64 value){
	char *buf;
	asprintf(&buf,"int %s %" PRIi64,tag,value);
	if(buf==NULL)throw("asprintf: allocation failure");
	i64 ret=tcp_send_line(sock,buf);
	free(buf);
	return ret;
}


i64 tcp_read_ok(int sock,const char *tag){
	char *buf=NULL;
	i64 bufsz=0;
	i64 ret=tcp_read_line(sock,&buf,&bufsz);
	if(ret==-1){
		if(buf!=NULL)free(buf);
		return -1;
	}

	char *walker=buf;
	char *ok=strsep(&walker," ");
	char *realtag=strsep(&walker," ");
	bool success=walker==NULL&&strcmp(ok,"ok")==0&&strcmp(realtag,tag)==0;
	free(buf);
	return success?0:-1;
}

static TcpList* interpret_list(char *buf,const char *tag){
	char *walker=buf;
	char *word1=strsep(&walker," ");
	char *word2=strsep(&walker," ");
	char *word3=strsep(&walker," ");
	char *argstart=walker;
	i64 nitems=0;
	while((strsep(&walker," "))!=NULL)nitems++;
	if(word1==NULL||word2==NULL||word3==NULL||strcmp(word1,"list")!=0||strcmp(word2,tag)!=0){
		free(buf);
		return NULL;
	}
	char *endp;
	i64 word3i=strtoll(word3,&endp,10);
	if(word3[0]=='\0'||*endp!='\0'||word3i!=nitems){
		free(buf);
		return NULL;
	}
	
	TcpList *list=malloc(1,TcpList);
	list->nitems=nitems;
	list->items=malloc(nitems,char*);
	walker=argstart;
	for(i64 i=0;i<nitems;i++){
		list->items[i]=strdup(strsep(&walker," "));
	}

	return list;
}

TcpList* tcp_read_list(int sock,const char *tag){
	char *buf=NULL;
	i64 bufsz=0;
	i64 ret=tcp_read_line(sock,&buf,&bufsz);
	if(ret==-1){
		if(buf!=NULL)free(buf);
		return NULL;
	}

	TcpList *list=interpret_list(buf,tag);
	free(buf);
	return list;
}

void tcp_list_destroy(TcpList *list){
	free(list->items);
	free(list);
}


TcpResponse* tcp_read_response(int sock,const char *tag){
	char *buf=NULL;
	i64 bufsz=0;
	i64 ret=tcp_read_line(sock,&buf,&bufsz);
	if(ret==-1){
		if(buf!=NULL)free(buf);
		return NULL;
	}

	char *walker=buf;
	char *word1=strsep(&walker," ");
	char *word2=strsep(&walker," ");
	if(word1==NULL||word2==NULL||strcmp(word2,tag)!=0){
		free(buf);
		return NULL;
	}

	TcpResponseType type;
	i64 intvalue;
	TcpList *listvalue=NULL;
	char *errorvalue=NULL;
	if(strcmp(word1,"ok")==0&&walker==NULL){
		type=TCP_OK;
	} else if(strcmp(word1,"error")==0){
		type=TCP_ERROR;
		if(walker==NULL){
			free(buf);
			return NULL;
		}
		errorvalue=walker;
	} else if(strcmp(word1,"int")==0){
		type=TCP_INT;
		char *token=strsep(&walker," ");
		if(walker!=NULL||token==NULL){
			free(buf);
			return NULL;
		}
		char *endp;
		intvalue=strtoll(token,&endp,10);
		if(token[0]=='\0'||*endp!='\0'){
			free(buf);
			return NULL;
		}
	} else if(strcmp(word1,"list")==0){
		type=TCP_LIST;
		listvalue=interpret_list(buf,tag);
		if(listvalue==NULL){
			free(buf);
			return NULL;
		}
	} else {
		free(buf);
		return NULL;
	}

	TcpResponse *res=malloc(1,TcpResponse);
	res->type=type;
	switch(type){
		case TCP_OK: break;
		case TCP_ERROR: res->eval=errorvalue; break;
		case TCP_INT: res->ival=intvalue; break;
		case TCP_LIST: res->lval=listvalue; break;
	}
	return res;
}

void tcp_response_destroy(TcpResponse *res){
	switch(res->type){
		case TCP_OK: break;
		case TCP_ERROR: free(res->eval); break;
		case TCP_INT: break;
		case TCP_LIST: tcp_list_destroy(res->lval); break;
	}
	free(res);
}


static const char* itoa(int n){
	static char buf[64];
	sprintf(buf,"%d",n);
	return buf;
}


int tcp_connect(const char *hostname,int port){
	struct addrinfo hints,*res;
	memset(&hints,0,sizeof(hints));
	hints.ai_family=AF_UNSPEC;
	hints.ai_socktype=SOCK_STREAM;
	int ret=getaddrinfo(hostname,itoa(port),&hints,&res);
	if(ret!=0){
		return -1;
	}

	int sock=socket(res->ai_family,res->ai_socktype,res->ai_protocol);
	if(sock==-1)return -1;
	if(connect(sock,res->ai_addr,res->ai_addrlen)==-1)return -1;
	return sock;
}