/* GNU Mailutils -- a suite of utilities for electronic mail
   Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

   GNU Mailutils is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GNU Mailutils is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GNU Mailutils; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA  */

/* This file implements an MH draftfile stream: a read-only stream used
   to transparently pass MH draftfiles to mailers. The only difference
   between the usual RFC822 and MH draft is that the latter allows to use
   a string of dashes to separate the headers from the body. */

#include <mh.h>
#include <mailutils/stream.h>

static int
_mh_delim (char *str)
{
  if (str[0] == '-')
    {
      for (; *str == '-'; str++)
	;
      for (; *str == ' ' || *str == '\t'; str++)
	;
    }
  return str[0] == '\n';
}

struct _mhdraft_stream {
  stream_t stream;     /* Actual stream */
  size_t mark_offset;  /* Offset of the header separator */
  size_t mark_length;  /* Length of the header separator (not counting the
			  newline) */
};

static int
_mhdraft_read (stream_t stream, char *optr, size_t osize,
	       off_t offset, size_t *nbytes)
{
  struct _mhdraft_stream *s = stream_get_owner (stream);

  if (offset < s->mark_offset)
    {
      if (offset + osize >= s->mark_offset)
	osize = s->mark_offset - offset;
    }
  else
    offset += s->mark_length;
  return stream_read (s->stream, optr, osize, offset, nbytes);
}
  
static int
_mhdraft_readline (stream_t stream, char *optr, size_t osize,
		   off_t offset, size_t *nbytes)
{
  struct _mhdraft_stream *s = stream_get_owner (stream);
    
  if (offset < s->mark_offset)
    {
      if (offset + osize >= s->mark_offset)
	{
	  int rc;
	  size_t n;
	  size_t rdsize = s->mark_offset - offset + 1;

	  rc = stream_readline (s->stream, optr, rdsize, offset, &n);
	  if (rc == 0)
	    {
	      if (nbytes)
		*nbytes = n;
	    }
	  return rc;
	}
    }
  else
    offset += s->mark_length;

  return stream_readline (s->stream, optr, osize, offset, nbytes);
}
  
static int
_mhdraft_size (stream_t stream, off_t *psize)
{
  struct _mhdraft_stream *s = stream_get_owner (stream);
  int rc = stream_size (s->stream, psize);
  
  if (rc == 0)
    *psize -= s->mark_length;
  return rc;
}
  
static int
_mhdraft_open (stream_t stream)
{
  struct _mhdraft_stream *s = stream_get_owner (stream);
  size_t offset, len;
  char buffer[256];
  int rc;

  offset = 0;
  while ((rc = stream_readline (s->stream, buffer, sizeof buffer,
				offset, &len)) == 0
	 && len > 0)
    {
      if (_mh_delim (buffer))
	{
	  s->mark_offset = offset;
	  s->mark_length = len - 1; /* do not count the terminating newline */
	  break;
	}

      offset += len;
    }
  return 0;
}

static int
_mhdraft_close (stream_t stream)
{
  struct _mhdraft_stream *s = stream_get_owner (stream);
  return stream_close (s->stream);
}

static void
_mhdraft_destroy (stream_t stream)
{
  struct _mhdraft_stream *s = stream_get_owner (stream);
  if (s->stream)
    stream_destroy (&s->stream, stream_get_owner (s->stream));
  free (s);
}
    
int
mhdraft_stream_create (stream_t *stream, stream_t src, int flags)
{
  struct _mhdraft_stream *s;
  int rc;

  if (!flags)
    flags = MU_STREAM_READ;
  if (flags != MU_STREAM_READ)
    return EINVAL;

  s = calloc (1, sizeof (*s));
  if (s == NULL)
    return ENOMEM;

  s->stream = src;
  
  rc = stream_create (stream, flags|MU_STREAM_NO_CHECK, s);
  if (rc)
    {
      free (s);
      return rc;
    }
  
  stream_set_open (*stream, _mhdraft_open, s);
  stream_set_close (*stream, _mhdraft_close, s);
  stream_set_destroy (*stream, _mhdraft_destroy, s);
  stream_set_readline (*stream, _mhdraft_readline, s);
  stream_set_read (*stream, _mhdraft_read, s);
  stream_set_size (*stream, _mhdraft_size, s);

  return 0;  
}



/* *************************** MH draft message **************************** */

char *
skipws (char *p, size_t off)
{
  int len;
  for (p += off; *p && isspace (*p); p++)
    ;
  len = strlen (p);
  if (len > 0 && p[len-1] == '\n')
    p[len-1] = 0;
  return p;
}

struct _mhdraft_message
{
  char *from;
  char *date;
  off_t body_start;
  off_t body_end;
};

static int
restore_envelope (stream_t str, struct _mhdraft_message **pmenv)
{
  size_t offset = 0;
  char *from = NULL;
  char *env_from = NULL;
  char *env_date = NULL;
  int rc;
  char buffer[80];
  size_t len;
  off_t body_start, body_end;
  
  while ((rc = stream_readline (str, buffer, sizeof buffer, offset, &len)) == 0
	 && len > 0)
    {
      if (buffer[0] == '\n')
	break;
      buffer[len] = 0;
      offset += len;
      if (strncasecmp (buffer, MU_HEADER_FROM,
		       sizeof (MU_HEADER_FROM) - 1) == 0)
	from = strdup (skipws (buffer, sizeof (MU_HEADER_FROM)));
      else if (strncasecmp (buffer, MU_HEADER_ENV_SENDER,
			    sizeof (MU_HEADER_ENV_SENDER) - 1) == 0)
	env_from = strdup (skipws (buffer, sizeof (MU_HEADER_ENV_SENDER)));
      else if (strncasecmp (buffer, MU_HEADER_ENV_DATE,
			    sizeof (MU_HEADER_ENV_DATE) - 1) == 0)
	env_date = strdup (skipws (buffer, sizeof (MU_HEADER_ENV_DATE)));
    }

  body_start = offset + 1;
  stream_size (str, &body_end);
  
  if (!env_from)
    {
      if (from)
	{
	  address_t addr;
	  
	  address_create (&addr, from);
	  if (!addr
	      || address_aget_email (addr, 1, &env_from))
	    env_from = strdup ("GNU-MH");
	  address_destroy (&addr);
	}
      else
	env_from = strdup ("GNU-MH");
    }
	  
  if (!env_date)
    {
      struct tm *tm;
      time_t t;
      char date[80];

      time(&t);
      tm = gmtime(&t);
      strftime (date, sizeof (date), "%a %b %e %H:%M:%S %Y", tm);
      env_date = strdup (date);
    }

  *pmenv = xmalloc (sizeof (**pmenv)
		    + strlen (env_from)
		    + strlen (env_date)
		    + 2);
  (*pmenv)->from = (char*) (*pmenv + 1);
  (*pmenv)->date = (char*) ((*pmenv)->from + strlen (env_from) + 1);

  strcpy ((*pmenv)->from, env_from);
  strcpy ((*pmenv)->date, env_date);

  (*pmenv)->body_start = body_start;
  (*pmenv)->body_end = body_end;
  
  free (env_from);
  free (env_date);
  free (from);
  return 0;
}

static int
_env_msg_date (envelope_t envelope, char *buf, size_t len, size_t *pnwrite)
{
  message_t msg = envelope_get_owner (envelope);
  struct _mhdraft_message *env = message_get_owner (msg);
  
  if (!env || !env->date)
    return EINVAL;
  strncpy (buf, env->date, len);
  buf[len-1] = 0;
  return 0;
}

static int
_env_msg_sender (envelope_t envelope, char *buf, size_t len, size_t *pnwrite)
{
  message_t msg = envelope_get_owner (envelope);
  struct _mhdraft_message *env = message_get_owner (msg);
  
  if (!env || !env->from)
    return EINVAL;
  strncpy (buf, env->from, len);
  buf[len-1] = 0;
  return 0;
}

static int
_body_size (body_t body, size_t *size)
{
  message_t msg = body_get_owner (body);
  struct _mhdraft_message *mp = message_get_owner (msg);

  if (size)
    *size = mp->body_end - mp->body_start;
  return 0;
}

static int 
_body_read (stream_t stream, char *optr, size_t osize,
	    off_t offset, size_t *nbytes)
{
  body_t body = stream_get_owner (stream);
  message_t msg = body_get_owner (body);
  struct _mhdraft_message *mp = message_get_owner (msg);
  stream_t str;

  message_get_stream (msg, &str);
  return stream_read (str, optr, osize, mp->body_start + offset, nbytes);
}

static int
_body_readline (stream_t stream, char *optr, size_t osize,
		off_t offset, size_t *nbytes)
{
  body_t body = stream_get_owner (stream);
  message_t msg = body_get_owner (body);
  struct _mhdraft_message *mp = message_get_owner (msg);
  stream_t str;

  message_get_stream (msg, &str);
  return stream_readline (str, optr, osize, mp->body_start + offset, nbytes);
}

static int
_body_stream_size (stream_t stream, off_t *psize)
{
  body_t body = stream_get_owner (stream);
  message_t msg = body_get_owner (body);
  struct _mhdraft_message *mp = message_get_owner (msg);
  
  if (psize)
    *psize = mp->body_end - mp->body_start;
  return 0;
}

message_t
mh_stream_to_message (stream_t instream)
{
  struct _mhdraft_message *mp;
  envelope_t env;
  message_t msg;
  body_t body;
  stream_t bstream;
  stream_t draftstream;
  int rc;
  
  if ((rc = mhdraft_stream_create (&draftstream, instream, 0)))
    {
      mh_error(_("cannot create draft message stream: %s"),
	       mu_strerror (rc));
      return NULL;
    }

  if ((rc = stream_open (draftstream)))
    {
      mh_error (_("cannot open draft message stream: %s"),
		mu_strerror (rc));
      stream_destroy (&draftstream, stream_get_owner (draftstream));
      return NULL;
    }

  restore_envelope (draftstream, &mp);

  if (message_create (&msg, mp))
    return NULL;
  
  message_set_stream (msg, draftstream, mp);
  
  if (envelope_create (&env, msg))
    return NULL;
  
  envelope_set_date (env, _env_msg_date, msg);
  envelope_set_sender (env, _env_msg_sender, msg);
  message_set_envelope (msg, env, mp);

  body_create (&body, msg);
  stream_create (&bstream,  MU_STREAM_RDWR | MU_STREAM_SEEKABLE, body);

  stream_set_read (bstream, _body_read, body);
  stream_set_readline (bstream, _body_readline, body);
  stream_set_size (bstream, _body_stream_size, body);
  body_set_stream (body, bstream, msg);
  body_set_size (body, _body_size, msg);
  message_set_body (msg, body, mp);
  
  return msg;
}