/* define SLOWGRAPH_IMPL */

#ifndef SLOWGRAPH_COMMON_H
#define SLOWGRAPH_COMMON_H

#ifndef SLOWGRAPH_FUNC
#define SLOWGRAPH_FUNC /**/
#endif

#include <ctype.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SLOWGRAPH_LENOF(x) (sizeof((x)) / sizeof(*(x)))

typedef struct SlowGraph SlowGraph;
typedef struct SlowGraphNode SlowGraphNode;
typedef struct SlowGraphEdge SlowGraphEdge;
typedef struct SlowGraphAttr SlowGraphAttr;

struct SlowGraphAttr
{
  SlowGraphAttr* next;
  unsigned hash;
  char *key, *val;
};

struct SlowGraphNode
{
  SlowGraphNode* next;

  unsigned name_hash;
  char* name;
  SlowGraphAttr* attr;
  SlowGraphEdge* children;

  unsigned gc_used : 1;
};

struct SlowGraphEdge
{
  SlowGraphEdge* next;
  SlowGraphAttr* attr;

  SlowGraphNode* node;
};

struct SlowGraph
{
  SlowGraphNode* first;
};

SLOWGRAPH_FUNC void SlowGraphAttr_free(SlowGraphAttr* attrs);

SLOWGRAPH_FUNC unsigned slowgraph_hash(char const* buf);

SLOWGRAPH_FUNC unsigned slowgraph_hashn(void const* bufp, int len);

SLOWGRAPH_FUNC char* slowgraph_next_edge(
    FILE* inp,
    char* buf,
    int bufn,
    void (*opt_attr_clbk)(char* node, char* key, char* val),
    void (*opt_last_edge_attr_clbk)(char* key, char* val));

SLOWGRAPH_FUNC SlowGraphAttr* SlowGraphAttr_find(SlowGraphAttr* a,
                                                 unsigned hash);

/*
 Step 1: call SlowGraph_markAllUnused(graph)

 Step 2: manually mark input nodes as used

 Step 3: call SlowGraph_gcUnused(graph)   // only deletes nodes not used by
 manually marked used nodes
 */
SLOWGRAPH_FUNC void SlowGraph_markAllUnused(SlowGraph* graph);
SLOWGRAPH_FUNC void SlowGraph_gcUnused(SlowGraph* graph);

SLOWGRAPH_FUNC SlowGraphNode* SlowGraph_find(SlowGraph* g, unsigned name_hash);

SLOWGRAPH_FUNC SlowGraphEdge* SlowGraphNode_findConnection(SlowGraphNode* from,
                                                           SlowGraphNode* to);

/* if edge from->to already exists, return it instead */
SLOWGRAPH_FUNC SlowGraphEdge* SlowGraphNode_connect(SlowGraphNode* from,
                                                    SlowGraphNode* to);

SLOWGRAPH_FUNC SlowGraphNode* SlowGraph_getOrCreate(SlowGraph* g,
                                                    char const* name);

SLOWGRAPH_FUNC void slowgraph_setAttr(SlowGraphAttr** list,
                                      char const* key,
                                      char const* val);

/* returns 1 on failure */
SLOWGRAPH_FUNC int SlowGraph_readDGTXT(SlowGraph* g, FILE* f);

#ifdef SLOWGRAPH_IMPL
SLOWGRAPH_FUNC void SlowGraphAttr_free(SlowGraphAttr* attrs)
{
  SlowGraphAttr* to_free;
  for (; attrs;) {
    to_free = attrs;
    attrs = attrs->next;
    free(to_free->key);
    free(to_free->val);
    free(to_free);
  }
}

SLOWGRAPH_FUNC unsigned slowgraph_hash(char const* buf)
{
  unsigned res = 5381;
  for (; *buf; buf++) {
    res = (res << 5) + res + *buf;
  }
  return res;
}

SLOWGRAPH_FUNC unsigned slowgraph_hashn(void const* bufp, int len)
{
  char const* buf = (char const*)bufp;
  unsigned res = 5381;
  for (; buf != ((char const*)bufp) + len; buf++) {
    res = (res << 5) + res + *buf;
  }
  return res;
}

SLOWGRAPH_FUNC char* slowgraph_next_edge(
    FILE* inp,
    char* buf,
    int bufn,
    void (*opt_attr_clbk)(char* node, char* key, char* val),
    void (*opt_last_edge_attr_clbk)(char* key, char* val))
{
  int c;
  char *n, *k, *v, *retv = 0;

  c = fgetc(inp);

  for (;;) {
    if (c == EOF) {
      retv = 0;
      break;
    }

    for (; isspace(c); c = fgetc(inp))
      ;

    if (c == '#') {
      c = fgetc(inp);
      if (c == '#' && opt_attr_clbk && buf == fgets(buf, bufn, inp)) {
        n = strtok(buf + 1, " \r\n");
        k = strtok(0, " \r\n");
        v = strtok(0, " \r\n");
        opt_attr_clbk(n, k, v);
      } else if (c == ':' && opt_last_edge_attr_clbk &&
                 buf == fgets(buf, bufn, inp)) {
        k = strtok(buf + 1, " \r\n");
        v = strtok(0, " \r\n");
        opt_last_edge_attr_clbk(k, v);
      } else {
        for (; c != EOF && c != '\n'; c = fgetc(inp))
          ;
        c = fgetc(inp);
      }
      continue;
    }

    for (k = buf; c != EOF && !isspace(c); k++) {
      *k = c;
      c = fgetc(inp);
    }

    if (k == buf)
      continue;

    *k++ = 0;

    for (; isspace(c); c = fgetc(inp))
      ;

    for (v = k; c != EOF && !isspace(c); v++) {
      *v = c;
      c = fgetc(inp);
    }
    *v = 0;

    if (v == k)
      continue;

    retv = k;
    break;
  }

  ungetc(c, inp);
  return retv;
}

SLOWGRAPH_FUNC SlowGraphAttr* SlowGraphAttr_find(SlowGraphAttr* a,
                                                 unsigned hash)
{
  for (; a; a = a->next)
    if (a->hash == hash)
      return a;
  return 0;
}

SLOWGRAPH_FUNC void SlowGraph_markAllUnused(SlowGraph* graph)
{
  SlowGraphNode* n;
  for (n = graph->first; n; n = n->next)
    n->gc_used = 0;
}

SLOWGRAPH_FUNC void SlowGraph_gcUnused(SlowGraph* graph)
{
  int changed = 0;
  SlowGraphNode *n, *o, **prev;
  SlowGraphEdge *e, *oe;

  do {
    for (n = graph->first; n; n = n->next) {
      if (n->gc_used) {
        for (e = n->children; e; e = e->next) {
          if (!e->node->gc_used) {
            e->node->gc_used = 1;
            changed = 1;
          }
        }
      }
    }
  } while (changed);

  prev = &graph->first;
  for (n = graph->first; n;) {
    if (n->gc_used) {
      prev = &n->next;
      n = n->next;
    } else {
      o = n;
      n = n->next;
      *prev = n;

      for (e = o->children; e;) {
        oe = e;
        e = e->next;
        SlowGraphAttr_free(oe->attr);
        free(oe);
      }

      SlowGraphAttr_free(o->attr);
      free(o->name);
      free(o);
    }
  }
}

SLOWGRAPH_FUNC SlowGraphNode* SlowGraph_find(SlowGraph* g, unsigned name_hash)
{
  SlowGraphNode* n;
  for (n = g->first; n; n = n->next)
    if (n->name_hash == name_hash)
      return n;
  return 0;
}

SLOWGRAPH_FUNC SlowGraphEdge* SlowGraphNode_findConnection(SlowGraphNode* from,
                                                           SlowGraphNode* to)
{
  SlowGraphEdge* e;
  for (e = from->children; e; e = e->next)
    if (e->node == to)
      return e;
  return 0;
}

SLOWGRAPH_FUNC SlowGraphEdge* SlowGraphNode_connect(SlowGraphNode* from,
                                                    SlowGraphNode* to)
{
  SlowGraphEdge* e = SlowGraphNode_findConnection(from, to);
  if (e)
    return e;
  e = (SlowGraphEdge*)calloc(1, sizeof(SlowGraphEdge));
  if (!e)
    return 0;
  e->node = to;
  e->next = from->children;
  from->children = e;
  return e;
}

SLOWGRAPH_FUNC SlowGraphNode* SlowGraph_getOrCreate(SlowGraph* g,
                                                    char const* name)
{
  unsigned hash, strln;
  SlowGraphNode* n;

  strln = strlen(name);
  hash = slowgraph_hashn(name, strln);
  if ((n = SlowGraph_find(g, hash)))
    return n;
  n = (SlowGraphNode*)calloc(1, sizeof(SlowGraphNode));
  if (!n)
    return 0;
  n->name = (char*)calloc(strln + 1, sizeof(char));
  if (!n->name) {
    free(n);
    return 0;
  }
  strcpy(n->name, name);
  n->name_hash = hash;
  n->next = g->first;
  g->first = n;
  return n;
}

SLOWGRAPH_FUNC void slowgraph_setAttr(SlowGraphAttr** list,
                                      char const* key,
                                      char const* val)
{
  /* TODO: malloc fail handking */
  unsigned keylen = strlen(key);
  unsigned vallen = strlen(val);
  unsigned hash = slowgraph_hashn(key, keylen);
  SlowGraphAttr* a = SlowGraphAttr_find(*list, hash);
  if (a) {
    free(a->val);
  } else {
    a = (SlowGraphAttr*)calloc(1, sizeof(SlowGraphAttr));
    a->next = *list;
    *list = a;

    a->hash = hash;
    a->key = (char*)calloc(keylen + 1, sizeof(char));
    strcpy(a->key, key);
  }

  a->val = (char*)calloc(vallen + 1, sizeof(char));
  strcpy(a->val, val);
}

static SlowGraph* SlowGraph_read__graph;
static SlowGraphEdge* SlowGraph_read__lastEdge;

static void SlowGraph_read__nodeAttr(char* node, char* key, char* val)
{
  SlowGraphNode* n = SlowGraph_getOrCreate(SlowGraph_read__graph, node);
  if (!n)
    return;
  slowgraph_setAttr(&n->attr, key, val);
}

static void SlowGraph_read__edgeAttr(char* key, char* val)
{
  if (!SlowGraph_read__lastEdge)
    return;
  slowgraph_setAttr(&SlowGraph_read__lastEdge->attr, key, val);
}

/* returns 1 on failure */
SLOWGRAPH_FUNC int SlowGraph_readDGTXT(SlowGraph* g, FILE* f)
{
  static char buf[512];
  char* dest;

  SlowGraph_read__graph = g;
  SlowGraph_read__lastEdge = 0;

  while ((dest = slowgraph_next_edge(f, buf, SLOWGRAPH_LENOF(buf),
                                     SlowGraph_read__nodeAttr,
                                     SlowGraph_read__edgeAttr))) {
    SlowGraph_read__lastEdge = SlowGraphNode_connect(
        SlowGraph_getOrCreate(g, buf), SlowGraph_getOrCreate(g, dest));
    if (!SlowGraph_read__lastEdge)
      return 1;
  }

  SlowGraph_read__graph = 0;
  SlowGraph_read__lastEdge = 0;

  return 0;
}

#endif

#endif