#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <tlmpsql.h>
#include "tlmpmail.h"
#include "tlmpmail.m"
#include <dialog.h>

class FOLDER_FACTORY_SQL: public FOLDER_FACTORY{
	FOLDER_VIEW *build(const char *path)
	{
		FOLDER_VIEW *ret = NULL;
		if (strncmp(path,"SQL/",4)==0){
			ret = new FOLDER_SQL (path+4);
		}
		return ret;
	}
	bool exist(const char *path)
	{
		bool ret = false;
		if (strncmp(path,"SQL/",4)==0){
			ret = folder_sql_exist (path+4);
		}
		return ret;
	}
	int list(SSTRINGS &tb)
	{
		return folder_sql_list (tb);
	}
};

static FOLDER_FACTORY_SQL ff;

static void folder_sql_init()
{
	static bool is_init=false;
	if (!is_init){
		query_setdefaultdb ("localhost","usermail");
		is_init = true;
	}
}

/*
	Return the ID of an SQL folder
*/
<mod>
int folder_sql_getid (const char *folder)
{
	<glocal>
		int id;
	</glocal>
	glocal.id = -1;
	folder_sql_init();
	NSQL_ENCODE enc;
	<call sql_query>("select id from folders"
		" where foldername='%s'",enc.enc(folder));
	<f onerow>
		glocal.id = atoi(row[0]);
	</f>
	</call>
	return glocal.id;
}
</mod>

/*
	Create a new SQL folder and assign an ID.
	Return the ID.
*/
int folder_sql_create (const char *folder)
{
	NSQL_ENCODE enc;
	sql_action ("insert into folders (foldername) values ('%s')"
		,enc.enc(folder));	
	return folder_sql_getid (folder);
}

<mod>
PUBLIC FOLDER_SQL::FOLDER_SQL(const char *folder)
{
	name.setfrom (folder);
	id = folder_sql_getid (folder);
	revision = -1;
}
</mod>

/*
	Forget all message in tb[], but put in the garbage collector
	message still in use.
*/
PRIVATE void FOLDER_SQL::forget(
	bool deleted)	// Forget deleted message or all
{
	for (int i=tb.getnb()-1; i>=0; i--){
		MAIL_MESSAGE *m = tb.getitem(i);
		if (!deleted || m->deleted){
			if (m->getusage()>0){
				m->assign (NULL);
				folders_register(m);
				tb.remove (i);
			}else{
				tb.remove_del(i);
			}
		}
	}
}

<mod>
PUBLIC int FOLDER_SQL::loadindex (MAIL_MESSAGES &idx, int &callerrev)
{
	int ret = -1;
	idx.neverdelete();
	int newrev = getrevision();
	if (newrev != revision){
		fprintf (stderr,"loading sql %d %d\n",newrev,revision);
		revision = newrev;
		forget(false);
		glocal MAIL_MESSAGES *tb = &tb;
		glocal MAIL_MESSAGE *m = NULL;
		glocal FOLDER_VIEW *folder = this;
		<call sql_query>("select messages.id,subject,msgid,replyid,deleted,replied,viewed,tagged,addrs.name,addr,type,comment,unix_timestamp(datesent),size"
			" from messages,addrs"
			" where folderid=%d and messages.id=addrs.id order by daterec,messages.id"
			,id);
		<f onerow>
			// glocal.one.set (fields,row);
			int id = atoi(row[0]);
			if (glocal.m == NULL || glocal.m->fid != id){
				glocal.m = new MAIL_MESSAGE;
				glocal.m->assign (glocal.folder);
				glocal.tb->add (glocal.m);
				glocal.m->fid = id;
				glocal.m->subject.setfrom(row[1]);
				glocal.m->id.setfrom(row[2]);
				glocal.m->replyid.setfrom (row[3]);
				glocal.m->deleted = row[4][0] == 'Y';
				glocal.m->replied = row[5][0] == 'Y';
				glocal.m->viewed = row[6][0] == 'Y';
				glocal.m->tagged = row[7][0] == 'Y';
				glocal.m->comment.setfrom (row[11]);
				glocal.m->date = atoi(row[12]);
				glocal.m->size = atoi(row[13]);
			}
			char type = row[10][0];
			if (type == 'f'){
				glocal.m->from.set (row[8],row[9]);
			}else if (type == 'c'){
				glocal.m->cc.set (row[8],row[9]);
			}else if (type == 'r'){
				glocal.m->reply.set (row[8],row[9]);
			}else if (type == 't'){
				glocal.m->to.set (row[8],row[9]);
			}else if (type == 'd'){
				glocal.m->flags.set_str (row[8],row[9]);
			}else{
				fprintf (stderr,"folder_sql::loadindex: Invalid type %c\n",type);
			}
		</f>
		</call>
fprintf (stderr,"end\n");
		ret = 0;
	}
	if (revision != callerrev){
		callerrev = revision;
		idx.remove_all();
		for (int i=0; i<tb.getnb(); i++){
			MAIL_MESSAGE *m = tb.getitem(i);
			idx.add (m);
		}
		ret = idx.getnb();
	}
	return ret;
}
</mod>

/*
	Insert a message flags in the addrs table
*/
static void folder_sql_insertflags (int id, const DICTIONARY &flags)
{
	NSQL_ENCODE enc;
	for (int i=0; i<flags.getnb(); i++){
		const char *var = flags.get_var(i);
		const char *val = flags.get_val(i);
		if (val[0] != '\0'){
			sql_action ("insert into addrs (id,type,name,addr)"
				" values (%d,'d','%s','%s')"
				,id,enc.enc(var),enc.enc(val));
		}
	}
}

/*
	Increment the revision of the folder so other software
	can track its evolution.
*/
PRIVATE void FOLDER_SQL::incrrevision()
{
	sql_action ("update folders set revision=revision+1 where id=%d",id);
	// We try to keep in sync. If we are alone updating the
	// folder, then all is fine, no need to re-read the folder.
	// If another app is updating the folder, then the revision
	// will be higher and we will re-read the folder in loadindex.
	revision++;
}


PUBLIC VIRTUAL void FOLDER_SQL::updatemsg (MAIL_MESSAGE &msg)
{
	NSQL_ENCODE enc;
	if (sql_action ("update messages set"
		" deleted='%c',viewed='%c',replied='%c',tagged='%c',comment='%s'"
		" where id=%d"
		,msg.deleted ? 'Y' : 'N'
		,msg.viewed ? 'Y' : 'N'
		,msg.replied ? 'Y' : 'N'
		,msg.tagged ? 'Y' : 'N'
		,enc.enc(msg.comment)
		,msg.fid)!=-1
		&& sql_action ("delete from addrs where id=%d and type='d'"
			,msg.fid)!=-1){
		folder_sql_insertflags (msg.fid,msg.flags);
		incrrevision();
		msg.rstmodified();
	}
}

/*
	Message are updated one by one, so we do nothing
	except when a cleanup is requested.
*/
PUBLIC int FOLDER_SQL::update (bool clean)
{
	if (clean){
		if (sql_action ("delete from messages where deleted='Y' and folderid=%d"
				,id)!=-1){
			incrrevision();
			for (int i=0; i<tb.getnb(); i++){
				MAIL_MESSAGE *m = tb.getitem(i);
				if (m->deleted){
					int fid = m->fid;
					sql_action ("delete from addrs where id=%d",fid);
					sql_action ("delete from parts where id=%d",fid);
				}
			}
			forget(true);
			wakeup();
		}
	}
	return 0;
}
PUBLIC const char *FOLDER_SQL::gettitle ()
{
	return name.get();
}
<mod>
PUBLIC int FOLDER_SQL::loadmsg (const MAIL_MESSAGE &msg, MAIL_MESSAGE_FULL &full)
{
	glocal MAIL_MESSAGE_FULL *full = &full;
	glocal int ret = -1;
	msg.copy (full);
	<call sql_query>("select message,header from parts where id=%d",msg.fid);
	<f onerow>
		glocal.full->text.setfrom (row[0]);
		glocal.full->header.setfrom (row[1]);
		glocal.ret = 0;
	</f>
	</call>
	full.parse_header();
	return glocal.ret;
}
</mod>
PUBLIC bool FOLDER_SQL::is_postponed()
{
	return false;
}
PUBLIC bool FOLDER_SQL::is_shared()
{
	return false;
}
PUBLIC int FOLDER_SQL::getid(SSTRING &id)
{
	id.setfromf ("SQL/%s",name.get());
	return 0;
}
/*
	Return the update revision of the folder
*/
<mod>
PUBLIC int FOLDER_SQL::getrevision()
{
	glocal int ret = -1;
	<call sql_query>("select revision from folders where id=%d",id);
	<f onerow>
		glocal.ret = atoi(row[0]);
	</f>
	</call>
	return glocal.ret;
}
</mod>

static void folder_sql_insertadr (
	int fid,		// Message ID
	EMAILADDRS &adrs,
	char type)
{
	NSQL_ENCODE enc;
	for (int i=0; i<adrs.getnb(); i++){
		const SSTRING *adr = adrs.addrs.getitem(i);
		const SSTRING *nam = adrs.names.getitem(i);
		sql_action ("insert into addrs (id,type,addr,name)"
			" values (%d,'%c','%s','%s')"
			,fid,type,enc.enc(adr),enc.enc(nam));
	}
}

<mod>
PUBLIC int FOLDER_SQL::appendmsg (MAIL_MESSAGE_FULL &full)
{
	int ret = -1;
	if (id == -1) folder_sql_create (name.get());
	if (id != -1){
		NSQL_ENCODE enc;
		char datesent[20];
		struct tm *t = localtime (&full.date);
		snprintf (datesent,sizeof(datesent)-1,"%4d/%02d/%02d %02d:%02d:%02d"
			,t->tm_year+1900,t->tm_mon+1,t->tm_mday
			,t->tm_hour,t->tm_min,t->tm_sec);
		ret = sql_action ("insert into messages"
			" (folderid,subject,msgid,replyid,datesent"
			",deleted,replied,viewed,tagged,daterec,comment,size)"
			" values "
			" (%d,'%s','%s','%s','%s','%c','%c','%c','%c',now(),'%s',%d)"
			,id,enc.enc(full.subject),enc.enc(full.id),enc.enc(full.replyid)
			,datesent
			,full.deleted ? 'Y' : 'N'
			,full.replied ? 'Y' : 'N'
			,full.viewed ? 'Y' : 'N'
			,full.tagged ? 'Y' : 'N'
			,enc.enc(full.comment)
			,full.text.getlen()
			);
		if(ret != -1){
			int fid = sql_getlastid();
			sql_action ("insert into parts (id,message,header) values (%d,'%s','%s')"
				,fid,enc.enc(full.text),enc.enc(full.header));
			folder_sql_insertadr (fid,full.from,'f');
			folder_sql_insertadr (fid,full.to,'t');
			folder_sql_insertadr (fid,full.reply,'r');
			folder_sql_insertadr (fid,full.cc,'c');
			folder_sql_insertflags (fid,full.flags);
			incrrevision();
		}
	}
	return ret;
}
</mod>

<mod>
int folder_sql_list (SSTRINGS &tb)
{
	<glocal>
		SSTRINGS *tb;
	</glocal>
	glocal.tb = &tb;
	folder_sql_init();
	int ret = <call sql_query>("select foldername from folders");
	<f onerow>
		SSTRING *s = new SSTRING;
		s->setfromf ("SQL/%s",row[0]);
		glocal.tb->add (s);
	</f>
	</call>
	return ret;
}
</mod>

<mod>
bool folder_sql_exist (const char *name)
{
	<glocal>
	</glocal>
	folder_sql_init();
	NSQL_ENCODE enc;
	int nb = <call sql_query>("select foldername from folders"
		" where foldername='%s'",enc.enc(name));
	<f onerow>
	</f>
	</call>
	return nb == 1;
}
</mod>

<mod>
PUBLIC bool FOLDER_SQL::msgexist (MAIL_MESSAGE &msg)
{
	glocal bool ret = false;
	NSQL_ENCODE enc;
	<call sql_query>("select count(*) from messages"
		" where folderid=%d and msgid='%s'"
		,id,enc.enc(msg.id));
	<f onerow>
		glocal.ret = atoi(row[0]) > 0;
	</f>
	</call>
	return glocal.ret;
}
</mod>

PUBLIC void FOLDER_SQL::getupdmsgs (PRIVATE_MESSAGES &upds)
{
	upds.add (&updmsg);
}

PUBLIC void FOLDER_SQL::checkupdate ()
{
	int newrev = getrevision();
	if (newrev != revision) dialog_sendmessage (updmsg);
}