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

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

   This program 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 Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* Notes:
First draft: Alain Magloire.

 */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <errno.h>
#include <string.h>
#include <stdlib.h>

#include <filter0.h>
#include <mailutils/iterator.h>

static void
filter_destroy (stream_t stream)
{
  filter_t filter = stream_get_owner (stream);
  if (filter->_destroy)
    filter->_destroy (filter);
  if (filter->property)
    property_destroy (&(filter->property), filter);
  free (filter);
}

static int
filter_read (stream_t stream, char *buffer, size_t buflen, off_t offset,
	     size_t *nbytes)
{
  filter_t filter = stream_get_owner (stream);
  if (filter->_read && (filter->direction & MU_STREAM_READ
		      || filter->direction & MU_STREAM_RDWR))
    return filter->_read (filter, buffer, buflen, offset, nbytes);
  return stream_read (filter->stream, buffer, buflen, offset, nbytes);
}

static int
filter_readline (stream_t stream, char *buffer, size_t buflen,
		 off_t offset, size_t *nbytes)
{
  filter_t filter = stream_get_owner (stream);
  if (filter->_readline && (filter->direction & MU_STREAM_READ
			  || filter->direction & MU_STREAM_RDWR))
    return filter->_readline (filter, buffer, buflen, offset, nbytes);
  return stream_readline (filter->stream, buffer, buflen, offset, nbytes);
}

static int
filter_write (stream_t stream, const char *buffer, size_t buflen,
	      off_t offset, size_t *nbytes)
{
  filter_t filter = stream_get_owner (stream);
  if (filter->_write && (filter->direction & MU_STREAM_WRITE
		       || filter->direction & MU_STREAM_RDWR))
    return filter->_write (filter, buffer, buflen, offset, nbytes);
  return stream_write (filter->stream, buffer, buflen, offset, nbytes);
}

static int
filter_open (stream_t stream, const char *filename, int port, int flags)
{
  filter_t filter = stream_get_owner (stream);
  stream_set_flags (stream, flags);
  return stream_open (filter->stream, filename, port, flags);
}

static int
filter_truncate (stream_t stream, off_t len)
{
  filter_t filter = stream_get_owner (stream);
  return stream_truncate (filter->stream, len);
}

static int
filter_size (stream_t stream, off_t *psize)
{
  filter_t filter = stream_get_owner (stream);
  return stream_size (filter->stream, psize);
}

static int
filter_flush (stream_t stream)
{
  filter_t filter = stream_get_owner(stream);
  return stream_flush (filter->stream);
}

static int
filter_get_fd (stream_t stream, int *pfd)
{
  filter_t filter = stream_get_owner (stream);
  return stream_get_fd (filter->stream, pfd);
}

static int
filter_close (stream_t stream)
{
  filter_t filter = stream_get_owner (stream);
  return stream_close (filter->stream);
}

static int
filter_property (property_t property, const char *key, const char *value)
{
  filter_t filter = property_get_owner (property);
  (void)key;
  if (value)
    {
      if (strcasecmp (value, "READ") == 0)
	{
         filter->direction = MU_STREAM_READ;
       }
      else if (strcasecmp (value, "WRITE") == 0)
	{
         filter->direction = MU_STREAM_WRITE;
       }
      else if (strcasecmp (value, "RDWR") == 0)
	{
         filter->direction = MU_STREAM_RDWR;
       }
    }
  return 0;
}

/* NOTE: We will leak here since the monitor of the filter will never
   be release.  That's ok we can leave with this, it's only done once.  */
static list_t filter_list;
struct _monitor filter_monitor = MU_MONITOR_INITIALIZER;

int
filter_get_list (list_t *plist)
{
  if (plist == NULL)
    return EINVAL;
  monitor_wrlock (&filter_monitor);
  if (filter_list == NULL)
    {
      int status = list_create (&filter_list);
      if (status != 0)
	return status;
      /* Default filters.  */
      list_append (filter_list, base64_filter);
      list_append (filter_list, qp_filter);
      list_append (filter_list, binary_filter);
      list_append (filter_list, bit8_filter);
      list_append (filter_list, bit7_filter);
      list_append (filter_list, rfc822_filter);
      /* FIXME: add the default encodings?  */
    }
  *plist = filter_list;
  monitor_unlock (&filter_monitor);
  return 0;
}

int
filter_create (stream_t *pstream, stream_t stream, const char *name,
	       int type, int direction)
{
  iterator_t iterator = NULL;
  filter_record_t filter_record = NULL;
  int  (*f_init)  __P ((filter_t))  = NULL;
  int found = 0;
  int status;
  list_t list = NULL;

  if (pstream == NULL || stream == NULL || name == NULL)
    return EINVAL;

  filter_get_list (&list);
  status = iterator_create (&iterator, list);
  if (status != 0)
    return status;

  for (iterator_first (iterator); !iterator_is_done (iterator);
       iterator_next (iterator))
    {
      iterator_current (iterator, (void **)&filter_record);
      if ((filter_record->_is_filter
	   && filter_record->_is_filter (filter_record, name))
	  || (strcasecmp (filter_record->name, name) == 0))
        {
	  found = 1;
	  if (filter_record->_get_filter)
	    filter_record->_get_filter (filter_record, &f_init);
	  else
	    f_init = filter_record->_filter;
	  break;
        }
    }
  iterator_destroy (&iterator);

  if (found)
    {
      int flags = 0;
      filter_t filter;

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

      stream_get_flags (stream, &flags);
      status = stream_create (pstream, flags | MU_STREAM_NO_CHECK, filter);
      if (status != 0)
	{
	  free (filter);
	  return status;
	}

      filter->stream = stream;
      filter->filter_stream = *pstream;
      filter->direction = (direction == 0) ? MU_STREAM_READ : direction;
      filter->type = type;

      status = property_create (&(filter->property), filter);
      if (status != 0)
	{
	  stream_destroy (pstream, filter);
	  free (filter);
	  return status;
	}
      property_add_defaults (filter->property, "DIRECTION",
			     ((filter->direction == MU_STREAM_WRITE) ? "WRITE":
			     (filter->direction == MU_STREAM_RDWR) ? "RDWR" :
			     "READ"), filter_property, NULL, filter);
      property_add_defaults (filter->property, "NAME", filter_record->name,
			     NULL, NULL, filter);
      stream_set_property (*pstream, filter->property, filter);

      if (f_init != NULL)
	{
	  status = f_init (filter);
	  if (status != 0)
	    {
	      stream_destroy (pstream, filter);
	      free (filter);
	      return status;
	    }
        }

      stream_set_open (*pstream, filter_open, filter );
      stream_set_close (*pstream, filter_close, filter );
      stream_set_read (*pstream, filter_read, filter);
      stream_set_readline (*pstream, filter_readline, filter);
      stream_set_write (*pstream, filter_write, filter);
      stream_set_fd (*pstream, filter_get_fd, filter );
      stream_set_truncate (*pstream, filter_truncate, filter );
      stream_set_size (*pstream, filter_size, filter );
      stream_set_flush (*pstream, filter_flush, filter );
      stream_set_destroy (*pstream, filter_destroy, filter);
    }
  else
    status = ENOENT;
  return status;
}