#include "gnupgplugin.h"

//	escape sequence type
struct escapesequence
{
	char *sequence;
	char *code;
};

//	supported escape sequences
struct escapesequence escsequence[]=
{
	{"\\n", "\n"},
	{"\\r", "\r"},
	{"\\t", "\t"}
};

//	number of supported escape sequences
int escsequencecount=sizeof(escsequence)/sizeof(struct escapesequence);

void replace(char *atext, const char *apattern, const char *areplacement)
{
	char *pos, *last;
	long textsize;
	long patternsize;
	long replacementsize;
	
	if (!atext || !apattern || !areplacement)
		return;

	pos=atext;
	patternsize=strlen(apattern);
	replacementsize=strlen(areplacement);
	
	while (pos)
	{
		// textstelle suchen
		last=pos;
		pos=strstr(pos,apattern);
		// etwas gefunden?
		if (!pos)
			break;
		// laenge des textes ermitteln
		textsize=strlen(last);
		// platz schaffen
		memmove
			(
			pos+replacementsize,
			pos+patternsize,
			textsize-((pos-last)+patternsize)+1
			);
		// ersetzen
		strncpy(pos,areplacement,replacementsize);
		pos+=replacementsize;
	}
}

char *replace_dup(const char *atext, const char *apattern, const char *areplacement)
{
	if (!atext || !apattern || !areplacement)
		return NULL;
	size_t patlen=strlen(apattern);
	const char *pos=atext;
	const char *ent;
	int i;
	for (i=0; (ent=strstr(pos,apattern)); (pos=ent+patlen),i++);
	size_t srcsiz=strlen(atext)+1;
	size_t replen=strlen(areplacement);
	size_t dstsiz=srcsiz+(replen>patlen?(replen-patlen)*i:0);
	char *dtext=(char*)mir_alloc(dstsiz);
	if (!dtext)
		return NULL;
	memcpy(dtext,atext,srcsiz);
	replace(dtext,apattern,areplacement);
	return dtext;
}

char *getNextPart(char *aresult, char *atext, const char *aseparator)
	//	adds to aresult an item from atext up to aseparator
	//  returns pointer to next item (or NULL)
{
	char *pos;
	
	if (!aresult || !atext || !aseparator)
		return NULL;
	
	strcpy(aresult,"");
	pos=strstr(atext,aseparator);
	
	if (pos)
	{
		strncat(aresult,atext,pos-atext);
		pos+=strlen(aseparator);
	}
	else 
		strcpy(aresult,atext);
	
	return pos;
}

void getLastPart(char *aresult, char *atext)
{
	if (aresult && atext)
		strcpy(aresult,atext);
}

void appendText(char **abuffer, const char *atext, int atextsize)
{
	int size;
	
	if (!abuffer || !atext)	return;
	
	size=(*abuffer==NULL)?0:strlen(*abuffer);
	size++; // abschliessende 0
	if (atextsize==0)
		atextsize=strlen(atext);
	size+=atextsize;
	
	*abuffer=(char*)mir_realloc(*abuffer,size);
	strncat(*abuffer,atext,atextsize);
}


BOOL existsFile(const char *afilename)
{
	if (!afilename || strlen(afilename)==0)
		return FALSE;
	
	FILE *handle=fopen(afilename,"r");
	if (!handle) 
		return FALSE;
	
	fclose(handle);
	return TRUE;
}

BOOL writeToFile(char *afilename, const char *atext, bool isUnicode)
{
	getTemporaryFileName(afilename);
	
	FILE *handle=fopen(afilename,"wb");
	
	if (!handle)
	{
		LogMessage("--- GnuPG.writeToFile: filename:",afilename,"\n");
		return FALSE;
	}
	
	size_t binlen=strlen(atext)+1;
	if (isUnicode) binlen*=(sizeof(wchar_t)+1);
	size_t written=fwrite(atext,sizeof(char),binlen,handle);
	
	fclose(handle);

	return (written==binlen)? TRUE: FALSE;
}

long get_file_size(const char *afilename)
{
	FILE *handle=fopen(afilename,"rb");
	if (!handle)
		return -1L;
	fseek(handle,0,SEEK_END);
	long filesize=ftell(handle);
	fclose(handle);
	return filesize;
}

BOOL fnFALSE(char **ppc)	//	free, nullify and return FALSE
{
	if (!ppc) return FALSE;
	if (*ppc) mir_free(*ppc); 
	*ppc=NULL; 
	return FALSE; 
}

BOOL readFromFile(char **aresult, const char *afilename)
	//	*aresult MUST be mir_alloc memory block or NULL
	//	on error returns FALSE, frees and nullifies *aresult
	//	on success returns TRUE, caller later MUST free *aresult by hands.
	//		reads even binary files.
	//		*aresult contains the file contents appended by a byte set to 0.
{
	if (!aresult) return FALSE;
	if (!afilename) return fnFALSE(aresult);
	if (!*aresult) *aresult=(char*)mir_alloc(1);
	if (!*aresult) return FALSE;

	FILE *handle=fopen(afilename,"rb");
	if (!handle) 
	{
		LogMessage("--- GnuPG.readFromFile: couldn't open handle for:\n",afilename,"\n");
		return fnFALSE(aresult);
	}
	
	fseek(handle,0,SEEK_END);
	size_t filesize=ftell(handle);

	if (filesize==-1L)
	{
		LogMessage("--- GnuPG.readFromFile: couldn't get filesize for:\n",afilename,"\n");
		return fnFALSE(aresult);
	}

	fseek(handle,0,SEEK_SET);
	
	*aresult=(char*)mir_realloc(*aresult,filesize+1);
	if (!*aresult)
	{
		LogMessage("--- GnuPG.readFromFile: memory reallocation error for:\n",afilename,"\n");
		return fnFALSE(aresult);
	}
	size_t read=fread(*aresult,sizeof(char),filesize,handle);
	fclose(handle);
	(*aresult)[filesize]='\0';

	if (read!=filesize)
		return fnFALSE(aresult);
	
	return TRUE;
}

void getTemporaryFileName(char *aresult)
{
	char name[filenamesize];

	if (!aresult) return;
	
	strcpy(aresult,gpgTempdir);
	tmpnam(name);
	strcat(aresult,name);
}

void quoteEscapeSequences(char *atext)
{
	if (!atext) return;
	for (int i=0; i<escsequencecount; i++)
		replace(atext,escsequence[i].code,escsequence[i].sequence);
}

void unquoteEscapeSequences(char *atext)
{
	if (!atext) return;
	for (int i=0; i<escsequencecount; i++)
		replace(atext,escsequence[i].sequence,escsequence[i].code);
}


/////////////////////////////////////////////////////////////////////////////////////////
// Unicode functions

char* u2a(const wchar_t *src)
{
	int codepage=CallService(MS_LANGPACK_GETCODEPAGE,0,0);

	int cbLen=WideCharToMultiByte(codepage,0,src,-1,NULL,0,NULL,NULL);
	char *result=(char*)mir_alloc(cbLen+1);
	if (!result)
		return NULL;

	WideCharToMultiByte(codepage,0,src,-1,result,cbLen,NULL,NULL);
	result[cbLen]=0;
	return result;
}

wchar_t* a2u(const char *src)
{
	int codepage=CallService(MS_LANGPACK_GETCODEPAGE,0,0);

	int cbLen=MultiByteToWideChar(codepage,0,src,-1,NULL,0);
	wchar_t *result=(wchar_t*)mir_alloc(sizeof(wchar_t)*(cbLen+1));
	if (!result)
		return NULL;

	MultiByteToWideChar(codepage,0,src,-1,result,cbLen);
	result[cbLen]=0;
	return result;
}

char *fixcrlf_dup(const char *buf)
{
	if (!buf) return NULL;
	char *freeofr=replace_dup(buf,"\r","");
	if (freeofr)
	{
		char *tmp=replace_dup(freeofr,"\n",txtcrlf);
		fnFALSE(&freeofr);
		if (tmp)
			return tmp;
	}
	return NULL;
}

char *makemix_dup(const char *buf)
	//	buf should be ASCIIZ
	//	returns newly allocated ASCIIZ+UCS2
{
	if (!buf) return NULL;
	int binsiz=strlen(buf)+1;
	int ascsiz=binsiz;
	binsiz=ascsiz*(sizeof(wchar_t)+1);
	char *mix=(char*)mir_alloc(binsiz);
	if (mix)
	{
		memcpy(mix,buf,ascsiz);
		wchar_t *wc=a2u(mix);
		if (!wc)
		{
			fnFALSE(&mix);
			return NULL;
		}
		memcpy(mix+ascsiz,wc,ascsiz*sizeof(wchar_t));
		mir_free(wc);
	}
	return mix;
}