/* How to compile:
** sc MyCapi.c
** sc CallerID.c
** sc capi-usr.c
** slink from LIB:c.o MyCAPI.o CallerID.o to CallerID LIB capi-usr.o LIB:sc.lib
*/

#include <proto/dos.h>
#include <proto/exec.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <dos.h>
#include <dos/rdargs.h>
#include <exec/types.h>

#include "os.h"
#include "capi-usr.h"
#include "MyCAPI.h"

/*
** Globals
*/
U8		 outputbuff[256];
U8		*actioncmd = NULL;
U8		*phonebook = NULL;
U8		*version = "$VER: CallerID 2.1 (18.11.97) © Frederic Steinfels";
BOOL	 debugcapi = FALSE;
struct	 Task *maintask;
FILE	*phonebookfile;


/*
** Locals
*/
static U32  ctrlnum = 1;
static U8 *logname = NULL;
static FILE *logfile;


/*
** Code
*/

/****************************************************************************
**	Um die CTRL-C Behandlungsroutine vom SAS-C lahmzulegen.
*/
int brk(void)
{
	return 0;
}


/****************************************************************************
** Oeffnet das Logfile, wenn flag 1 ist, wird das alte geloescht.
*/
static BOOL openlog(BOOL flag)
{
	if (logname != NULL) {
		if (logfile = fopen(logname, flag ? "w" : "a"))
			return TRUE;
	}
	return FALSE;
}


/****************************************************************************
** Schliesst das Logfile
*/
static VOID closelog(VOID)
{
	if (logfile) {
		fclose(logfile);
		logfile = NULL;
	}
}



/****************************************************************************
** Ausgaberoutine (inkl. Datum/Uhrzeit)
** Achtung, diese Routine wird auch vom CAPI-SignalHandler Callback
** benuetzt !
*/
VOID myoutput(U8 *fmt, ...)
{
	struct DateStamp ds;
	struct DateTime dt;
	U8 day[32], date[32], time[32], buff[256];
	va_list arg;

	/*
	** Datum/Uhrzeit voranstellen
	*/
	DateStamp(&ds);
	dt.dat_Stamp = ds;
	dt.dat_Format = FORMAT_CDN;
	dt.dat_Flags = 0;
	dt.dat_StrDay = day;
	dt.dat_StrDate = date;
	dt.dat_StrTime = time;
	DateToStr(&dt);
	sprintf(buff, "%.3s %s %s ", day, date, time);
	if (openlog(0)) {
		fwrite(buff, strlen(buff), 1, logfile);
		closelog();
	}
	printf(buff);

	/*
	** Text ausgeben
	*/
	va_start(arg, fmt);
	vsprintf(buff, fmt, arg);
	va_end(arg);
	if (openlog(0)) {
		fwrite(buff, strlen(buff), 1, logfile);
		fwrite("\n", 1, 1, logfile);
		closelog();
	}
	puts(buff);
}


/****************************************************************************
** Das Programm ...
*/
void main(int argc, char **argv)
{
	#define TEMPLATE "CONTROLLER/N,DEBUG/S,LOGFILE/K,PHONEBOOK/K,ACTIONCOMMAND/K"
	#define OPT_CONTROLLER 0
	#define OPT_DEBUG 1
	#define OPT_LOGFILE 2
	#define OPT_PHONEBOOK 3
	#define OPT_ACTIONCOMMAND 4
	#define OPT_COUNT 5
	
	LONG result[OPT_COUNT];
	U32 *val;
	unsigned char *valc;
	
	struct RDArgs *rdargs;
	
	maintask = FindTask(NULL);

	/*
	** Erstmal testen, ob CAPI ueberhaupt installiert ist ...
	*/
	if (U_CAPI_INSTALLED()) {
		myoutput("FEHLER: CAPI 2.0 nicht installiert !");
		return;
	}

	/*
	** Kommandozeile auswerten
	*/

	result[OPT_CONTROLLER] = 0;
	result[OPT_DEBUG] = FALSE;
	result[OPT_LOGFILE] = NULL;
	result[OPT_PHONEBOOK] = NULL;
	result[OPT_ACTIONCOMMAND] = NULL;

	if (rdargs = ReadArgs(TEMPLATE, result, NULL))
	{
		debugcapi = FALSE;
		if (result[OPT_DEBUG])
		{
			debugcapi = TRUE;
		}
		ctrlnum = 1;
		if (val = (U32 *)result[OPT_CONTROLLER])
		{
			ctrlnum = *val;
		}
		logname = NULL;
		if (valc = (U8 *)result[OPT_LOGFILE])
		{
			logname = valc;
		}
		phonebook = NULL;
		if (valc = (U8 *)result[OPT_PHONEBOOK])
		{
			phonebook = valc;
		}
		actioncmd = NULL;
		if (valc = (U8 *)result[OPT_ACTIONCOMMAND])
		{
			actioncmd = valc;
		}

		/*
		** CTRL-C ausschalten
		*/
		if (onbreak(&brk)) {
			myoutput("FEHLER: Kann CTRL-C nicht ausschalten!");
			return;
		}
	
		/*
		** CAPI initialisieren
		*/
		if (MYCAPI_Init(ctrlnum)) {
			for (;;) {
				if (Wait(SIGBREAKF_CTRL_C | SIGF_SINGLE) & SIGBREAKF_CTRL_C)
					break;
				myoutput(outputbuff);
			}
		} else
			myoutput("FEHLER: CAPI-Initialisierung fehlgeschlagen!");
	
		/*
		** CAPI-Resourcen wieder freigeben (immer nach MYCAPI_Init()!)
		*/
		MYCAPI_Exit();
	
	}
	FreeArgs(rdargs);
}