/*
 * WriteMyMsg -- Schreibe eine Nachricht in die UMS-Messagebase
 *
 */

UMSMsgNum
WriteMsg (int type)
{
  BOOL msgisread = FALSE;
  struct Window *win = Mywindow;
  UMSUserAccount acc = account;

  /* eine vorbereitete Nachricht kann mit UMSWrite() */
  /* geschrieben werden: */
  BOOL okay = TRUE;

  /* Variablen für UMS-Interface */
  UMSMsgNum num = 0;		/* Ergebnis von UMSWriteMsg() = Nr. geschriebener Nachricht */
  UMSMsgTextFields wtf;		/* neue Mail-Texttags für UMSWriteMsg(UMSTAG_WTextFields) */
  UMSMsgTextFields stf;		/* alte Mail-Texttags eineer eventuellen Bezugsnachricht */

  int i = 0;			/* Schleifenzähler */

  /* Textfield-Handling Puffer und Pointer */
  ULONG txtbuffer = NULL;		/* Textbuffer */
  ULONG txtsize = 0;		/* Länge Textbuffers (byte) */
  STRPTR buffer = NULL;		/* dynamisch allozierten Textpuffer */

  /* Dialog Puffer und Pointer */

  STRPTR to = malloc (MAXCHARS + 1);
  STRPTR toa = malloc (MAXCHARS + 1);
  STRPTR subj = malloc (MAXCHARS + 1);

  if (to && toa && subj)
    {
      printf ("Strs erledigt. %10s %10s %10s", to, toa, subj);

      i = 0;
      while (i <= UMSNUMFIELDS)	/* = 128 ! */
	{
	  wtf[i] = NULL;	/* initialisiere Feld */
	  stf[i] = NULL;	/* initialisiere Feld */
	  i++;
	}

      /* Fallunterscheidung FollowUp/Reply */
      /* Gibt es eine Bezugsnachricht? */

      if (type == FOLLOWUP | type == REPLY)
	if (!GetGlobMsgNum() )
	  {
	    ShowError ("Keine Bezugsmessage für FollowUp oder Reply.\nSchreiben abgebrochen.");
	    return (0);
	  }
	else
	  {
	    /* Bezug vorhanden: für Reply und FollowUp Bezugsnachricht lesen: */
	    printf ("Lese Bezugsnachricht %ld\n", GetGlobMsgNum());
	    if (!UMSReadMsgTags (acc,
				 UMSTAG_RMsgNum, GetGlobMsgNum(),
				 UMSTAG_RTextFields, &stf,	/* global UMSMsgTextFields */
				 UMSTAG_RReadAll, NULL,
				 UMSTAG_RNoUpdate, 1L,
				 TAG_DONE))
	      {
		CheckErr ();	/* Gebe die UMS-Fehlermeldung aus */
		return (0);	/* breche Schreiben ab */
	      }
	    else
	      {
		msgisread = TRUE;
		printf ("Msg %ld gelesen. ", GetGlobMsgNum());
	      }
	  }			/* Ende der Sonderbehandlung Reply/FollowUp */


      /* Textfield-Gadget sperren. Dann Textbuffer auslesen. */
      /* (Der Textfield-Textbuffer ist nicht Null-terminiert!) */

      SetGadgetAttrsX (txtfld, win, NULL,
		       TEXTFIELD_ReadOnly, TRUE,	/* sperren */
		       TAG_END);

      GetAttr (TEXTFIELD_Text, txtfld, &txtbuffer);	/* Bufferadresse lesen */
      GetAttr (TEXTFIELD_Size, txtfld, &txtsize);	/* Bufferlänge lesen */

      if (txtsize && txtbuffer)	/* ist wirklich Text im Buffer? */
	if (buffer = malloc (txtsize + 1))	/* kann Speicher reserviert werden? */
	  {
	    /* Text aus Textfield-Puffer kopieren */
	    printf ("memcpy: ");
	    memcpy ((ULONG *) buffer, (ULONG *) txtbuffer, txtsize);

            printf ("Switch ");
	    /* kopiere Strings für Mailtags (= FROM; TO; GROUP usw...) */
	    switch (type)
	      {
	      case EMAIL:
		strncpy (to, NB_AUTHOR_NAME, MAXCHARS);		/* Defaultsettings, todo */
		strncpy (toa, NB_AUTHOR_EMAIL, MAXCHARS);
		strncpy (subj, "Support " NB_VERSION, MAXCHARS);
		printf (":Strs sind kopiert. ");
		break;

	      case REPLY:
		if (stf[UMSCODE_ReplyName])	/* todo: testen! */
		  {
		    printf ("Reply-Name gesetzt.");
		    strncpy (to, stf[UMSCODE_ReplyName], MAXCHARS);
		  }
		else
		  {
		    strncpy (to, stf[UMSCODE_FromName], MAXCHARS);
		  }

		if (stf[UMSCODE_ReplyAddr])
		  {
		    printf ("Reply-Adresse gesetzt.");
		    strncpy (toa, stf[UMSCODE_ReplyAddr], MAXCHARS);
		  }
		else
		  {
		    strncpy (toa, stf[UMSCODE_FromAddr], MAXCHARS);
		  }

		/* "Re:"-Behandlung: */
		if (0 == strncmp ("Re:", stf[UMSCODE_Subject], 3))
		  {
		    /* altes Subjekt beginnt mit "Re: ", */
		    /* Subject aus Bezugsnachricht übernehmen: */
		    strncpy (subj, stf[UMSCODE_Subject], MAXCHARS);
		  }
		else
		  {
		    /* Subject ohne "Re:": */
		    /* "Re: " dem Subject voranstellen */
		    strncpy (subj, "Re: ", MAXCHARS);
		    strncat (subj, stf[UMSCODE_Subject], (MAXCHARS - 4));
		  }

		break;		/* REPLY */

	      case POSTING:
		strncpy (to, "", MAXCHARS);
		strncpy (toa, GlobMsgGroup ? GlobMsgGroup : "", MAXCHARS);
		strncpy (subj, "", MAXCHARS);
		break;

	      case FOLLOWUP:
		strncpy (to, stf[UMSCODE_FromName], MAXCHARS);

		/* besondere Reply-Gruppe gewünscht ? */
		if (stf[UMSCODE_ReplyGroup])
		  {		/* todo: multi-replys werden noch nicht behandelt: */
		    /* "poster" Behandlung todo */
		    strncpy (toa, stf[UMSCODE_ReplyGroup], MAXCHARS);
		  }
		else
		  {
		    strncpy (toa, stf[UMSCODE_Group], MAXCHARS);
		  }

		/* Subject-"Re: "-Behandlung, wie bei REPLY: todo */
		if (0 == strncmp ("Re:", stf[UMSCODE_Subject], 3))
		  {
		    /* altes Subjekt beginnt mit "Re: ", */
		    /* Subject aus Bezugsnachricht übernehmen: */
		    strncpy (subj, stf[UMSCODE_Subject], MAXCHARS);
		  }
		else
		  {
		    /* Subject ohne "Re:": */
		    /* "Re: " dem Subject voranstellen */
		    strncpy (subj, "Re: ", MAXCHARS);
		    strncat (subj, stf[UMSCODE_Subject], (MAXCHARS - 4));
		  }

		break;		/* FOLLOWUP */

	      default:
		ShowError ("Error in switch-statement. Never reach this!\n");
		break;
	      }

	    /* Aufbau eines Dialog-GUI: */
	    /* to, toa, subj sind STRPTR */
	    /* type ist EMAIL, REPLY, FOLLOWUP, POSTING */

	    printf ("Dialog: ");

	    i = Dialog (to, toa, subj, type);	/* Dialogfenster */

	    /* i ist ein returncode, bei NOSELECT hat User den Dialog abgebrochen */
	    if (i != NOSELECT)
	      {
		printf ("wtfs: ");
		/* Standardbelegung */
		wtf[UMSCODE_MsgText] = buffer;
		wtf[UMSCODE_ToName] = to;
		wtf[UMSCODE_Subject] = subj;
		wtf[UMSCODE_FromName] = realname;	/*todo: FromAddr ? */
		wtf[UMSCODE_Newsreader] = NB_TAG;	/* Version, Datum & Email von Autor */
		printf (" fertig. ");

		switch (type)	/*todo */
		  {
		  case EMAIL:	/*todo */
		    wtf[UMSCODE_ToAddr] = toa;
		    break;

		  case REPLY:	/*todo */
		    wtf[UMSCODE_ToAddr] = toa;
		    break;

		  case POSTING:	/*todo */
		    wtf[UMSCODE_Group] = toa;
		    break;

		  case FOLLOWUP:	/*todo */
		    wtf[UMSCODE_Group] = toa;
		    break;
		  }

		/* Ausgabe fürs Debugging */
		i = 0;
		while (i < 50)
		  {
		    if (wtf[i])
		      printf ("%ld -- %50.50s\n", i, wtf[i]);
		    i = i + 1;
		  };


		/* schreibe die Nachricht in UMS-Messagebase */
		if (okay)	/* alles okay für Schreiben? */
		  {
                    printf ("Schreibe: ");

		    num = UMSWriteMsgTags (acc,
					   UMSTAG_WTextFields, &wtf,
					   (type == REPLY) ? UMSTAG_WChainUp : TAG_IGNORE, GlobMsgNum,
					   (type == FOLLOWUP) ? UMSTAG_WChainUp : TAG_IGNORE, GlobMsgNum,
					   TAG_DONE);

		    printf (" WrtTags %ld ", num);

		    if (!num)	/* Konnte in Messagebase geschrieben werden? */
		      {
			CheckErr ();	/* Gebe den entspr. UMS-Fehler aus */
			printf ("%20.20s Nachricht nicht geschrieben!\n ", msgtypename[type]);
		      }
		    else
		      {
			/* todo */
			STRPTR sbuffer = NULL;
			if (sbuffer = malloc (255))  /* Fehlerquelle: buf zu klein! */
			  {
			    sprintf (sbuffer, "%.9s erfolgreich als Nr. %ld geschrieben.\n" \
				     "%.60s\n%.60s\n%.90s\n", 
                                     msgtypename[type], num, to, toa, subj);
			    ShowReq (NULL, sbuffer, NULL);
			    free (sbuffer);
			  }
		      }

		  }
		else
		  printf ("WriteMsg: Msg nicht okay zum Schreiben.\n");

	      }
	    else
	      printf ("User brach WriteMsg Dialog ab.\n");	/* noselect */
	  }			/* if */
	else
	  {
	    ShowError ("- kein Text vorhanden oder\n- zuwenig Speicher für Write ");
	  }

      if (msgisread)
        {
        printf("Free Msg ");
	UMSFreeMsg (acc, GetGlobMsgNum());	/* todo */
        }

      if (buffer)
	free (buffer);

      SetGadgetAttrsX (txtfld, win, NULL,
		       TEXTFIELD_ReadOnly, FALSE,
		       TAG_DONE);
    }
  if (to)
    free (to);
  if (toa)
    free (toa);
  if (subj)
    free (subj);

  return (num);
}