/* GNU Mailutils -- a suite of utilities for electronic mail
   Copyright (C) 1999-2002, 2005-2008, 2010-2012, 2014-2016 Free
   Software Foundation, Inc.

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

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

   You should have received a copy of the GNU Lesser General
   Public License along with this library.  If not, see
   <http://www.gnu.org/licenses/>. */

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

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <sieve-priv.h>

void *
mu_sieve_alloc (size_t size)
{
  void *p = malloc (size);
  if (!p)
    {
      mu_error ("not enough memory");
      abort ();
    }
  return p;
}

void *
mu_sieve_palloc (mu_list_t *pool, size_t size)
{
  void *p = malloc (size);
  if (p)
    {
      if (!*pool && mu_list_create (pool))
	{
	  free (p);
	  return NULL;
	}
      mu_list_append (*pool, p);
    }
  return p;
}

char *
mu_sieve_pstrdup (mu_list_t *pool, const char *str)
{
  size_t len;
  char *p;
  
  if (!str)
    return NULL;
  len = strlen (str);
  p = mu_sieve_palloc (pool, len + 1);
  if (p)
    {
      memcpy (p, str, len);
      p[len] = 0;
    }
  return p;
}

void *
mu_sieve_prealloc (mu_list_t *pool, void *ptr, size_t size)
{
  void *newptr;
  
  if (*pool)
    mu_list_remove (*pool, ptr);

  newptr = realloc (ptr, size);
  if (newptr)
    {
      if (!*pool && mu_list_create (pool))
	{
	  free (newptr);
	  return NULL;
	}
      mu_list_append (*pool, newptr);
    }
  return newptr;
}

void
mu_sieve_pfree (mu_list_t *pool, void *ptr)
{
  if (*pool)
    mu_list_remove (*pool, ptr);
  free (ptr);
}  

void *
mu_sieve_malloc (mu_sieve_machine_t mach, size_t size)
{
  return mu_sieve_palloc (&mach->memory_pool, size);
}

char *
mu_sieve_mstrdup (mu_sieve_machine_t mach, const char *str)
{
  return mu_sieve_pstrdup (&mach->memory_pool, str);
}

void *
mu_sieve_mrealloc (mu_sieve_machine_t mach, void *ptr, size_t size)
{
  return mu_sieve_prealloc (&mach->memory_pool, ptr, size);
}

void
mu_sieve_mfree (mu_sieve_machine_t mach, void *ptr)
{
  mu_sieve_pfree (&mach->memory_pool, ptr);
}  

static int
_destroy_item (void *item, void *data)
{
  free (item);
  return 0;
}

void
mu_sieve_slist_destroy (mu_list_t *plist)
{
  if (!plist)
    return;
  mu_list_foreach (*plist, _destroy_item, NULL);
  mu_list_destroy (plist);
}

mu_sieve_value_t *
mu_sieve_value_create (mu_sieve_data_type type, void *data)
{
  mu_sieve_value_t *val = mu_sieve_alloc (sizeof (*val));

  val->type = type;
  switch (type)
    {
    case SVT_NUMBER:
      val->v.number = * (long *) data;
      break;
      
    case SVT_STRING:
      val->v.string = data;
      break;
      
    case SVT_STRING_LIST:
      val->v.list = data;
      break;
      
    case SVT_TAG:
    case SVT_IDENT:
      val->v.string = data;
      break;

    case SVT_POINTER:
      val->v.ptr = data;
      break;
	
    default:
      mu_error ("%s", _("invalid data type"));
      abort ();
    }
  return val;
}

mu_sieve_value_t *
mu_sieve_get_arg_untyped (mu_sieve_machine_t mach, size_t index)
{
  mu_sieve_value_t *val = NULL;
  int rc = mu_list_get (mach->arg_list, index, (void **)&val);
  if (rc)
    {
      mu_sieve_error (mach, _("can't get argument %zu: %s"),
		      index, mu_strerror (rc));
      mu_sieve_abort (mach);
    }
  return val;
}

mu_sieve_value_t *
mu_sieve_get_arg_optional (mu_sieve_machine_t mach, size_t index)
{
  mu_sieve_value_t *val = NULL;
  int rc = mu_list_get (mach->arg_list, index, (void **)&val);
  if (rc == MU_ERR_NOENT)
    return NULL;
  else if (rc)
    {
      mu_sieve_error (mach, _("can't get argument %zu: %s"),
		      index, mu_strerror (rc));
      mu_sieve_abort (mach);
    }
  return val;
}  

int
mu_sieve_get_arg (mu_sieve_machine_t mach, size_t index,
		  mu_sieve_data_type type, void *ret)
{
  mu_sieve_value_t *val = mu_sieve_get_arg_untyped (mach, index);
  if (val->type != type)
    {
      mu_sieve_error (mach,
		    _("bad type for argument %zu: %s, instead of expected %s"),
		      index,
		      mu_sieve_type_str (val->type),
		      mu_sieve_type_str (type));
      mu_sieve_abort (mach);
    }

  *(union mu_sieve_value_storage *)ret = val->v;
  return 0;
}

void
mu_sieve_error (mu_sieve_machine_t mach, const char *fmt, ...)
{
  va_list ap;
  
  va_start (ap, fmt);
  mu_stream_printf (mach->errstream, "\033s<%d>", MU_LOG_ERROR);
  if (mach->locus.mu_file)
    mu_stream_printf (mach->errstream, "\033O<%d>\033f<%u>%s\033l<%u>",
		      MU_LOGMODE_LOCUS,
		      (unsigned) strlen (mach->locus.mu_file),
		      mach->locus.mu_file,
		      mach->locus.mu_line);
  if (mach->identifier)
    mu_stream_printf (mach->errstream, "%s: ", mach->identifier);
  mu_stream_vprintf (mach->errstream, fmt, ap);
  mu_stream_write (mach->errstream, "\n", 1, NULL);
  va_end (ap);
}

const char *
mu_sieve_type_str (mu_sieve_data_type type)
{
  switch (type)
    {
    case SVT_VOID:
      return "void";
      
    case SVT_NUMBER:
      return "number";
      
    case SVT_STRING:
      return "string";

    case SVT_STRING_LIST:
      return "string-list";
      
    case SVT_TAG:
      return "tag";

    case SVT_IDENT:
      return "ident";

    case SVT_POINTER:
      return "pointer";
    }

  return "unknown";
}

static int
tag_printer (void *item, void *data)
{
  mu_sieve_runtime_tag_t *val = item;
  mu_stream_t str = data;
  
  mu_stream_printf (str, " :%s", val->tag);
  if (val->arg)
    mu_i_sv_valf (str, val->arg);
  return 0;
}

void
mu_i_sv_tagf (mu_stream_t str, mu_list_t taglist)
{
  mu_list_foreach (taglist, tag_printer, str);
}

void
mu_i_sv_debug (mu_sieve_machine_t mach, size_t pc, const char *fmt, ...)
{
  va_list ap;

  if (mach->state_flags & MU_SV_SAVED_DBG_STATE)
    {
      unsigned severity = MU_LOG_DEBUG;
      mu_stream_ioctl (mach->dbgstream, MU_IOCTL_LOGSTREAM,
		       MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity);
      if (mach->locus.mu_file)
	{
	  int mode = mach->dbg_mode | MU_LOGMODE_LOCUS;
	  mu_stream_ioctl (mach->dbgstream, MU_IOCTL_LOGSTREAM,
			   MU_IOCTL_LOGSTREAM_SET_LOCUS, &mach->locus);
	  mu_stream_ioctl (mach->dbgstream, MU_IOCTL_LOGSTREAM,
			   MU_IOCTL_LOGSTREAM_SET_MODE, &mode);
	}
    }
  va_start (ap, fmt);
  mu_stream_printf (mach->dbgstream, "%4zu: ", pc);
  mu_stream_vprintf (mach->dbgstream, fmt, ap);
  mu_stream_write (mach->dbgstream, "\n", 1, NULL);
  va_end (ap);
}

void
mu_i_sv_debug_command (mu_sieve_machine_t mach,
		       size_t pc,
		       char const *what)
{
  if (mach->state_flags & MU_SV_SAVED_DBG_STATE)
    {
      unsigned severity = MU_LOG_DEBUG;
      mu_stream_ioctl (mach->dbgstream, MU_IOCTL_LOGSTREAM,
		       MU_IOCTL_LOGSTREAM_SET_SEVERITY, &severity);
      if (mach->locus.mu_file)
	{
	  int mode = mach->dbg_mode | MU_LOGMODE_LOCUS;
	  mu_stream_ioctl (mach->dbgstream, MU_IOCTL_LOGSTREAM,
			   MU_IOCTL_LOGSTREAM_SET_LOCUS, &mach->locus);
	  mu_stream_ioctl (mach->dbgstream, MU_IOCTL_LOGSTREAM,
			   MU_IOCTL_LOGSTREAM_SET_MODE, &mode);
	}
    }
  mu_stream_printf (mach->dbgstream, "%4zu: %s: %s",
		    pc, what, mach->identifier);  
  mu_i_sv_tagf (mach->dbgstream, mach->tag_list);
  mu_i_sv_argf (mach->dbgstream, mach->arg_list);
  mu_stream_write (mach->dbgstream, "\n", 1, NULL);
}

void
mu_i_sv_trace (mu_sieve_machine_t mach, const char *what)
{
  if (!mu_debug_level_p (mu_sieve_debug_handle, MU_DEBUG_TRACE4))
    return;
  
  mu_stream_printf (mach->errstream, "\033s<%d>", MU_LOG_DEBUG);
  if (mach->locus.mu_file)
    mu_stream_printf (mach->errstream, "\033O<%d>\033f<%u>%s\033l<%u>",
		      MU_LOGMODE_LOCUS,
		      (unsigned) strlen (mach->locus.mu_file),
		      mach->locus.mu_file,
		      mach->locus.mu_line);
  mu_stream_printf (mach->errstream, "%zu: %s %s", mach->msgno, what,
		    mach->identifier);
  mu_i_sv_tagf (mach->errstream, mach->tag_list);
  mu_i_sv_argf (mach->errstream, mach->arg_list);
  mu_stream_printf (mach->errstream, "\n");
}

void
mu_sieve_log_action (mu_sieve_machine_t mach, const char *action,
		     const char *fmt, ...)
{
  va_list ap;
  
  if (!mach->logger)
    return;
  
  mu_stream_ioctl (mach->errstream, MU_IOCTL_LOGSTREAM,
		   MU_IOCTL_LOGSTREAM_SET_LOCUS, &mach->locus);
  va_start (ap, fmt);
  mach->logger (mach, action, fmt, ap);
  va_end (ap);
}
  
static int
tag_finder (void *item, void *data)
{
  mu_sieve_runtime_tag_t *val = item;
  mu_sieve_runtime_tag_t *target = data;

  if (strcmp (val->tag, target->tag) == 0)
    {
      target->arg = val->arg;
      return 1;
    }
  return 0;
}

int
mu_sieve_get_tag_untyped (mu_sieve_machine_t mach, 
			  char *name, mu_sieve_value_t **ret)
{
  mu_sieve_runtime_tag_t t;

  t.tag = name;
  if (mach->tag_list && mu_list_foreach (mach->tag_list, tag_finder, &t))
    {
      if (ret)
	*ret = t.arg;
      return 1;
    }
  return 0;
}

int
mu_sieve_get_tag (mu_sieve_machine_t mach, 
		  char *name, mu_sieve_data_type type,
		  void *ret)
{
  mu_sieve_value_t *val;
  int found = mu_sieve_get_tag_untyped (mach, name, &val);

  if (found)
    {
      if (ret)
	{
	  if (val->type != type)
	    {
	      mu_sieve_error (mach,
			      _("bad type for tag %s: %s, instead of expected %s"),
			      name,
			      mu_sieve_type_str (val->type),
			      mu_sieve_type_str (type));
	      mu_sieve_abort (mach);
	    }
	  *(union mu_sieve_value_storage *)ret = val->v;
	}
    }

  return found;
}

int
mu_sieve_vlist_do (mu_sieve_value_t *val, mu_list_action_t ac, void *data)
{
  switch (val->type)
    {
    case SVT_STRING_LIST:
      return mu_list_foreach (val->v.list, ac, data);
    case SVT_STRING:
      return ac (val->v.string, data);
    default:
      mu_error ("mu_sieve_vlist_do: unexpected list type %d", val->type);
      return EINVAL;
    }
}

struct comp_data
{
  mu_sieve_value_t *val;
  mu_sieve_comparator_t comp;
  mu_sieve_relcmp_t test;
  mu_sieve_retrieve_t retr;
  void *data;
  size_t count;
};

struct comp_data2
{
  char *sample;
  mu_sieve_comparator_t comp;
  mu_sieve_relcmp_t test;
};

int
_comp_action2 (void *item, void *data)
{
  struct comp_data2 *cp = data;
  return cp->test (cp->comp (item, cp->sample), 0);
}

int
_comp_action (void *item, void *data)
{
  struct comp_data *cp = data;
  struct comp_data2 d;
  int rc = 0;
  int i;

  d.comp = cp->comp;
  d.test = cp->test;
  for (i = 0; rc == 0 && cp->retr (item, cp->data, i, &d.sample) == 0; i++)
    if (d.sample)
      {
	cp->count++;
        rc = mu_sieve_vlist_do (cp->val, _comp_action2, &d);
        free (d.sample);
      }
  return rc;
}

int
mu_sieve_vlist_compare (mu_sieve_value_t *a, mu_sieve_value_t *b,
			mu_sieve_comparator_t comp, mu_sieve_relcmp_t test,
			mu_sieve_retrieve_t retr,
			void *data, size_t *count)
{
  struct comp_data d;
  int rc;
  
  d.comp = comp;
  d.test = test;
  d.retr = retr;
  d.data = data;
  d.val = b;
  d.count = 0;
  rc = mu_sieve_vlist_do (a, _comp_action, &d);
  if (count)
    *count = d.count;
  return rc;
}


void
mu_sieve_stream_save (mu_sieve_machine_t mach)
{
  if (mach->state_flags & MU_SV_SAVED_STATE)
    return;
  
  if (mu_stream_ioctl (mach->errstream, MU_IOCTL_LOGSTREAM,
		       MU_IOCTL_LOGSTREAM_GET_MODE, &mach->err_mode) == 0
      && mu_stream_ioctl (mach->errstream, MU_IOCTL_LOGSTREAM,
			  MU_IOCTL_LOGSTREAM_SET_LOCUS, &mach->err_locus) == 0)
      mach->state_flags |= MU_SV_SAVED_ERR_STATE;

  if (mu_stream_ioctl (mach->dbgstream, MU_IOCTL_LOGSTREAM,
		       MU_IOCTL_LOGSTREAM_GET_MODE, &mach->dbg_mode) == 0
      && mu_stream_ioctl (mach->dbgstream, MU_IOCTL_LOGSTREAM,
			  MU_IOCTL_LOGSTREAM_SET_LOCUS, &mach->dbg_locus) == 0)
    mach->state_flags |= MU_SV_SAVED_DBG_STATE;
  
  mach->state_flags |= MU_SV_SAVED_STATE;
}

void
mu_sieve_stream_restore (mu_sieve_machine_t mach)
{
  if (!(mach->state_flags & MU_SV_SAVED_STATE))
    return;

  if (mach->state_flags & MU_SV_SAVED_ERR_STATE)
    {
      mu_stream_ioctl (mach->errstream, MU_IOCTL_LOGSTREAM,
		       MU_IOCTL_LOGSTREAM_SET_MODE, &mach->err_mode);
      mu_stream_ioctl (mach->errstream, MU_IOCTL_LOGSTREAM,
		       MU_IOCTL_LOGSTREAM_SET_LOCUS, &mach->err_locus);
    }
  
  if (mach->dbgstream != mach->errstream
      && (mach->state_flags & MU_SV_SAVED_DBG_STATE))
    {
      mu_stream_ioctl (mach->dbgstream, MU_IOCTL_LOGSTREAM,
		       MU_IOCTL_LOGSTREAM_SET_MODE, &mach->dbg_mode);
      mu_stream_ioctl (mach->dbgstream, MU_IOCTL_LOGSTREAM,
		       MU_IOCTL_LOGSTREAM_SET_LOCUS, &mach->dbg_locus);
    }
  
  mach->state_flags = 0;
}