// Copyright 2011-2020 David Robillard <d@drobilla.net>
// SPDX-License-Identifier: ISC

#undef NDEBUG

#include "serd/caret.h"
#include "serd/memory.h"
#include "serd/node.h"
#include "serd/nodes.h"
#include "serd/statement.h"

#include <assert.h>
#include <stddef.h>

#define NS_EG "http://example.org/"

static void
test_new(void)
{
  SerdAllocator* const allocator = serd_default_allocator();

  assert(!serd_statement_copy(allocator, NULL));

  SerdNodes* const nodes = serd_nodes_new(allocator);

  const SerdNode* const s = serd_nodes_get(nodes, serd_a_string("s"));
  const SerdNode* const u = serd_nodes_get(nodes, serd_a_uri_string(NS_EG "u"));
  const SerdNode* const b =
    serd_nodes_get(nodes, serd_a_blank_string(NS_EG "b"));

  // S, P, and G may not be strings (must be resources)
  assert(!serd_statement_new(allocator, s, u, u, u, NULL));
  assert(!serd_statement_new(allocator, u, s, u, u, NULL));
  assert(!serd_statement_new(allocator, u, u, u, s, NULL));

  // P may not be a blank node
  assert(!serd_statement_new(allocator, u, b, u, u, NULL));

  serd_nodes_free(nodes);
}

static void
test_copy(void)
{
  SerdAllocator* const alloc = NULL;

  assert(!serd_statement_copy(NULL, NULL));

  SerdNode* const f = serd_node_new(alloc, serd_a_string("file"));
  SerdNode* const s = serd_node_new(alloc, serd_a_uri_string(NS_EG "s"));
  SerdNode* const p = serd_node_new(alloc, serd_a_uri_string(NS_EG "p"));
  SerdNode* const o = serd_node_new(alloc, serd_a_uri_string(NS_EG "o"));
  SerdNode* const g = serd_node_new(alloc, serd_a_uri_string(NS_EG "g"));

  SerdCaret* const     caret     = serd_caret_new(alloc, f, 1, 1);
  SerdStatement* const statement = serd_statement_new(alloc, s, p, o, g, caret);
  SerdStatement* const copy      = serd_statement_copy(alloc, statement);

  assert(serd_statement_equals(copy, statement));
  assert(serd_caret_equals(serd_statement_caret(copy), caret));

  serd_statement_free(NULL, copy);
  serd_caret_free(NULL, caret);
  serd_statement_free(NULL, statement);
  serd_node_free(NULL, g);
  serd_node_free(NULL, o);
  serd_node_free(NULL, p);
  serd_node_free(NULL, s);
  serd_node_free(NULL, f);
}

static void
test_free(void)
{
  serd_statement_free(serd_default_allocator(), NULL);
  serd_statement_free(NULL, NULL);
}

static void
test_fields(void)
{
  SerdAllocator* const alloc = NULL;

  SerdNode* const f = serd_node_new(alloc, serd_a_string("file"));
  SerdNode* const s = serd_node_new(alloc, serd_a_uri_string(NS_EG "s"));
  SerdNode* const p = serd_node_new(alloc, serd_a_uri_string(NS_EG "p"));
  SerdNode* const o = serd_node_new(alloc, serd_a_uri_string(NS_EG "o"));
  SerdNode* const g = serd_node_new(alloc, serd_a_uri_string(NS_EG "g"));

  SerdCaret* const caret = serd_caret_new(alloc, f, 1, 1);

  SerdStatement* const statement = serd_statement_new(alloc, s, p, o, g, caret);

  assert(serd_statement_equals(statement, statement));
  assert(!serd_statement_equals(statement, NULL));
  assert(!serd_statement_equals(NULL, statement));

  assert(serd_statement_node(statement, SERD_SUBJECT) == s);
  assert(serd_statement_node(statement, SERD_PREDICATE) == p);
  assert(serd_statement_node(statement, SERD_OBJECT) == o);
  assert(serd_statement_node(statement, SERD_GRAPH) == g);

  assert(serd_statement_subject(statement) == s);
  assert(serd_statement_predicate(statement) == p);
  assert(serd_statement_object(statement) == o);
  assert(serd_statement_graph(statement) == g);
  assert(serd_statement_caret(statement) != caret);
  assert(serd_caret_equals(serd_statement_caret(statement), caret));
  assert(serd_statement_matches(statement, s, p, o, g));
  assert(serd_statement_matches(statement, NULL, p, o, g));
  assert(serd_statement_matches(statement, s, NULL, o, g));
  assert(serd_statement_matches(statement, s, p, NULL, g));
  assert(serd_statement_matches(statement, s, p, o, NULL));
  assert(!serd_statement_matches(statement, o, NULL, NULL, NULL));
  assert(!serd_statement_matches(statement, NULL, o, NULL, NULL));
  assert(!serd_statement_matches(statement, NULL, NULL, s, NULL));
  assert(!serd_statement_matches(statement, NULL, NULL, NULL, s));

  SerdStatement* const diff_s = serd_statement_new(alloc, o, p, o, g, caret);
  assert(!serd_statement_equals(statement, diff_s));
  serd_statement_free(alloc, diff_s);

  SerdStatement* const diff_p = serd_statement_new(alloc, s, o, o, g, caret);
  assert(!serd_statement_equals(statement, diff_p));
  serd_statement_free(alloc, diff_p);

  SerdStatement* const diff_o = serd_statement_new(alloc, s, p, s, g, caret);
  assert(!serd_statement_equals(statement, diff_o));
  serd_statement_free(alloc, diff_o);

  SerdStatement* const diff_g = serd_statement_new(alloc, s, p, o, s, caret);
  assert(!serd_statement_equals(statement, diff_g));
  serd_statement_free(alloc, diff_g);

  serd_statement_free(alloc, statement);
  serd_caret_free(alloc, caret);
  serd_node_free(alloc, g);
  serd_node_free(alloc, o);
  serd_node_free(alloc, p);
  serd_node_free(alloc, s);
  serd_node_free(alloc, f);
}

int
main(void)
{
  test_new();
  test_copy();
  test_free();
  test_fields();

  return 0;
}