#include "microdot.h"

#include "ogre.h"
#include "ogre_protos.h"

#define SD_OK 1
#define SD_CANCEL 2

#define SD_DEVICE 3
#define SD_UNIT 4
#define SD_BAUD 5
#define SD_RTS 6
#define SD_HS 7
#define SD_SHARED 8

#define SD_MINIT 9
#define SD_MDIAL 10
#define SD_MHANGUP 11

#define SD_ZMBUF 12

#define SD_XFER 13
#define SD_DTR 14

#define SD_CARRIER 15

#define SD_HYD_AUTOCHAT 16
#define SD_HYD_NOTIMEOUT 17

void doserialcfg( void )
{
	struct ogwin *ogw;
	struct Window *iw;
	struct IntuiMessage *im;
	char *xfermode[] = { "Z-Modem", "Z-Modem-8k", "Hydra", NULL };

	int Done = FALSE;

	if( !isv37 )
		xfermode[ 2 ] = NULL;

	ogw = ogreInitWindow( scr, 0, 0, "Modem-Konfiguration..." );

	ogreAddGroup( ogw, 0 | OGGP_EXPANDSTRING, OGFRAME_OUTLINE, " Serielle Parameter " );
	ogreAddString( ogw, 0, 'e', "D_evice:", SD_DEVICE, prefs.modemdevice, 32, 32 );
	ogreAddInteger( ogw, 1, 0,  "  Unit:", SD_UNIT, prefs.modemunit, 0, MAXINT, 16, 32 );
	ogreAddInteger( ogw, 1, 0, "Baud:", SD_BAUD, prefs.modembaud, 75, MAXINT, 16, 32 );
	ogreAddCheckbox( ogw, 2, 'r', "_RTS/CTS", SD_RTS, prefs.modemflags & 1 );
	ogreAddCheckbox( ogw, 2, 'h', "_Highspeed", SD_HS, prefs.modemflags & 2 );
	ogreAddCheckbox( ogw, 2, 's', "_Shared", SD_SHARED, prefs.modemflags & 4 );
	ogreAddCheckbox( ogw, 2, 'c', "_Carriercheck", SD_CARRIER, ! ( prefs.modemflags & 8 ) );
	ogreAddCycle( ogw, 3, 't', "Pro_tokoll", SD_XFER, xfermode, 16, prefs.pointxfer );
	ogreAddInteger( ogw, 4, 'z', "_Z-Modem-Dateipuffer", SD_ZMBUF, prefs.zmodembuffer, 1, MAXINT, 32, 32 );
	ogreAddCheckbox( ogw, 5, 0, "Hydra-Auto-Chat", SD_HYD_AUTOCHAT, prefs.hydra_autochat );
	ogreAddCheckbox( ogw, 5, 0, "Kein Hydra-Chattimeout", SD_HYD_NOTIMEOUT, prefs.hydra_nochattimeout );
	

	ogreAddGroup( ogw, 1 | OGGP_EXPANDSTRING, OGFRAME_OUTLINE, " Modem-Kommandos " );
	ogreAddString( ogw, 0, 'i', "    _Init:", SD_MINIT, prefs.modeminit, 32, 80 );
	ogreAddString( ogw, 1, 0,   "  Wählen:", SD_MDIAL, prefs.modemdial, 32, 80 );
	ogreAddString( ogw, 2, 0,   "Auflegen:", SD_MHANGUP, prefs.modemhangup, 32, 80 );
	ogreAddCheckbox( ogw, 3, 'd', "Auflegen per _DTR-Drop", SD_DTR, prefs.modem_dropdtr );

	ogreAddGroup( ogw, 2, OGFRAME_NONE, NULL );
	ogreAddButton( ogw, 0 | OGB_ONENTER, 'o', "_OK", SD_OK );
	ogreAddHelp( ogw, 0 );
	ogreAddButton( ogw, 0 | OGB_ONESC, 'a', "_Abbruch", SD_CANCEL );

	iw = ogreOpenWindow( ogw );
	if( !iw )
		return;

	while( !Done )
	{
		ogreEnable( ogw, ogreValue( ogw, SD_XFER ) != 2, SD_ZMBUF, 0 );

		im = ogreWaitIM( ogw );

		if( im->Class == IDCMP_GADGETHELP)
			showguidenum( "modemwin_gads", im->Code );
		else if( im->Class == IDCMP_GADGETUP )
		{
			switch( im->Code )
			{
				case SD_OK:
					Done = 2;
					break;
				case SD_CANCEL:
					Done = 1;
					break;

			}
		}
		ogreIMReply( ogw, im );
	}

	if( Done == 2 )
	{
		ogreCopyStringValue( ogw, SD_DEVICE, prefs.modemdevice );
		ogreCopyStringValue( ogw, SD_MINIT, prefs.modeminit );
		ogreCopyStringValue( ogw, SD_MDIAL, prefs.modemdial );
		ogreCopyStringValue( ogw, SD_MHANGUP, prefs.modemhangup );

		prefs.modemunit    = ogreValue( ogw, SD_UNIT );
		prefs.modembaud    = ogreValue( ogw, SD_BAUD );
		prefs.zmodembuffer = ogreValue( ogw, SD_ZMBUF );
		prefs.pointxfer	   = ogreValue( ogw, SD_XFER );

		prefs.hydra_nochattimeout = ogreValue( ogw, SD_HYD_NOTIMEOUT );
		prefs.hydra_autochat = ogreValue( ogw, SD_HYD_AUTOCHAT );

		prefs.modem_dropdtr = ogreValue( ogw, SD_DTR );

		if( ogreValue( ogw, SD_RTS ) )
			prefs.modemflags |= 1;
		else
			prefs.modemflags &= ~1;

		if( ogreValue( ogw, SD_HS ) )
			prefs.modemflags |= 2;
		else
			prefs.modemflags &= ~2;

		if( ogreValue( ogw, SD_SHARED ) )
			prefs.modemflags |= 4;
		else
			prefs.modemflags &= ~4;

		if( !ogreValue( ogw, SD_CARRIER ) )
			prefs.modemflags |= 8;
		else
			prefs.modemflags &= ~8;

	}

	ogreExitWindow( ogw );
}

#ifndef NO_RFC

#define RI_OK 1
#define RI_CANCEL 2
#define RI_FMTMAIL 3
#define RI_FMTNEWS 4
#define RI_BATCHNEWS 5
#define RI_BATCHMAIL 6
#define RI_CICOOPT 7
#define RI_CICOCON 8
#define RI_LOGIN 9

static void rfcopts( void )
{
	struct ogwin *ogw;
	struct Window *iw;
	struct IntuiMessage *im;
	int Done = FALSE;
	char *sevenbit[] = { "7 Bit (ASCII)", "8 Bit (ISO-8859-1)", NULL };
	char *newsb[] = { "Compress", "GZip", NULL };
	//char *mailb[] = { "Ungebatcht", "bsmtp unkomprimiert", "bsmtp Compress", "bsmtp GZip", NULL };

	ogw = ogreInitWindow( scr, 0, 0, "RFC/UUCP-Konfiguration..." );

	ogreAddGroup( ogw, 0 | OGGP_EXPANDSTRING, OGFRAME_OUTLINE, " Daten-Format " );
	ogreAddCycle( ogw, 0, 'n', "_News:", RI_FMTNEWS, sevenbit, 20, prefs.rfc_newsfmt );
	//ogreAddCycle( ogw, 0, 'm', "_Mail:", RI_FMTMAIL, sevenbit, 20, prefs.rfc_mailfmt );
	ogreAddCycle( ogw, 1, 'b', "News_batch-Modus:", RI_BATCHNEWS, newsb, 40, prefs.rfc_newsbatch );
	//ogreAddCycle( ogw, 2, 't', "Mail_batch-Modus:", RI_BATCHMAIL, mailb, 40, prefs.rfc_mailbatch );

	ogreAddGroup( ogw, 1 | OGGP_EXPANDSTRING, OGFRAME_OUTLINE, " UUCICO-Optionen " );
	ogreAddString( ogw, 0, 'l', "_Login-Script:", RI_LOGIN, prefs.rfc_login, 40, 256 );
	ogreAddString( ogw, 1, 'c', "_CON:-Fenster", RI_CICOCON, prefs.rfc_cicocon, 40, 256 );
	ogreAddString( ogw, 2, 'p', "Zusätzliche O_ptionen:", RI_CICOOPT, prefs.rfc_cicoopts, 40, 128 );

	ogreAddGroup( ogw, 2, OGFRAME_NONE, NULL );
	ogreAddButton( ogw, 0 | OGB_ONENTER, 'o', "_OK", RI_OK );
	ogreAddHelp( ogw, 0 );
	ogreAddButton( ogw, 0 | OGB_ONESC, 'a', "_Abbruch", RI_CANCEL );

	iw = ogreOpenWindow( ogw );
	if( !iw )
		return;

	while( !Done )
	{
		im = ogreWaitIM( ogw );

		if( im->Class == IDCMP_GADGETHELP)
			showguidenum( "rfcwin_gads", im->Code );
		else if( im->Class == IDCMP_GADGETUP )
		{
			switch( im->Code )
			{
				case RI_OK:
					Done = 2;
					break;

				case RI_CANCEL:
					Done = 1;
					break;
			}
		}
		ogreIMReply( ogw, im );
	}

	if( Done == 2 )
	{
		prefs.rfc_newsfmt = ogreValue( ogw, RI_FMTNEWS );
		//prefs.rfc_mailfmt = ogreValue( ogw, RI_FMTMAIL );
		prefs.rfc_newsbatch = ogreValue( ogw, RI_BATCHNEWS );
		//prefs.rfc_mailbatch = ogreValue( ogw, RI_BATCHMAIL );

		ogreCopyStringValue( ogw, RI_CICOCON, prefs.rfc_cicocon );
		ogreCopyStringValue( ogw, RI_CICOOPT, prefs.rfc_cicoopts );
		ogreCopyStringValue( ogw, RI_LOGIN, prefs.rfc_login );
	}

	ogreExitWindow( ogw );
}

#endif


#define PD_OK 1
#define PD_CANCEL 2

#define PD_BOX 3
#define PD_BOXDOMAIN 4
#define PD_USER 5
#define PD_POINT 6
#define PD_PW 7
#define PD_PACK 8
#define PD_UNPACK 9
#define PD_PHONE 10
#define PD_RETRIES 11
#define PD_RETRYDELAY 12
#define PD_TIMEOUT 13
#define PD_PACKTIMEOUT 14
#define PD_NETCALLMODE 15
#define PD_USERPW 16
#define PD_NETCALLSAVE 17
#define PD_CRLF 18
#define PD_BREAKLOGIN 19
#define PD_RFC 20

#define PD_IP 21

#define PD_JANUS2 22

extern int allow_rfc;

static void renameuser( char *olduser, char *newuser )
{
	struct mbrett *mb = ( struct mbrett * ) brettlist.lh_Head;
	char newname[ 80 ];

	pushdir( prefs.datadir );
	UnLock( CreateDir( prefs.username ) );
	while( !Rename( olduser, newuser ) )
	{
		if( !askreq( "AmigaDOS-Fehler %ld beim Umbenennen des\nUserpostfachs von %s nach %s!", "Wiederholen|Ignorieren", IoErr(), olduser, newuser ) )
			break;
	}
	popdir();

	saveprefs( currentprefsname );

	strcpy( mb->b.name, newuser );

	mb = GetEntry( &brettlist, 4 );

	while( mb && mb->n.ln_Succ && ( mb->b.flags & BFLAG_EXTEND_PM ) )
	{
		sprintf( newname, "%s/%s", newuser, strchr( mb->b.name, '/' ) + 1 );
		strcpy( mb->b.name, newname );
		mb = ( struct mbrett * ) mb->n.ln_Succ;
	}
}

extern void enablejanus2menus( void );

int dopointcfg( void )
{
	struct ogwin *ogw;
	struct Window *iw;
	struct IntuiMessage *im;
	int Done = FALSE;
	char buffer[ 256 ];
	int ncmode = prefs.mode;
	char *netcallmode_options[] = 
	{
	      "ZConnect",
	      "Netcall3.8",
	      NULL,
		  NULL
	};


/*	if( ncmode )
		ncmode = 1;*/

	if( !allow_rfc )
	{
		if( ncmode == MDM_RFC )
			ncmode = MDM_JANUS;
	}
	else
	{
		if( !netcallmode_options[ 2 ] )
		{
			netcallmode_options[ 2 ] = netcallmode_options[ 1 ];
			netcallmode_options[ 1 ] = "RFC/UUCP";
		}
	}

	ogw = ogreInitWindow( scr, 0, 0, "Point-Konfiguration..." );

	ogreAddGroup( ogw, 0 | OGGP_EXPANDSTRING, OGFRAME_OUTLINE, " Netz " );

	ogreAddString( ogw, 0, 'b', "  _Boxname:", PD_BOX, prefs.boxname, 20, 40 );
	ogreAddString( ogw, 0, 0,   "    Boxdomain:", PD_BOXDOMAIN, prefs.boxdomain, 20, 40 );
	ogreAddString( ogw, 1, 0,   " Username:", PD_USER, prefs.username, 20, 40 );
	ogreAddString( ogw, 1, 0,   " Userpasswort:", PD_USERPW, prefs.userpassword, 20, 40 );
	ogreAddString( ogw, 2, 0,   "Pointname:", PD_POINT, prefs.pointname, 20, 40 );
	ogreAddString( ogw, 2, 0,   "Pointpasswort:", PD_PW, prefs.password, 20, 40 );

	ogreAddGroup( ogw, 1 | OGGP_EXPANDSTRING, OGFRAME_OUTLINE, " Packer " );
	ogreAddString( ogw, 0, 'p', "   _Packer:", PD_PACK, prefs.packer, 20, 40 );
	ogreAddString( ogw, 0, 0,   "Entpacker:", PD_UNPACK, prefs.unpacker, 20, 40 );

	ogreAddGroup( ogw, 2 | OGGP_EXPANDSTRING, OGFRAME_OUTLINE, " Anruf " );
	ogreAddString( ogw, 0, 't', " _Telefon:", PD_PHONE, prefs.phone, 40, 128 );
	ogreAddInteger( ogw, 1, 0, "Versuche:", PD_RETRIES, prefs.dialretries, 1, MAXINT, 12, 12 );
	ogreAddInteger( ogw, 1, 0, "        Anwahlpause:", PD_RETRYDELAY, prefs.retrydelay, 1, MAXINT, 12, 12 );
	ogreAddInteger( ogw, 2, 0, " Timeout:", PD_TIMEOUT, prefs.dialtimeout, 10, MAXINT, 12, 12 );
	ogreAddInteger( ogw, 2, 0, "Timeout beim Packen:", PD_PACKTIMEOUT, prefs.packtimeout, 30, MAXINT, 12, 12 );
	ogreAddCycle( ogw, 3, 'n', "_Netcallmodus:", PD_NETCALLMODE, netcallmode_options, 11, ncmode );
	ogreAddCheckbox( ogw, 3, 'j', "_Janus2?", PD_JANUS2, prefs.flags2 & MDF2_JANUS2 );
	ogreAddCheckbox( ogw, 3, 'e', "_Empfangene Daten sichern?", PD_NETCALLSAVE, prefs.netcall_save );
	ogreAddCheckbox( ogw, 4, 'c', "_CR/LF verwenden?", PD_CRLF, prefs.flags2 & MDF2_NETCALLCRLF );
	ogreAddCheckbox( ogw, 4, 'l', "_Login abbrechen?", PD_BREAKLOGIN, prefs.flags2 & MDF2_BREAKLOGIN );
#if 0
	if( SocketBase )
		ogreAddCheckbox( ogw, 4, 's', "_CLIPSaug?", PD_IP, prefs.flags2 & MDF2_CLIPSAUG );
#endif

	ogreAddGroup( ogw, 3, OGFRAME_NONE, NULL );
	ogreAddButton( ogw, 0 | OGB_ONENTER, 'o', "_OK", PD_OK );

	if( allow_rfc )
		ogreAddButton( ogw, 0, 'r', "_RFC/UU-Optionen", PD_RFC );

	ogreAddHelp( ogw, 0 );
	ogreAddButton( ogw, 0 | OGB_ONESC, 'a', "_Abbruch", PD_CANCEL );

	iw = ogreOpenWindow( ogw );
	if( !iw )
		return( 0 );

	while( !Done )
	{
		ogreEnable( ogw, ogreValue( ogw, PD_NETCALLMODE ) == MDM_RFC,
			PD_RFC,
			0
		);

		ogreEnable( ogw, ogreValue( ogw, PD_NETCALLMODE ) == MDM_JANUS,
			PD_JANUS2,
			0
		);

		ogreEnable( ogw, ogreValue( ogw, PD_NETCALLMODE ) != MDM_RFC,
			PD_PW,
			PD_PACK, PD_UNPACK,
			PD_PACKTIMEOUT, PD_NETCALLSAVE, PD_CRLF, PD_BREAKLOGIN,
			0
		);

		im = ogreWaitIM( ogw );

		if( im->Class == IDCMP_GADGETHELP)
			showguidenum( "pointwin_gads", im->Code );
		else if( im->Class == IDCMP_GADGETUP )
		{
			switch( im->Code )
			{
				case PD_OK:
					ncmode = ogreValue( ogw, PD_NETCALLMODE );
					if( ncmode != MDM_RFC )
					{
						ogreCopyStringValue( ogw, PD_PACK, buffer );
						if( !checkprograminpath( buffer ) )
						{
							char *p = strchr( buffer, ' ' );
							if( p )
								*p = 0;
							askreq( "Packer \"%s\" nicht gefunden!\nDas Program muß im Pfad liegen und aufrufbar sein!",
								"Abbruch",
								buffer
							);
							ogreActivate( ogw, PD_PACK );
							break;
						}

						ogreCopyStringValue( ogw, PD_UNPACK, buffer );
						if( !checkprograminpath( buffer ) )
						{
							char *p = strchr( buffer, ' ' );
							if( p )
								*p = 0;
							askreq( "Entpacker \"%s\" nicht gefunden!\nDas Program muß im Pfad liegen und aufrufbar sein!",
								"Abbruch",
								buffer
							);
							ogreActivate( ogw, PD_UNPACK );
							break;
						}
					}

					Done = 2;
					break;

				case PD_CANCEL:
					Done = 1;
					break;

#ifndef NO_RFC
				case PD_RFC:
					ogreLockWindow( ogw );
					rfcopts();
					ogreUnlockWindow( ogw );
					break;
#endif
			}
		}
		ogreIMReply( ogw, im );
	}

	if( Done == 2 )
	{
		char *p;

		ogreCopyStringValue( ogw, PD_BOX, prefs.boxname );
		ogreCopyStringValue( ogw, PD_BOXDOMAIN, prefs.boxdomain );

		p = ogreStringValue( ogw, PD_USER );
		if( !( prefs.flags2 & MDF2_NOPREFS ) && strcmp( p, prefs.username ) )
		{
			renameuser( prefs.username, p );
			strcpy( prefs.username, p );
			settitletxt();
			makebrettview();
			displayscroller();
		}
		else
			strcpy( prefs.username, p );

		ogreCopyStringValue( ogw, PD_USERPW, prefs.userpassword );
		ogreCopyStringValue( ogw, PD_POINT, prefs.pointname );
		ogreCopyStringValue( ogw, PD_PW, prefs.password );
		ogreCopyStringValue( ogw, PD_PACK, prefs.packer );
		ogreCopyStringValue( ogw, PD_UNPACK, prefs.unpacker );

		ogreCopyStringValue( ogw, PD_PHONE, prefs.phone );

		prefs.dialretries = ogreValue( ogw, PD_RETRIES );
		prefs.dialtimeout = ogreValue( ogw, PD_TIMEOUT );
		prefs.packtimeout = ogreValue( ogw, PD_PACKTIMEOUT );
		prefs.retrydelay  = ogreValue( ogw, PD_RETRYDELAY );

		prefs.netcall_save = ogreValue( ogw, PD_NETCALLSAVE );

#if 0
		if( SocketBase )
		{
			if( ogreValue( ogw, PD_IP ) )
				prefs.flags2 |= MDF2_CLIPSAUG;
			else
				prefs.flags2 &= ~MDF2_CLIPSAUG;
		}
#endif

		if( allow_rfc )
		{
			prefs.mode = ogreValue( ogw, PD_NETCALLMODE );
		}
		else
		{
			if( ogreValue( ogw, PD_NETCALLMODE ) )
				prefs.mode = MDM_N38;
			else
				prefs.mode = MDM_JANUS;
		}

		if( ogreValue( ogw, PD_CRLF ) )
			prefs.flags2 |= MDF2_NETCALLCRLF;
		else
			prefs.flags2 &= ~MDF2_NETCALLCRLF;

		if( ogreValue( ogw, PD_JANUS2 ) )
			prefs.flags2 |= MDF2_JANUS2;
		else
			prefs.flags2 &= ~MDF2_JANUS2;

		if( ogreValue( ogw, PD_BREAKLOGIN ) )
			prefs.flags2 |= MDF2_BREAKLOGIN;
		else
			prefs.flags2 &= ~MDF2_BREAKLOGIN;

		if( prefs.boxdomain[0] != '.' )
			strins( prefs.boxdomain, "." );

		enablejanus2menus();
	}

	ogreExitWindow( ogw );

	return( Done == 2 );
}