/* GObject - GLib Type, Object, Parameter and Signal Library

 * Copyright (C) 1998-1999, 2000-2001 Tim Janik and Red Hat, 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 2 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, write to the

 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include	"../config.h"

#include        <glib-object.h>

#include	<glib/gprintf.h>

#include	<stdlib.h>

#include	<string.h>

#ifdef HAVE_UNISTD_H

#include	<unistd.h>

#endif

#include	<sys/stat.h>

#include	<fcntl.h>

static gchar *indent_inc = NULL;

static guint spacing = 1;

static FILE *f_out = NULL;

static GType root = 0;

static gboolean recursion = TRUE;

#if 0

#  define	O_SPACE	"\\as"

#  define	O_ESPACE " "

#  define	O_BRANCH "\\aE"

#  define	O_VLINE "\\al"

#  define	O_LLEAF	"\\aL"

#  define	O_KEY_FILL "_"

#else

#  define	O_SPACE	" "

#  define	O_ESPACE ""

#  define	O_BRANCH "+"

#  define	O_VLINE "|"

#  define	O_LLEAF	"`"

#  define	O_KEY_FILL "_"

#endif

static void

show_nodes (GType        type,

	    GType        sibling,

	    const gchar *indent)

{

  GType   *children;

  guint i;

  if (!type)

    return;

  children = g_type_children (type, NULL);

  if (type != root)

    for (i = 0; i < spacing; i++)

      g_fprintf (f_out, "%s%s\n", indent, O_VLINE);

  g_fprintf (f_out, "%s%s%s%s",

	   indent,

	   sibling ? O_BRANCH : (type != root ? O_LLEAF : O_SPACE),

	   O_ESPACE,

	   g_type_name (type));

  for (i = strlen (g_type_name (type)); i <= strlen (indent_inc); i++)

    fputs (O_KEY_FILL, f_out);

  fputc ('\n', f_out);

  if (children && recursion)

    {

      gchar *new_indent;

      GType   *child;

      if (sibling)

	new_indent = g_strconcat (indent, O_VLINE, indent_inc, NULL);

      else

	new_indent = g_strconcat (indent, O_SPACE, indent_inc, NULL);

      for (child = children; *child; child++)

	show_nodes (child[0], child[1], new_indent);

      g_free (new_indent);

    }

  g_free (children);

}

static gint

help (gchar *arg)

{

  g_fprintf (stderr, "usage: query <qualifier> [-r <type>] [-{i|b} \"\"] [-s #] [-{h|x|y}]\n");

  g_fprintf (stderr, "       -r       specifiy root type\n");

  g_fprintf (stderr, "       -n       don't descend type tree\n");

  g_fprintf (stderr, "       -h       guess what ;)\n");

  g_fprintf (stderr, "       -b       specify indent string\n");

  g_fprintf (stderr, "       -i       specify incremental indent string\n");

  g_fprintf (stderr, "       -s       specify line spacing\n");

  g_fprintf (stderr, "qualifiers:\n");

  g_fprintf (stderr, "       froots   iterate over fundamental roots\n");

  g_fprintf (stderr, "       tree     print type tree\n");

  return arg != NULL;

}

int

main (gint   argc,

      gchar *argv[])

{

  GLogLevelFlags fatal_mask;

  gboolean gen_froots = 0;

  gboolean gen_tree = 0;

  gint i;

  gchar *iindent = "";

  f_out = stdout;

  fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);

  fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;

  g_log_set_always_fatal (fatal_mask);

  root = G_TYPE_OBJECT;

  g_type_init ();

  for (i = 1; i < argc; i++)

    {

      if (strcmp ("-s", argv[i]) == 0)

	{

	  i++;

	  if (i < argc)

	    spacing = atoi (argv[i]);

	}

      else if (strcmp ("-i", argv[i]) == 0)

	{

	  i++;

	  if (i < argc)

	    {

	      char *p;

	      guint n;

	      p = argv[i];

	      while (*p)

		p++;

	      n = p - argv[i];

	      indent_inc = g_new (gchar, n * strlen (O_SPACE) + 1);

	      *indent_inc = 0;

	      while (n)

		{

		  n--;

		  strcpy (indent_inc, O_SPACE);

		}

	    }

	}

      else if (strcmp ("-b", argv[i]) == 0)

	{

	  i++;

	  if (i < argc)

	    iindent = argv[i];

	}

      else if (strcmp ("-r", argv[i]) == 0)

	{

	  i++;

	  if (i < argc)

	    root = g_type_from_name (argv[i]);

	}

      else if (strcmp ("-n", argv[i]) == 0)

	{

	  recursion = FALSE;

	}

      else if (strcmp ("froots", argv[i]) == 0)

	{

	  gen_froots = 1;

	}

      else if (strcmp ("tree", argv[i]) == 0)

	{

	  gen_tree = 1;

	}

      else if (strcmp ("-h", argv[i]) == 0)

	{

	  return help (NULL);

	}

      else if (strcmp ("--help", argv[i]) == 0)

	{

	  return help (NULL);

	}

      else

	return help (argv[i]);

    }

  if (!gen_froots && !gen_tree)

    return help (argv[i-1]);

  if (!indent_inc)

    {

      indent_inc = g_new (gchar, strlen (O_SPACE) + 1);

      *indent_inc = 0;

      strcpy (indent_inc, O_SPACE);

    }

  if (gen_tree)

    show_nodes (root, 0, iindent);

  if (gen_froots)

    {

      root = ~0;

      for (i = 0; i <= G_TYPE_FUNDAMENTAL_MAX; i += G_TYPE_MAKE_FUNDAMENTAL (1))

	{

	  const gchar *name = g_type_name (i);

	  if (name)

	    show_nodes (i, 0, iindent);

	}

    }

  return 0;

}