/* Amichecks arexx port! */

#include <stdlib.h>
#include <string.h>
#include <libraries/asl.h>
#include "amiCheck.h"
#include "database.h"
#include "libraries.h"
#include "arexx.h"
#include "regGadget.h"

extern char *quitstr;

void ArexxInit(void);
BOOL ArexxHandleGadget(struct IntuiMessage *);
BOOL ArexxGoodbye(struct IntuiMessage *);
void AmiManageBalance(filterNode *find, entryNode *entry);

static entryNode new;
static struct Window *arexxWin;
GUIFront *arexxGUI;
arexxNode copyMacros[MAXMACROS];
static int catSel = 0;

static struct TagItem axgetfile[] = {
	{ALT_Image, ALTI_GetFile},
	{ALT_AslRequester, FALSE},
	/*{GA_Immediate,TRUE},*/
	{TAG_DONE},
};

struct TagItem labeltags[] =
{
 {GTST_MaxChars,20},
 {TAG_DONE},
};

GadgetSpec AREXXgadgetspecs[] = 
{
	{STRING_KIND,18,0,{0,0,0,0,"Label 1:", NULL, GID_AXLABEL1,
		PLACETEXT_LEFT},labeltags,GS_DefaultTags},
	{STRING_KIND,18,0,{0,0,0,0,"Macro 1:", NULL, GID_AXFILE1,
		PLACETEXT_LEFT},NULL,GS_DefaultTags},
	{GETALT_KIND,0,0,{0,0,0,0,NULL, NULL, GID_AXGETFILE1,
		PLACETEXT_LEFT},axgetfile,GS_DefaultTags},

	{STRING_KIND,18,0,{0,0,0,0,"Label 2:", NULL, GID_AXLABEL2,
		PLACETEXT_LEFT},labeltags,GS_DefaultTags},
	{STRING_KIND,18,0,{0,0,0,0,"Macro 2:", NULL, GID_AXFILE2,
		PLACETEXT_LEFT},NULL,GS_DefaultTags},
	{GETALT_KIND,0,0,{0,0,0,0,NULL, NULL, GID_AXGETFILE2,
		PLACETEXT_LEFT},axgetfile,GS_DefaultTags},

	{STRING_KIND,18,0,{0,0,0,0,"Label 3:", NULL, GID_AXLABEL3,
		PLACETEXT_LEFT},labeltags,GS_DefaultTags},
	{STRING_KIND,18,0,{0,0,0,0,"Macro 3:", NULL, GID_AXFILE3,
		PLACETEXT_LEFT},NULL,GS_DefaultTags},
	{GETALT_KIND,0,0,{0,0,0,0,NULL, NULL, GID_AXGETFILE3,
		PLACETEXT_LEFT},axgetfile,GS_DefaultTags},

	{STRING_KIND,18,0,{0,0,0,0,"Label 4:", NULL, GID_AXLABEL4,
		PLACETEXT_LEFT},labeltags,GS_DefaultTags},
	{STRING_KIND,18,0,{0,0,0,0,"Macro 4:", NULL, GID_AXFILE4,
		PLACETEXT_LEFT},NULL,GS_DefaultTags},
	{GETALT_KIND,0,0,{0,0,0,0,NULL, NULL, GID_AXGETFILE4,
		PLACETEXT_LEFT},axgetfile,GS_DefaultTags},

	{STRING_KIND,18,0,{0,0,0,0,"Label 5:", NULL, GID_AXLABEL5,
		PLACETEXT_LEFT},labeltags,GS_DefaultTags},
	{STRING_KIND,18,0,{0,0,0,0,"Macro 5:", NULL, GID_AXFILE5,
		PLACETEXT_LEFT},NULL,GS_DefaultTags},
	{GETALT_KIND,0,0,{0,0,0,0,NULL, NULL, GID_AXGETFILE5,
		PLACETEXT_LEFT},axgetfile,GS_DefaultTags},

	{STRING_KIND,18,0,{0,0,0,0,"Label 6:", NULL, GID_AXLABEL6,
		PLACETEXT_LEFT},labeltags,GS_DefaultTags},
	{STRING_KIND,18,0,{0,0,0,0,"Macro 6:", NULL, GID_AXFILE6,
		PLACETEXT_LEFT},NULL,GS_DefaultTags},
	{GETALT_KIND,0,0,{0,0,0,0,NULL, NULL, GID_AXGETFILE6,
		PLACETEXT_LEFT},axgetfile,GS_DefaultTags},

	{STRING_KIND,18,0,{0,0,0,0,"Label 7:", NULL, GID_AXLABEL7,
		PLACETEXT_LEFT},labeltags,GS_DefaultTags},
	{STRING_KIND,18,0,{0,0,0,0,"Macro 7:", NULL, GID_AXFILE7,
		PLACETEXT_LEFT},NULL,GS_DefaultTags},
	{GETALT_KIND,0,0,{0,0,0,0,NULL, NULL, GID_AXGETFILE7,
		PLACETEXT_LEFT},axgetfile,GS_DefaultTags},

	{STRING_KIND,18,0,{0,0,0,0,"Label 8:", NULL, GID_AXLABEL8,
		PLACETEXT_LEFT},labeltags,GS_DefaultTags},
	{STRING_KIND,18,0,{0,0,0,0,"Macro 8:", NULL, GID_AXFILE8,
		PLACETEXT_LEFT},NULL,GS_DefaultTags},
	{GETALT_KIND,0,0,{0,0,0,0,NULL, NULL, GID_AXGETFILE8,
		PLACETEXT_LEFT},axgetfile,GS_DefaultTags},

	{STRING_KIND,18,0,{0,0,0,0,"Label 9:", NULL, GID_AXLABEL9,
		PLACETEXT_LEFT},labeltags,GS_DefaultTags},
	{STRING_KIND,18,0,{0,0,0,0,"Macro 9:", NULL, GID_AXFILE9,
		PLACETEXT_LEFT},NULL,GS_DefaultTags},
	{GETALT_KIND,0,0,{0,0,0,0,NULL, NULL, GID_AXGETFILE9,
		PLACETEXT_LEFT},axgetfile,GS_DefaultTags},

	{STRING_KIND,18,0,{0,0,0,0,"Label 10:", NULL, GID_AXLABEL10,
		PLACETEXT_LEFT},labeltags,GS_DefaultTags},
	{STRING_KIND,18,0,{0,0,0,0,"Macro 10:", NULL, GID_AXFILE10,
		PLACETEXT_LEFT},NULL,GS_DefaultTags},
	{GETALT_KIND,0,0,{0,0,0,0,NULL, NULL, GID_AXGETFILE10,
		PLACETEXT_LEFT},axgetfile,GS_DefaultTags},

	{BUTTON_KIND,0,0,{0,0,0,0,"_OK",NULL,GID_AXOK,
		PLACETEXT_IN},NULL,GS_DefaultTags},
	{BUTTON_KIND,0,0,{0,0,0,0,"_Cancel",NULL,GID_AXCANCEL,
		PLACETEXT_IN},NULL,GS_DefaultTags},

};

GadgetSpec *AX_ArexxSpecs[] =
{
 	&AREXXgadgetspecs[0],
 	&AREXXgadgetspecs[1],
 	&AREXXgadgetspecs[2],
 	&AREXXgadgetspecs[3],
 	&AREXXgadgetspecs[4],
 	&AREXXgadgetspecs[5],
 	&AREXXgadgetspecs[6],
 	&AREXXgadgetspecs[7],
 	&AREXXgadgetspecs[8],
 	&AREXXgadgetspecs[9],
 	&AREXXgadgetspecs[10],
 	&AREXXgadgetspecs[11],
 	&AREXXgadgetspecs[12],
 	&AREXXgadgetspecs[13],
 	&AREXXgadgetspecs[14],
 	&AREXXgadgetspecs[15],
 	&AREXXgadgetspecs[16],
 	&AREXXgadgetspecs[17],
 	&AREXXgadgetspecs[18],
 	&AREXXgadgetspecs[19],
 	&AREXXgadgetspecs[20],
 	&AREXXgadgetspecs[21],
 	&AREXXgadgetspecs[22],
 	&AREXXgadgetspecs[23],
 	&AREXXgadgetspecs[24],
 	&AREXXgadgetspecs[25],
 	&AREXXgadgetspecs[26],
 	&AREXXgadgetspecs[27],
 	&AREXXgadgetspecs[28],
 	&AREXXgadgetspecs[29],
 	&AREXXgadgetspecs[30],
 	&AREXXgadgetspecs[31],
	NULL,
};

ULONG AX_ArexxPanel[] =
{
  GUIL_Flags, GUILF_PropShare | GUILF_EqualWidth,

  GUIL_HorizGroup,1,
		GUIL_Flags, GUILF_EqualWidth | GUILF_EqualHeight,
		GUIL_FrameType, GUILFT_Recess,

     GUIL_VertGroup,1,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		
	GUIL_VertGroup,0,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		GUIL_GadgetSpecID, GID_AXLABEL1,
		GUIL_HorizGroup,0,
			GUIL_GadgetSpecID, GID_AXFILE1,
			GUIL_GadgetSpecID, GID_AXGETFILE1,
		TAG_DONE,
	TAG_DONE,
	GUIL_VertGroup,0,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		GUIL_GadgetSpecID, GID_AXLABEL2,
		GUIL_HorizGroup,0,
			GUIL_GadgetSpecID, GID_AXFILE2,
			GUIL_GadgetSpecID, GID_AXGETFILE2,
		TAG_DONE,
	TAG_DONE,

	GUIL_VertGroup,0,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		GUIL_GadgetSpecID, GID_AXLABEL3,
		GUIL_HorizGroup,0,
			GUIL_GadgetSpecID, GID_AXFILE3,
			GUIL_GadgetSpecID, GID_AXGETFILE3,
		TAG_DONE,
	TAG_DONE,

	GUIL_VertGroup,0,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		GUIL_GadgetSpecID, GID_AXLABEL4,
		GUIL_HorizGroup,0,
			GUIL_GadgetSpecID, GID_AXFILE4,
			GUIL_GadgetSpecID, GID_AXGETFILE4,
		TAG_DONE,
	TAG_DONE,

	GUIL_VertGroup,0,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		GUIL_GadgetSpecID, GID_AXLABEL5,
		GUIL_HorizGroup,0,
			GUIL_GadgetSpecID, GID_AXFILE5,
			GUIL_GadgetSpecID, GID_AXGETFILE5,
		TAG_DONE,
	TAG_DONE,


     TAG_DONE,

     GUIL_VertGroup,1,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,

	GUIL_VertGroup,0,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		GUIL_GadgetSpecID, GID_AXLABEL6,
		GUIL_HorizGroup,0,
			GUIL_GadgetSpecID, GID_AXFILE6,
			GUIL_GadgetSpecID, GID_AXGETFILE6,
		TAG_DONE,
	TAG_DONE,
	GUIL_VertGroup,0,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		GUIL_GadgetSpecID, GID_AXLABEL7,
		GUIL_HorizGroup,0,
			GUIL_GadgetSpecID, GID_AXFILE7,
			GUIL_GadgetSpecID, GID_AXGETFILE7,
		TAG_DONE,
	TAG_DONE,

	GUIL_VertGroup,0,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		GUIL_GadgetSpecID, GID_AXLABEL8,
		GUIL_HorizGroup,0,
			GUIL_GadgetSpecID, GID_AXFILE8,
			GUIL_GadgetSpecID, GID_AXGETFILE8,
		TAG_DONE,
	TAG_DONE,

	GUIL_VertGroup,0,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		GUIL_GadgetSpecID, GID_AXLABEL9,
		GUIL_HorizGroup,0,
			GUIL_GadgetSpecID, GID_AXFILE9,
			GUIL_GadgetSpecID, GID_AXGETFILE9,
		TAG_DONE,
	TAG_DONE,

	GUIL_VertGroup,0,
		GUIL_Flags, GUILF_LabelAlign | GUILF_EqualWidth,
		GUIL_GadgetSpecID, GID_AXLABEL10,
		GUIL_HorizGroup,0,
			GUIL_GadgetSpecID, GID_AXFILE10,
			GUIL_GadgetSpecID, GID_AXGETFILE10,
		TAG_DONE,
	TAG_DONE,


     TAG_DONE,

  TAG_DONE,

     GUIL_HorizGroup,1,
        GUIL_Flags, GUILF_EqualSize | GUILF_EqualWidth,
        
           GUIL_GadgetSpecID, GID_AXOK,
           GUIL_GadgetSpecID, GID_AXCANCEL,
           
    TAG_DONE, 

  TAG_DONE,
};


struct ARexxContext *axContext = NULL;

struct ARexxCommandTable commandTable[] =
{
 {AREXX_OPEN,		"OPEN", 
			"FILENAME/A/F",
			NULL},

 {AREXX_SAVE,		"SAVE", 
			"FILENAME/F",
			NULL},

 {AREXX_QUIT,		"QUIT", 
			"FORCE/S",
			NULL},

 {AREXX_GETRECORD, 	"AC_GETRECORD", 	
			"ENTRY/A/N,TYPE/S,NAME/S,MEMO/S,DATE/S,AMOUNT/S,CLEARED/S,PRINTED/S,VOIDED/S,TAX/S,CHECKNUMBER/S,CATEGORIES/S",
			NULL},

 {AREXX_GETBUDGET,	"AC_GETBUDGET",
			"ENTRY/A/N,CATNUM/A/N,CATNAME/S,CATBUDGET/S",
			NULL},

 {AREXX_GETINFO,	"AC_GETINFO", 		
			"ENTRIES/S,CURRBAL/S,STATEBAL/S,FILTBAL/S,FILENAME/S,HOLDER/S,ACCOUNT/S,BANK/S,OPENDATE/S,CLOSED/S,CLOSEDATE/S,STARTDEPOSIT/S", 
			NULL},

 {AREXX_SETINFO,	"AC_SETINFO", 		
			"HOLDER/F,ACCOUNT/F,BANK/F,OPENDATE/F,CLOSED/N,CLOSEDATE/F,STARTDEPOSIT/F", 
			NULL},

 {AREXX_USERSEL, 	"AC_USERSEL",
			"SETENTRY/N,GETENTRY/S",
			NULL},

 {AREXX_EDITRECORD,	"AC_EDITRECORD",	
			"ENTRY/A/N,NAME/F,MEMO/F,DATE/F,AMOUNT/F,CLEARED/N,PRINTED/N,VOIDED/N,TAX/N,CHECKNUMBER/N", 
			NULL},

 {AREXX_ADDBUDGET,	"AC_ADDBUDGET",
			"ENTRY/A/N,CATEGORY/A,BUDGETED/A",
			NULL},

 {AREXX_DELBUDGET,	"AC_DELBUDGET",
			"ENTRY/A/N,CATNUM/A/N",
			NULL},

 {AREXX_DELRECORD,	"AC_DELRECORD",
			"ENTRY/A/N",
			NULL},

 {AREXX_BUILDRECORD, 	"AC_BUILDRECORD", 	
			"TYPE/N,NAME/F,MEMO/F,DATE/F,AMOUNT/F,CLEARED/N,PRINTED/N,VOIDED/N,TAX/N,CHECKNUMBER/N",
			NULL},

 {AREXX_BUILDBUDGET,	"AC_BUILDBUDGET",
			"CATNAME/A,CATBUDGET/A",
			NULL},

 {AREXX_PUTRECORD,	"AC_PUTRECORD",
			"",
			NULL},

#if 0
 {AREXX_RUNMACRO,	"AC_RUNMACRO",
			"NUMBER/N,LABEL",
			NULL},
#endif

 {AREXX_LOCK,		"AC_LOCK",
			"",
			NULL},

 {AREXX_UNLOCK,		"AC_UNLOCK",
			"",
			NULL},

 {AREXX_REBUILD,	"AC_REBUILD",
			"",
			NULL},
 TABLE_END,
};

LONG arexxSel = 0;
char portName[100];
char outString[100];
char *errMsg = "Warning: Invalid state of command";

/*******************************************************
* ArexxGUI()
*
*	Handles the arexx gui for the menu macros
********************************************************/
BOOL ArexxGUI(void)
{
 UWORD ordinal;
 BOOL done, noreply; 
 ULONG signal;

   done = FALSE;

   /* lock edit window */
   AmiLock();

   /* bring up this gui */
   GF_SetGUIAttr(arexxGUI, GUI_OpenGUI, TRUE, TAG_DONE);
   
   /* grab window */
   GF_GetGUIAttr(arexxGUI,GUI_Window,&arexxWin,TAG_DONE);

   ArexxInit();

   /* Process input events */
    while (!done)
       {
         struct IntuiMessage *imsg;
                    /* Wait for an event to occur */

                    signal = GF_Wait(guiapp,AmigaGuideSignal(agc));
		    if (signal & AmigaGuideSignal(agc)) {
			AmiHelpMsg();
			continue;
		    }


                    /* We only bother to listen for CLOSEWINDOW events.
                     * Of course, in a real application, you would be
                     * examining the Class field for IDCMP_GADGETUP
                     * messages and act accordingly.
                     */

                    while (imsg = GF_GetIMsg(guiapp))
                    {
			noreply = TRUE;
                        switch (imsg->Class) {
				case IDCMP_REFRESHWINDOW:
					RegRefresh(TRUE);
					break;

                                case IDCMP_CLOSEWINDOW:
                                        done = TRUE;
                                        break;

				case IDCMP_RAWKEY:
					AmiHelpKey(imsg,AREXX_PANEL);
					break;

				case IDCMP_GADGETUP:
					noreply = FALSE;
					done=ArexxHandleGadget(imsg);
					break;
	            }

		    if (noreply) GF_ReplyIMsg(imsg);

         	}
  }

  /* close window */
  GF_SetGUIAttr(arexxGUI, GUI_OpenGUI, FALSE, TAG_DONE);            
  arexxWin = NULL;
      
  /* unlock window */
  AmiUnlock();

  return FALSE;
}

/*****************************************************************
* ArexxHandleGadget()
*
*	Handle the gadgets of this panel
******************************************************************/
BOOL ArexxHandleGadget(struct IntuiMessage *imsg)
{
 BOOL done = FALSE;
 struct Gadget *gad =  (struct Gadget *)(imsg->IAddress);
 UWORD code = imsg->Code;
 
 switch (gad->GadgetID) {
	case GID_AXGETFILE1:
		if (AmiGetFile(arexxGUI, otherRexxASL,copyMacros[0].macrofile,FILESIZE)) 
			GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[GID_AXFILE1]->gs_Gadget,
				GTST_String,copyMacros[0].macrofile,
				TAG_DONE);
		break;

	case GID_AXGETFILE2:
		if (AmiGetFile(arexxGUI, otherRexxASL,copyMacros[1].macrofile,FILESIZE)) 
			GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[GID_AXFILE2]->gs_Gadget,
				GTST_String,copyMacros[1].macrofile,
				TAG_DONE);
		break;

	case GID_AXGETFILE3:
		if (AmiGetFile(arexxGUI, otherRexxASL,copyMacros[2].macrofile,FILESIZE))
			GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[GID_AXFILE3]->gs_Gadget,
				GTST_String,copyMacros[2].macrofile,
				TAG_DONE);
		break;

	case GID_AXGETFILE4:
		if (AmiGetFile(arexxGUI, otherRexxASL,copyMacros[3].macrofile,FILESIZE))
			GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[GID_AXFILE4]->gs_Gadget,
				GTST_String,copyMacros[3].macrofile,
				TAG_DONE);
		break;

	case GID_AXGETFILE5:
		if (AmiGetFile(arexxGUI, otherRexxASL,copyMacros[4].macrofile,FILESIZE))
			GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[GID_AXFILE5]->gs_Gadget,
				GTST_String,copyMacros[4].macrofile,
				TAG_DONE);
		break;

	case GID_AXGETFILE6:
		if (AmiGetFile(arexxGUI, otherRexxASL,copyMacros[5].macrofile,FILESIZE))
			GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[GID_AXFILE6]->gs_Gadget,
				GTST_String,copyMacros[5].macrofile,
				TAG_DONE);
		break;


	case GID_AXGETFILE7:
		if (AmiGetFile(arexxGUI, otherRexxASL,copyMacros[6].macrofile,FILESIZE))
			GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[GID_AXFILE7]->gs_Gadget,
				GTST_String,copyMacros[6].macrofile,
				TAG_DONE);
		break;


	case GID_AXGETFILE8:
		if (AmiGetFile(arexxGUI, otherRexxASL,copyMacros[7].macrofile,FILESIZE))
			GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[GID_AXFILE8]->gs_Gadget,
				GTST_String,copyMacros[7].macrofile,
				TAG_DONE);
		break;


	case GID_AXGETFILE9:
		if (AmiGetFile(arexxGUI, otherRexxASL,copyMacros[8].macrofile,FILESIZE))
			GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[GID_AXFILE9]->gs_Gadget,
				GTST_String,copyMacros[8].macrofile,
				TAG_DONE);
		break;

	case GID_AXGETFILE10:
		if (AmiGetFile(arexxGUI, otherRexxASL,copyMacros[9].macrofile,FILESIZE))
			GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[GID_AXFILE10]->gs_Gadget,
				GTST_String,copyMacros[9].macrofile,
				TAG_DONE);
		break;

	case GID_AXCANCEL:
		done = TRUE;
		break;

	case GID_AXOK:
		if (ArexxGoodbye(imsg)) {
			done = TRUE;
			memcpy(arexxMacros,copyMacros,sizeof(arexxNode)*MAXMACROS);
		}
		break;
 }

 return (done);
}

/********************************************************
* ArexxGoodbye()
*
*	Pull in all data entry
*********************************************************/
BOOL ArexxGoodbye(struct IntuiMessage *imsg)
{ 
 int x;

 for (x=0;x<MAXMACROS;x++) {
	strcpy(copyMacros[x].macroname,
		((struct StringInfo *)(AX_ArexxSpecs[GID_AXLABEL1+(x*3)]->gs_Gadget)->SpecialInfo)->Buffer); 
	strcpy(copyMacros[x].macrofile,
		((struct StringInfo *)(AX_ArexxSpecs[GID_AXFILE1+(x*3)]->gs_Gadget)->SpecialInfo)->Buffer);
 }

 return (TRUE);
}

/********************************************************
* ArexxInit()
*
*	Initialize the interface
*********************************************************/
void ArexxInit(void)
{
 int x;
 memcpy(copyMacros,arexxMacros,sizeof(arexxNode)*MAXMACROS);

 for (x=0;x<MAXMACROS;x++) {
 
 	GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[ (x*3)+GID_AXLABEL1]->gs_Gadget,
		GTST_String,copyMacros[x].macroname,
		TAG_DONE);

	GF_SetGadgetAttrs (arexxGUI, AX_ArexxSpecs[(x*3)+GID_AXFILE1]->gs_Gadget,
		GTST_String,copyMacros[x].macrofile,
		TAG_DONE);
 }

}

/*******************************************************
* axOpen
*
*	Open the arexx port
*******************************************************/
BOOL axOpen(void)
{
 BOOL ret = FALSE;

 axContext = AllocARexxContext(
	ER_Portname, "AMICHECK",
	ER_CommandTable, commandTable,
	ER_Author, AC_Author,
	ER_Copyright, "Copyright© 1994,1995 Douglas M. Dyer",
	ER_Version, AC_Version,
	TAG_DONE);

 if (axContext != NULL) {
	ret = TRUE;
	sprintf(portName,"%s>",axContext->portname);
	memset(&new,0,sizeof(entryNode));
	memcpy(&new.date,&currDate,sizeof(dateType));
 }

 return (ret);
}

/*******************************************************
* axClose
*
*	Close the arexx port
*******************************************************/
BOOL axClose(void)
{
 BOOL ret = TRUE;

 if (EasyRexxBase != NULL && axContext != NULL)
	FreeARexxContext(axContext);

 return (ret);
}

/*******************************************************
* axOpenCmd()
*
*	Open the command shell
********************************************************/
void axOpenCmd(void)
{
 
 ARexxCommandShell(axContext,
	ER_Prompt, 	portName,
	WA_Title,	"amiCheck CommandShell",
	WA_Left,	0,
	WA_Width,	320,
	WA_Height,	100,
	WA_DragBar,	TRUE,
	WA_DepthGadget,	TRUE,
	WA_SizeGadget,	TRUE,
	WA_CloseGadget,	TRUE,
	WA_MinWidth,	50,
	WA_MinHeight,	50,
	WA_MaxWidth,	~0,
	WA_MaxHeight,	~0,
	WA_SizeBBottom,	TRUE,
	/*WA_PubScreen, amiWindow->WScreen, */
	/*ER_Font,	amiWindow->WScreen->Font,*/
	ER_Close, 	FALSE,
	TAG_DONE);

}

/*******************************************************
* axCloseCmd()
*
*	Close the command shell
********************************************************/
void axCloseCmd(void)
{
 ARexxCommandShell(axContext,
	ER_Close, TRUE,
	TAG_DONE);
}

/*******************************************************
* axHandle()
*
*	Handle all arexx commanding
*******************************************************/
BOOL axHandle(struct ARexxContext *cx)
{
 ULONG resultint = 1L;
 LONG  result = RC_OK;
 UBYTE *resultstring = NULL;
 filterNode *filt;
 BOOL done = FALSE;

 if (GetARexxMsg(cx)) {
	switch (cx->id) {

		case AREXX_GETRECORD:
			arexxSel = ARGNUMBER(cx,0);
			if (arexxSel == 0 || arexxSel > entryCount) {
				result = RC_WARN;
				resultstring = errMsg;
			}
			else {
				if (ARG(cx,1)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					resultint = filt->entry->type;
				}
				else if (ARG(cx,2)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					resultstring = filt->entry->name;
				}
				else if (ARG(cx,3)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					resultstring = filt->entry->memo;
				}
				else if (ARG(cx,4)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					DataBuildDate(&filt->entry->date,outString);
					resultstring = outString;
				}
				else if (ARG(cx,5)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					DataBuildAmnt(TRUE,&filt->entry->amount,outString);
					resultstring = outString;
				}
				else if (ARG(cx,6)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					resultint = filt->entry->flags & CLEARED;
				}
				else if (ARG(cx,7)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					resultint = filt->entry->flags & PRINTED;
				}
				else if (ARG(cx,8)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					resultint = filt->entry->flags & VOIDED;
				}
				else if (ARG(cx,9)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					resultint = filt->entry->flags & TAXDEDUCT;
				}
				else if (ARG(cx,10)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					resultint = filt->entry->check;
				}
				else if (ARG(cx,11)) {
					resultint = 1;
				}
				else {
					result = RC_WARN;
					resultstring = errMsg;
				}

			}
			break;

		case AREXX_USERSEL:
			if (ARG(cx,0)) {
				arexxSel = ARGNUMBER(cx,0);
				if (arexxSel == 0 || arexxSel > entryCount) {
					result = RC_WARN;
					resultstring = errMsg;
				}
				else {
					resultint = arexxSel;
					selRow = arexxSel - 1;
					RegMoveToSel(&filtered);
				}
			}
			else if (ARG(cx,1)) {
				if (selRow < 0)
					resultint = 0;
				else 	resultint = selRow + 1;			
			}
			else {
				result = RC_WARN;
				resultstring = errMsg;
			}
			break;

		case AREXX_SETINFO:
			if (ARG(cx,0)) {
				strncpy(usrAccount.holder,ARGSTRING(cx,0),STRINGSIZE);
			}
			else if (ARG(cx,1)) {
				strncpy(usrAccount.accnt,ARGSTRING(cx,1),STRINGSIZE);
			}
			else if (ARG(cx,2)) {
				strncpy(usrAccount.bank,ARGSTRING(cx,2),STRINGSIZE);
			}
			else if (ARG(cx,3)) {
				if (DataVerifyDate(ARGSTRING(cx,3),outString)) {
					DataStoreDate(&usrAccount.openDate,outString);
				}
				else {
					result = RC_WARN;
					resultstring = errMsg;
					break;
				}
			}
			else if (ARG(cx,3)) {
				if (ARGNUMBER(cx,3))
					usrAccount.closed = TRUE;
				else	usrAccount.closed = FALSE;

			}
			else if (ARG(cx,4)) {
				if (DataVerifyDate(ARGSTRING(cx,4),outString)) {
					DataStoreDate(&usrAccount.closeDate,outString);
				}
				else {
					result = RC_WARN;
					resultstring = errMsg;
					break;
				}
			}
			else if (ARG(cx,5)) {
				if ( (resultint = DataVerifyAmnt(ARGSTRING(cx,5),outString))) {
					DataStoreAmnt(&usrAccount.beginAmount,outString);
				}
				else {
					result = RC_WARN;
					resultstring = errMsg;
					break;
				}
			}
			break;
	
		case AREXX_GETINFO:
			if (ARG(cx,0)) {
				resultint = entryCount;
			}
			else if (ARG(cx,1)) {
				resultstring = currStr;
			}
			else if (ARG(cx,2)) {
				resultstring = stateStr;
			}
			else if (ARG(cx,3)) {
				resultstring = filtStr;
			}
			else if (ARG(cx,4)) {
				resultstring = currFile;
			}
			else if (ARG(cx,5)) {
				resultstring = usrAccount.holder;
			}
			else if (ARG(cx,6)) {
				resultstring = usrAccount.accnt;
			}
			else if (ARG(cx,7)) {
				resultstring = usrAccount.bank;
			}
			else if (ARG(cx,8)) {
				DataBuildDate(&usrAccount.openDate,outString);
				resultstring = outString;
			}
			else if (ARG(cx,9)) {
				resultint = usrAccount.closed;
			}
			else if (ARG(cx,10)) {
 				DataBuildDate(&usrAccount.closeDate,outString);
				resultstring = outString;
			}
			else if (ARG(cx,11)) {
				DataBuildAmnt(TRUE,&usrAccount.beginAmount,outString);
				resultstring = outString;
			}
			break;

		case AREXX_GETBUDGET:
			arexxSel = ARGNUMBER(cx,0);
			catSel = ARGNUMBER(cx,1);
			if (arexxSel == 0 || arexxSel > entryCount || catSel != 1) {
				result = RC_WARN;
				resultstring = errMsg;
				break;
			}
			else {
				if (ARG(cx,2)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					resultstring = filt->entry->category;
				}
				else if (ARG(cx,3)) {
					filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
					DataBuildAmnt(TRUE,&filt->entry->amount,outString);
					resultstring = outString;
				}
			}
			break;

		case AREXX_OPEN:
			AmiOpen(ARGSTRING(cx,0),FALSE);
			break;

		case AREXX_QUIT:
			if (ARG(cx,1)) {
				amiChangedItems = FALSE;
				done = TRUE;
			}
			else done = AmiAsk(quitstr);
			break;

		case AREXX_ADDBUDGET:
			arexxSel = ARGNUMBER(cx,0);
			catSel = ARGNUMBER(cx,1);
			if (arexxSel > entryCount || arexxSel == 0 ) {
				result = RC_WARN;
				resultstring = errMsg;
				break;
			}

			filt = (filterNode *)DataOrd2Node( (struct List *)&filtered,arexxSel-1);
			strncpy(filt->entry->category,ARGSTRING(cx,1),CATNAMESIZE);
			amiChangedItems = TRUE;
			break;

		case AREXX_DELBUDGET:
			arexxSel = ARGNUMBER(cx,0);
			catSel = ARGNUMBER(cx,1);
			if (arexxSel > entryCount || arexxSel == 0 || catSel != 1) {
				result = RC_WARN;
				resultstring = errMsg;
				break;
			}

			amiChangedItems = TRUE;
			filt = (filterNode *)DataOrd2Node( (struct List *)&filtered,arexxSel-1);
			strcpy(filt->entry->category, "None");
			break;

		case AREXX_EDITRECORD:
			arexxSel = ARGNUMBER(cx,0);
			if (arexxSel == 0 || arexxSel > entryCount) {
				result = RC_WARN;
				resultstring = errMsg;
				break;
			}

			amiChangedItems = TRUE;
			filt = (filterNode *)DataOrd2Node( (struct List *)&filtered,arexxSel-1);

			if (ARG(cx,1)) {
				strncpy(filt->entry->name,ARGSTRING(cx,1),STRINGSIZE);
			}

			else if (ARG(cx,2)) {
				strncpy(filt->entry->memo,ARGSTRING(cx,2),STRINGSIZE);
			}
			else if (ARG(cx,3)) {
				if ( (resultint = DataVerifyDate(ARGSTRING(cx,3),outString)))
					DataStoreDate(&filt->entry->date,outString);
				else {
					result = RC_WARN;
					resultstring = errMsg;
					break;
				}
	
			}
			else if (ARG(cx,4)) {
				if ( (resultint = DataVerifyAmnt(ARGSTRING(cx,4),outString)))
					DataStoreAmnt(&filt->entry->amount,outString);
				else {
					result = RC_WARN;
					resultstring = errMsg;
					break;
				}
			}
			else if (ARG(cx,5)) {
				if (ARGNUMBER(cx,5))
					filt->entry->flags |= CLEARED;
				else	filt->entry->flags &= ~CLEARED;
			}

			else if (ARG(cx,6)) {
				if (filt->entry->type == CHECKTYPE && ARGNUMBER(cx,6))
					filt->entry->flags |= PRINTED;
				else	filt->entry->flags &= ~PRINTED;
			}

			else if (ARG(cx,7)) {
				if (filt->entry->type == CHECKTYPE && ARGNUMBER(cx,7))
					filt->entry->flags |= VOIDED;
				else	filt->entry->flags &= ~VOIDED;
			}

			else if (ARG(cx,8)) {
				if (ARGNUMBER(cx,8))
					filt->entry->flags |= TAXDEDUCT;
				else	filt->entry->flags &= ~TAXDEDUCT;
			}

			else if (ARG(cx,9)) {
				if (filt->entry->type == CHECKTYPE)
					filt->entry->check = ARGNUMBER(cx,9);
			}

			break;

		case AREXX_BUILDRECORD:
			if (ARG(cx,0)) {
				switch (ARGNUMBER(cx,0)) {
					case DEPOSITTYPE:
						new.type = DEPOSITTYPE;
						break;
					case WITHDRAWALTYPE:
						new.type = WITHDRAWALTYPE;
						break;
					case CHECKTYPE:
						new.type = CHECKTYPE;
						break;
				}
			}
			else if (ARG(cx,1)){
				strncpy(new.name,ARGSTRING(cx,1),STRINGSIZE);
			}
			else if (ARG(cx,2)) {
				strncpy(new.memo, ARGSTRING(cx,2),STRINGSIZE);
			}
			else if (ARG(cx,3)) {
				if ( (resultint = DataVerifyDate(ARGSTRING(cx,3),outString)))
					DataStoreDate(&new.date,outString);
				else {
					result = RC_WARN;
					resultstring = errMsg;
					break;
				}
			}
			else if (ARG(cx,4)) {
				if ( (resultint = DataVerifyAmnt(ARGSTRING(cx,4),outString)))
					DataStoreAmnt(&new.amount,outString);
				else {
					result = RC_WARN;
					resultstring = errMsg;
					break;
				}
			}
			else if (ARG(cx,5)) {
				if (ARGNUMBER(cx,5))
					new.flags |= CLEARED;
				else	new.flags &= ~CLEARED;
			}

			else if (ARG(cx,6)) {
				if (new.type == CHECKTYPE && ARGNUMBER(cx,6))
					new.flags |= PRINTED;
				else	new.flags &= ~PRINTED;
			}

			else if (ARG(cx,7)) {
				if (new.type == CHECKTYPE && ARGNUMBER(cx,7))
					new.flags |= VOIDED;
				else	new.flags &= ~VOIDED;
			}

			else if (ARG(cx,8)) {
				if (ARGNUMBER(cx,8))
					new.flags |= TAXDEDUCT;
				else	new.flags &= ~TAXDEDUCT;
			}

			else if (ARG(cx,9)) {
				if (new.type == CHECKTYPE)
					new.check = ARGNUMBER(cx,9);
			}
			break;

		case AREXX_BUILDBUDGET:
			strncpy(new.category,ARGSTRING(cx,0),CATNAMESIZE);
			break;
	
		case AREXX_PUTRECORD:
			/* verify our stuff.. */
			if ( currFile[0] == 0  || (new.type != CHECKTYPE && new.flags & (VOIDED|PRINTED))) {
				result = RC_WARN;
				resultstring = errMsg;
				break;
			}

			/* insert and update balance */
			amiChangedItems = TRUE;
			DataAddEntry(&new,&entries,&filt);
		
			/* zero out our copy */
			memset(&new,0,sizeof(entryNode));
			break;

		case AREXX_LOCK:
			AmiLock();
			break;

		case AREXX_UNLOCK:
			AmiUnlock();
			break;

		case AREXX_DELRECORD:
			arexxSel = ARGNUMBER(cx,0);
			if (arexxSel == 0 || arexxSel > entryCount) {
				result = RC_WARN;
				resultstring = errMsg;
				break;
			}
			
			filt = (filterNode *)DataOrd2Node((struct List *)&filtered,arexxSel-1);
			DataRemoveEntry(filt->entry,filt);
			amiChangedItems = TRUE;
			break;

		case AREXX_REBUILD:
			DataRebuildFilters();
			DataInitBalances();
			DataFilterBalance(&filtered);
			selRow = -1;

			DataBuildBal(usrAccount.decimal,&amntState.currAmnt,currStr);
			DataBuildBal(usrAccount.decimal,&filtAmnt,filtStr);

			AmiUpdateFilt(filtStr);
			AmiUpdateCurr(currStr);
			RegRedrawFilter(0);
			break;
 	}

#if 0
	if (result != RC_OK) {
		ReplyARexxMsg(cx,
			ER_ReturnCode,	result,
			ER_ErrorMessage, ER_ResultString,
			TAG_DONE);
	}
#endif
	if (result != RC_OK) {
		ReplyARexxMsg(cx,
			ER_Result,	result,
			ER_ErrorMessage, ER_ResultString,
			TAG_DONE);
	}

	else {
	 	ReplyARexxMsg(cx,
			ER_ReturnCode,	result,
			(resultstring==NULL)?TAG_IGNORE:ER_ResultString,resultstring,
			(resultstring==NULL)?ER_ResultLong:TAG_IGNORE,	resultint,
			TAG_DONE);
	}
 }

 return (done);
}
