/*
cdcd - Command Driven CD player
Copyright (C) 1998-99 Tony Arcieri
Copyright (C) 2001, 2002, 2003 Fabrice Bauzac

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

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

#include "config.h"

#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
#include <stdio.h>

#ifdef HAVE_VASPRINTF
/* Should be declared in <stdio.h>, but I need this line for an
   unknown reason.  */
extern int vasprintf (char **, const char *, va_list);
#else
# include <glib.h>
#endif

#ifdef HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif

#include "cdcd.h"
#include "str.h"

#ifdef va_copy
#elif defined (__va_copy)
# define va_copy(va2, va) __va_copy ((va2), (va));
#else
# define va_copy(va2, va) memcpy (&(va2), &(va), sizeof (va));
#endif

/* Returns a malloc()ed string containing the lowercase version of S */
char *
strlowera (const char *s)
{
  char *r, *t;
  t = r = (char *) xmalloc (strlen (s) + 1);
  while (*s)
    *t++ = tolower (*s++);
  *t = 0;
  return r;
}

#if ! defined(HAVE_STRCASESTR)

/* case-insensitive strstr() */
const char *
strcasestr (const char *u, const char *v)
{
  char *uu, *vv, *ret;
  int i;
  uu = strlowera (u);
  vv = strlowera (v);
  ret = strstr (uu, vv);	/* ret is a pointer inside uu.  */
  if (!ret)
    {
      free (uu);
      free (vv);
      return NULL;
    }
  else
    {
      i = ret - uu;		/* i is an index.  */
      free (uu);
      free (vv);
      return u + i;		/* u+i is a pointer inside u.  */
    }
}

#endif

/* I don't know why, but these seem to not always work */

#if 0
/* Change a whole string to lower case */
int
strnlower (char *dest, const char *src, int len)
{
  int index;

  for (index = 0; index < len; index++)
    {
      dest[index] = tolower (src[index]);
      if (src[index] == '\0')
	return index;
    }

  return index;
}
#endif

#if 0
/* Case insensitive substring search with size limits*/
int
strncasestr (const char *haystack, int haystacklen,
	     const char *needle, int needlelen)
{
  char *haystacklower, *needlelower;
  int r;

  haystacklower = (char *) xmalloc (strlen (haystack) + 1);
  needlelower = (char *) xmalloc (strlen (needle) + 1);

  strnlower (haystacklower, haystack, haystacklen);
  strnlower (needlelower, needle, needlelen);

  r = strstr (haystacklower, needlelower) ? 1 : 0;
  free (haystacklower);
  free (needlelower);

  return r;
}
#endif

#if 0
/* Case insensitive substring search */
int
strcasestr (const char *haystack, const char *needle)
{
  int r;
  r = strncasestr (haystack, strlen (haystack), needle, strlen (needle));
  printf ("strcasestr({%s}, {%s}) = %d\n", haystack, needle, r);
  return r;
}
#endif



static int
space_needed (int wlen, struct pprintfd *ppd)
{
  int ret = wlen;
  if (ppd->col)
    ret += ppd->liad ? 2 : 1;
  return ret;
}

static void
print_word (int width, char *w, struct pprintfd *ppd)
{
  int l;
  int needed;

  l = strlen (w);

  needed = space_needed (l, ppd);
  if (ppd->col && ppd->col + needed > width)
    {
      putchar ('\n');
      ppd->col = 0;
      needed = space_needed (l, ppd);
    }

  if (ppd->col)
    {
      if (ppd->liad)
	putchar (' ');
      putchar (' ');
    }

  fputs (w, stdout);

  ppd->col += needed;

  ppd->liad = w[l - 1] == '.' ? 1 : 0;
}

#if ! HAVE_VASPRINTF
# if HAVE_VSNPRINTF

/* Replacement function for vasprintf, using vsnprintf.  */
static void
my_vasprintf (char **str, char *fmt, va_list va)
{
  /* Capacity (number of allocated bytes) of *STR.  */
  size_t capacity = 1;

  /* Number of chars (except final 0) to write to STR.  */
  int total_len;

  va_list va2;

  *str = (char *) xmalloc (capacity);

  va_copy (va2, va);

  /* vsnprintf returns the strlen of the string that would be
     generated (ie: we must allocate at least strlen+1 bytes).  */
  total_len = vsnprintf (*str, capacity, fmt, va);
  if (total_len >= capacity)
    {
      capacity = total_len + 1;
      *str = (char *) xrealloc (*str, capacity);
      vsnprintf (*str, capacity, fmt, va2);
    }

  va_end (va);
  va_end (va2);
}

# endif	 /* HAVE_VSNPRINTF */
#endif	 /* ! HAVE_VASPRINTF */

/* These are the magic functions.  */

/* vpdprintf does a printf() with word breaks; the width is MAXCOL.
   Be careful, no \n is appended at the end of the last line, and all
   \n's are removed from FMT ! */
void
vpdprintf (int maxcol, struct pprintfd *ppd, char *fmt, va_list v)
{
  char *s, *p;
  char *word = NULL;

#if HAVE_VASPRINTF
  vasprintf (&s, fmt, v);
#elif HAVE_VSNPRINTF
  my_vasprintf (&s, fmt, v);
#elif HAVE_GLIB
  s = g_strdup_vprintf (fmt, v);
#endif

  for (p = s; *p; p++)
    {
      if (!word && !isspace (*p))	/* We have just found a new word */
	word = p;
      else if (word && isspace (*p))	/* The current word is finished */
	{
	  *p = 0;
	  print_word (maxcol, word, ppd);
	  word = NULL;
	}
    }

  if (word)
    print_word (maxcol, word, ppd);

#if HAVE_VASPRINTF
  free (s);
#else /* Strictly speaking, memory allocated by Glib should be freed
         with g_free().  */
  g_free (s);
#endif
}

void
pdprintf (int maxcol, struct pprintfd *ppd, char *fmt, ...)
{
  va_list v;
  va_start (v, fmt);
  vpdprintf (maxcol, ppd, fmt, v);
  va_end (v);
}

void
vpprintf (int maxcol, char *fmt, va_list v)
{
  struct pprintfd ppd = { 0, 0 };
  vpdprintf (maxcol, &ppd, fmt, v);
}

void
pprintf (int maxcol, char *fmt, ...)
{
  va_list v;
  va_start (v, fmt);
  vpprintf (maxcol, fmt, v);
  va_end (v);
}

/* cv2v0 converts argc+argv style parameters to argv0 style parameters */
/* argv0 is a NULL-terminated array of pointers to strings (char*) */
char **
cv2v0 (int argc, char **argv)
{
  char **r;
  int i;
  r = (char **) xmalloc ((argc + 1) * sizeof (*r));	/* don't forget the
							   NULL pointer */
  for (i = 0; i < argc; ++i)
    {
      r[i] = (char *) xmalloc (strlen (argv[i]) + 1);
      strcpy (r[i], argv[i]);
    }
  r[i] = NULL;
  return r;
}

/* freev0 frees a argv0 array */
void
freev0 (char **v)
{
  char **p = v;

  if (!v)
    return;

  while (*p)
    free (*p++);
  free (v);
}

/* Tokenization with ", ', `.  This is meant to be a (limited?)
   replacement of history_tokenize ().  However we don't use
   history_tokenize() because of its (bogus?) behaviour on empty lines
   (it returns NULL).  */
char **
my_tokenize (char *s)
{
  char **p;
  char *ss = s;
  int q = 0;
  char *word = NULL;
  int p_size = 0;

  p = (char **) xmalloc (sizeof (*p) * ++p_size);
  *p = NULL;

  while (*ss)
    {
      if (!isspace (*ss) && !word)
	word = ss;
      if (isspace (*ss) && word && !q)
	{
	  *ss = 0;
	  p = (char **) xrealloc (p, sizeof (*p) * ++p_size);
	  p[p_size - 2] = (char *) xmalloc (strlen (word) + 1);
	  strcpy (p[p_size - 2], word);
	  p[p_size - 1] = NULL;
	  word = NULL;
	}
      else if (*ss == '\'' || *ss == '\"' || *ss == '`')
	{
	  if (q == *ss)
	    q = 0;
	  else
	    q = *ss;
	}
      else if (*ss == '\\')
	ss++;

      ss++;
    }

  if (word)
    {
      p = (char **) xrealloc (p, sizeof (*p) * ++p_size);
      p[p_size - 2] = (char *) xmalloc (strlen (word) + 1);
      strcpy (p[p_size - 2], word);
      p[p_size - 1] = NULL;
    }

  return p;
}

/*
  It should be easier to understand this with some examples:
  hello "           becomes hello (there is no need to quote)
  hello world "     becomes "hello world"
  hello world '     becomes 'hello world'
  it's nice "       becomes "it's nice"
  it's nice '       becomes 'it\'s nice'
  dumb thing\'"` `  becomes `dumb thing\\'"\`` (only \ and ` are backslashed)

  Q must be one of ', ", `.

  This function has not been extensively tested, it should behave like
  the previous examples.  If not, correct the function, not the examples!
*/
char *
quote_armor (char *s, char q)
{
  char *ret, *t;
  int need_quotes = 0;

  {
    /* Add quotes if and only if the following characters are in S */
    char *forbidden = " \t\\'\"`";
    int i;
    for (i = 0; forbidden[i]; ++i)
      if (strchr (s, forbidden[i]))
	{
	  need_quotes = 1;
	  break;
	}
  }

  /* At max, s is filled with q or '\', so everything must be
     backslashed: strlen(s) * 2 */
  t = ret = (char *) xmalloc (2 * strlen (s) + (need_quotes ? 2 : 0) + 1);

  if (need_quotes)
    *t++ = q;

  while (*s)
    {
      if (*s == '\\' || *s == q)
	{
	  /* We know that need_quotes is set to 1 because there is '\\'
	     or q inside.  */
	  *t++ = '\\';
	  *t++ = *s++;
	}
      else
	*t++ = *s++;
    }

  if (need_quotes)
    *t++ = q;

  *t = 0;
  ret = (char *) xrealloc (ret, strlen (ret) + 1);	/* shrink */
  return ret;
}

/* Unquote one string: suppress non-protected quotes and some
   backslashes */
char *
unquote_armor (char *s)
{
  int q = 0;
  char *ret;
  char *p;
  p = ret = (char *) xmalloc (strlen (s) + 1);

  while (*s)
    {
      if (*s == '\'' || *s == '\"' || *s == '`')
	{
	  if (q == *s)
	    {
	      s++;
	      q = 0;
	    }
	  else if (!q)
	    {
	      q = *s;
	      s++;
	    }
	  else
	    *p++ = *s++;
	}
      else if (*s == '\\')
	{
	  s++;
	  if (*s)
	    *p++ = *s++;
	}
      else
	*p++ = *s++;
    }

  *p = 0;
  return ret;
}

/* Unquote an entire parameter list */
char **
unquote_params (char **argv)
{
  char **ret;
  int argc;

  /* Count upwards... */
  for (argc = 0; argv[argc]; argc++)
    ;

  ret = (char **) xmalloc (sizeof (*ret) * (argc + 1));
  ret[argc] = NULL;

  if (!argc)
    return ret;

  /* This only works if argc > 0.  */

  /* ... and downwards.  */
  for (; argc; --argc)
    ret[argc - 1] = unquote_armor (argv[argc - 1]);

  return ret;
}