/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "b.h"

static int usage (char *what, int ret);
static b_error_t serialise_type (b_t * data, b_type_t type);
static b_error_t serialise_triple (b_t * data);
static b_error_t add_type (b_t * data, b_type_t type, char *what);
static b_error_t remove_type (b_t * data, b_type_t type, char *what);
static b_error_t add_triple (b_t * data, char *su, char *sb, char *p,
			     char *ou, char *ob, char *ol, char *c,
			     char *d, char *l);
static b_error_t remove_triple (b_t * data, char *su, char *sb, char *p,
				char *ou, char *ob, char *ol, char *c,
				char *d, char *l);
static b_error_t count_type (b_t * data, b_type_t type);
static b_error_t count_triple (b_t * data);

int
main (int argc, char **argv)
{
  b_error_t error;
  b_t *data;
  int i;

  if (argc < 2)
    return usage (argv[0], 1);

  if ((error = b_new (&data, (unsigned char *) argv[1])) != B_OK)
    {
      fprintf (stderr, "Error (b_new): %s\n", b_strerror (error));
      return 1;
    }

  for (i = 2; i < argc; i++)
    {
      if (!strcmp (argv[i], "-h") || !strcmp (argv[i], "--help"))
	{
	  b_destroy (data);
	  return usage (argv[0], 0);
	}

      else if (!strcmp (argv[i], "-us")
	       || !strcmp (argv[i], "--uri_serialise"))
	{
	  error = serialise_type (data, B_TYPE_URI);
	  break;
	}

      else if (!strcmp (argv[i], "-bs")
	       || !strcmp (argv[i], "--bnode_serialise"))
	{
	  error = serialise_type (data, B_TYPE_BNODE);
	  break;
	}

      else if (!strcmp (argv[i], "-ls")
	       || !strcmp (argv[i], "--literal_serialise"))
	{
	  error = serialise_type (data, B_TYPE_LITERAL);
	  break;
	}

      else if (!strcmp (argv[i], "-ps")
	       || !strcmp (argv[i], "--property_serialise"))
	{
	  error = serialise_type (data, B_TYPE_PROPERTY);
	  break;
	}

      else if (!strcmp (argv[i], "-ds")
	       || !strcmp (argv[i], "--datatype_serialise"))
	{
	  error = serialise_type (data, B_TYPE_DATATYPE);
	  break;
	}

      else if (!strcmp (argv[i], "-cs")
	       || !strcmp (argv[i], "--context_serialise"))
	{
	  error = serialise_type (data, B_TYPE_CONTEXT);
	  break;
	}

      else if (!strcmp (argv[i], "-s") || !strcmp (argv[i], "--serialise"))
	{
	  error = serialise_triple (data);
	  break;
	}

      else if (!strcmp (argv[i], "-uc") || !strcmp (argv[i], "--uri_count"))
	{
	  error = count_type (data, B_TYPE_URI);
	  break;
	}

      else if (!strcmp (argv[i], "-bc") || !strcmp (argv[i], "--bnode_count"))
	{
	  error = count_type (data, B_TYPE_BNODE);
	  break;
	}

      else if (!strcmp (argv[i], "-lc")
	       || !strcmp (argv[i], "--literal_count"))
	{
	  error = count_type (data, B_TYPE_LITERAL);
	  break;
	}

      else if (!strcmp (argv[i], "-pc")
	       || !strcmp (argv[i], "--property_count"))
	{
	  error = count_type (data, B_TYPE_PROPERTY);
	  break;
	}

      else if (!strcmp (argv[i], "-dc")
	       || !strcmp (argv[i], "--datatype_count"))
	{
	  error = count_type (data, B_TYPE_DATATYPE);
	  break;
	}

      else if (!strcmp (argv[i], "-cc")
	       || !strcmp (argv[i], "--context_count"))
	{
	  error = count_type (data, B_TYPE_CONTEXT);
	  break;
	}

      else if (!strcmp (argv[i], "-c") || !strcmp (argv[i], "--count"))
	{
	  error = count_triple (data);
	  break;
	}

      else if ((!strcmp (argv[i], "-ua") || !strcmp (argv[i], "--uri_add"))
	       && argv[++i])
	{
	  error = add_type (data, B_TYPE_URI, argv[i]);
	  break;
	}

      else if ((!strcmp (argv[i], "-ba") || !strcmp (argv[i], "--bnode_add"))
	       && argv[++i])
	{
	  error = add_type (data, B_TYPE_BNODE, argv[i]);
	  break;
	}

      else
	if ((!strcmp (argv[i], "-la") || !strcmp (argv[i], "--literal_add"))
	    && argv[++i])
	{
	  error = add_type (data, B_TYPE_LITERAL, argv[i]);
	  break;
	}

      else
	if ((!strcmp (argv[i], "-pa") || !strcmp (argv[i], "--property_add"))
	    && argv[++i])
	{
	  error = add_type (data, B_TYPE_PROPERTY, argv[i]);
	  break;
	}

      else
	if ((!strcmp (argv[i], "-da") || !strcmp (argv[i], "--datatype_add"))
	    && argv[++i])
	{
	  error = add_type (data, B_TYPE_DATATYPE, argv[i]);
	}

      else if ((!strcmp (argv[i], "-a") || !strcmp (argv[i], "--add"))
	       && (i + 9) < argc)
	{
	  error =
	    add_triple (data, argv[i + 1], argv[i + 2], argv[i + 3],
			argv[i + 4], argv[i + 5], argv[i + 6], argv[i + 7],
			argv[i + 8], argv[i + 9]);
	  break;
	}

      else if ((!strcmp (argv[i], "-ur") || !strcmp (argv[i], "--uri_remove"))
	       && argv[++i])
	{
	  error = remove_type (data, B_TYPE_URI, argv[i]);
	  break;
	}

      else
	if ((!strcmp (argv[i], "-br") || !strcmp (argv[i], "--bnode_remove"))
	    && argv[++i])
	{
	  error = remove_type (data, B_TYPE_BNODE, argv[i]);
	  break;
	}

      else
	if ((!strcmp (argv[i], "-lr")
	     || !strcmp (argv[i], "--literal_remove")) && argv[++i])
	{
	  error = remove_type (data, B_TYPE_LITERAL, argv[i]);
	  break;
	}

      else
	if ((!strcmp (argv[i], "-pr")
	     || !strcmp (argv[i], "--property_remove")) && argv[++i])
	{
	  error = remove_type (data, B_TYPE_PROPERTY, argv[i]);
	  break;
	}

      else
	if ((!strcmp (argv[i], "-dr")
	     || !strcmp (argv[i], "--datatype_remove")) && argv[++i])
	{
	  error = remove_type (data, B_TYPE_DATATYPE, argv[i]);
	}

      else if ((!strcmp (argv[i], "-r") || !strcmp (argv[i], "--remove"))
	       && (i + 9) < argc)
	{
	  error =
	    remove_triple (data, argv[i + 1], argv[i + 2], argv[i + 3],
			   argv[i + 4], argv[i + 5], argv[i + 6], argv[i + 7],
			   argv[i + 8], argv[i + 9]);
	  break;
	}

      else
	{
	  fprintf (stderr, "Unkown option: %s\n", argv[i]);
	  b_destroy (data);
	  return 1;
	}
    }

  if (error)
    {
      fprintf (stderr, "Error: %s\n", b_strerror (error));
      return 1;
    }

  if ((error = b_destroy (data)))
    {
      fprintf (stderr, "Error (b_destroy): %s\n", b_strerror (error));
      return 1;
    }

  return 0;
}

static int
usage (char *what, int ret)
{
  fprintf (stderr, "%s path [options]\n\n", what);
  fprintf (stderr, "Options are:\n");
  fprintf (stderr,
	   "-us or --uri_serialise                                         | Serialise all uris\n");
  fprintf (stderr,
	   "-bs or --bnode_serialise                                       | Serialise all bnodes\n");
  fprintf (stderr,
	   "-ls or --literal_serialise                                     | Serialise all literals\n");
  fprintf (stderr,
	   "-ps or --property_serialise                                    | Serialise all properties\n");
  fprintf (stderr,
	   "-cs or --context_serialise                                     | Serialise all contexts\n");
  fprintf (stderr,
	   "-ds or --datatype_serialise                                    | Serialise all datatypes\n");
  fprintf (stderr,
	   "-s  or --serialise                                             | Serialise all triples\n");
  fprintf (stderr,
	   "-uc or --uri_count                                             | Count all uris\n");
  fprintf (stderr,
	   "-bc or --bnode_count                                           | Count all bnodes\n");
  fprintf (stderr,
	   "-lc or --literal_count                                         | Count all literals\n");
  fprintf (stderr,
	   "-pc or --property_count                                        | Count all properties\n");
  fprintf (stderr,
	   "-cc or --context_count                                         | Count all contexts\n");
  fprintf (stderr,
	   "-dc or --datatype_count                                        | Count all datatypes\n");
  fprintf (stderr,
	   "-c  or --count                                                 | Count all triples\n");
  fprintf (stderr,
	   "-ua or --uri_add      <what>                                   | Add a uri\n");
  fprintf (stderr,
	   "-ba or --bnode_add    <what>                                   | Add a bnode\n");
  fprintf (stderr,
	   "-la or --literal_add  <what>                                   | Add a literal\n");
  fprintf (stderr,
	   "-pa or --property_add <what>                                   | Add a property\n");
  fprintf (stderr,
	   "-ca or --context_add  <what>                                   | Add a context\n");
  fprintf (stderr,
	   "-da or --datatype_add <what>                                   | Add a datatype\n");
  fprintf (stderr,
	   "-a  or --add          <su> <sb> <p> <ou> <ob> <ol> <c> <d> <l> | Add a triple\n");
  fprintf (stderr,
	   "-ur or --uri_remove      <what>                                | Remove a uri\n");
  fprintf (stderr,
	   "-br or --bnode_remove    <what>                                | Remove a bnode\n");
  fprintf (stderr,
	   "-lr or --literal_remove  <what>                                | Remove a literal\n");
  fprintf (stderr,
	   "-pr or --property_remove <what>                                | Remove a property\n");
  fprintf (stderr,
	   "-cr or --context_remove  <what>                                | Remove a context\n");
  fprintf (stderr,
	   "-dr or --datatype_remove <what>                                | Remove a datatype\n");
  fprintf (stderr,
	   "-r  or --remove       <su> <sb> <p> <ou> <ob> <ol> <c> <d> <l> | Remove a triple\n");
  fprintf (stderr, "\nFor the triples: if a item is empty, use '-'\n\n");

  return ret;
}

static b_error_t
serialise_type (b_t * data, b_type_t type)
{
  unsigned char *what;
  b_error_t error;
  b_iterator_type_t *iterator;

  if ((error = b_iterator_type_new (data, type, &iterator)) != B_OK)
    return error;

  while ((error = b_iterator_type_step (iterator, &what, NULL)) == B_OK
	 && what)
    {
      fprintf (stdout, "%s\n", what);
      free (what);
    }

  if (error != B_OK)
    return error;

  error = b_iterator_type_destroy (iterator);
  return error;
}

static b_error_t
serialise_triple (b_t * data)
{
  b_triple_t *what;
  b_error_t error;
  b_iterator_triple_t *iterator;

  if ((error = b_iterator_triple_new (data, &iterator, NULL)) != B_OK)
    return error;

  while ((error = b_iterator_triple_step (iterator, &what)) == B_OK && what)
    {
      b_triple_print (stdout, what);
      b_triple_destroy (what);
    }

  if (error != B_OK)
    return error;

  error = b_iterator_triple_destroy (iterator);
  return error;
}

static b_error_t
count_type (b_t * data, b_type_t type)
{
  b_error_t error;
  b_uint64 n;

  if ((error = b_count_type (data, type, &n)))
    return error;

  fprintf (stdout, "%d\n", (int) n);
  return B_OK;
}

static b_error_t
count_triple (b_t * data)
{
  b_error_t error;
  b_uint64 n;

  if ((error = b_count_triple (data, &n)))
    return error;

  fprintf (stdout, "%d\n", (int) n);
  return B_OK;
}

static b_error_t
add_type (b_t * data, b_type_t type, char *what)
{
  return b_add_type (data, type, (unsigned char *) what, 0);
}

static b_error_t
add_triple (b_t * data, char *su, char *sb, char *p, char *ou,
	    char *ob, char *ol, char *c, char *d, char *l)
{
  b_triple_t *triple;
  b_error_t error;

  if ((error =
       b_triple_new (&triple,
		     (unsigned char *) (strcmp (su, "-") ? su : NULL), 0,
		     (unsigned char *) (strcmp (sb, "-") ? sb : NULL), 0,
		     (unsigned char *) (strcmp (p, "-") ? p : NULL), 0,
		     (unsigned char *) (strcmp (ou, "-") ? ou : NULL), 0,
		     (unsigned char *) (strcmp (ob, "-") ? ob : NULL), 0,
		     (unsigned char *) (strcmp (ol, "-") ? ol : NULL), 0,
		     (unsigned char *) (strcmp (c, "-") ? c : NULL), 0,
		     (unsigned char *) (strcmp (d, "-") ? d : NULL), 0,
		     (unsigned char *) (strcmp (l, "-") ? l : NULL), 0)))
    return error;

  error = b_add_triple (data, triple);

  b_triple_destroy (triple);
  return error;
}

static b_error_t
remove_type (b_t * data, b_type_t type, char *what)
{
  return b_remove_type (data, type, (unsigned char *) what, 0);
}

static b_error_t
remove_triple (b_t * data, char *su, char *sb, char *p, char *ou,
	       char *ob, char *ol, char *c, char *d, char *l)
{
  b_triple_t *triple;
  b_error_t error;

  if ((error =
       b_triple_new (&triple,
		     (unsigned char *) (strcmp (su, "-") ? su : NULL), 0,
		     (unsigned char *) (strcmp (sb, "-") ? sb : NULL), 0,
		     (unsigned char *) (strcmp (p, "-") ? p : NULL), 0,
		     (unsigned char *) (strcmp (ou, "-") ? ou : NULL), 0,
		     (unsigned char *) (strcmp (ob, "-") ? ob : NULL), 0,
		     (unsigned char *) (strcmp (ol, "-") ? ol : NULL), 0,
		     (unsigned char *) (strcmp (c, "-") ? c : NULL), 0,
		     (unsigned char *) (strcmp (d, "-") ? d : NULL), 0,
		     (unsigned char *) (strcmp (l, "-") ? l : NULL), 0)))
    return error;

  error = b_remove_triple (data, triple);

  b_triple_destroy (triple);
  return error;
}

/* EOF */
