#include <igraph.h>
#include <stdio.h>

int igraph_read_graph_extended_weighted_edgelist(igraph_t *graph, FILE *instream, 
			       igraph_integer_t n, igraph_bool_t directed) {

  igraph_vector_t edges=IGRAPH_VECTOR_NULL;
  igraph_vector_t ws=IGRAPH_VECTOR_NULL;
  igraph_vector_t ls=IGRAPH_VECTOR_NULL;
  igraph_vector_t vs=IGRAPH_VECTOR_NULL;
  long int id, label, value, nvertices;
  long int from, to, w;
  long int i;
  int c, read;
  igraph_vector_ptr_t  weight;
  igraph_vector_ptr_t  *pweight=0;
  igraph_vector_ptr_t	vertexattr;
  igraph_vector_ptr_t  *pvertexattr=0;
  igraph_i_attribute_record_t  weightrec;
  igraph_i_attribute_record_t  labelrec;
  igraph_i_attribute_record_t  valuerec;
  
  IGRAPH_VECTOR_INIT_FINALLY(&ls, 0);
  IGRAPH_CHECK(igraph_vector_reserve(&ls, 100));
  IGRAPH_VECTOR_INIT_FINALLY(&vs, 0);
  IGRAPH_CHECK(igraph_vector_reserve(&vs, 100));
  IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
  IGRAPH_CHECK(igraph_vector_reserve(&edges, 100));
  IGRAPH_VECTOR_INIT_FINALLY(&ws, 0);
  IGRAPH_CHECK(igraph_vector_reserve(&ws, 100));

  /* skip all whitespace */
  do {
    c = getc (instream);
  } while (isspace (c));
  ungetc (c, instream);
  
  read=fscanf(instream, "*Vertices %li", &nvertices);
  if (read != 1) { 
      IGRAPH_ERROR("parsing edgelist file failed 1", IGRAPH_PARSEERROR); 
  }

  do {
    c = getc (instream);
  } while (isspace (c));
  ungetc (c, instream);

  while (c != '*') {
     IGRAPH_ALLOW_INTERRUPTION();
    
    read=fscanf(instream, "%li", &id);
    if (read != 1) { 
      IGRAPH_ERROR("parsing edgelist file failed 2", IGRAPH_PARSEERROR); 
    }
    read=fscanf(instream, "%li", &label);
    if (read != 1) { 
      IGRAPH_ERROR("parsing edgelist file failed 3", IGRAPH_PARSEERROR); 
    }
    read=fscanf(instream, "%li", &value);
    if (read != 1) { 
      IGRAPH_ERROR("parsing edgelist file failed 4", IGRAPH_PARSEERROR); 
    }

    IGRAPH_CHECK(igraph_vector_push_back(&ls, label));
    IGRAPH_CHECK(igraph_vector_push_back(&vs, value));
    
    /* skip all whitespace */
    do {
      c = getc (instream);
    } while (isspace (c));
    ungetc (c, instream); 
   
  }

  /* Skip one line */
  do {
    c=getc(instream);
  } while (c != '\n' && c != '\r');
  
  do {
    c = getc (instream);
  } while (isspace (c));
  ungetc (c, instream);

  while (!feof(instream)) {

    IGRAPH_ALLOW_INTERRUPTION();
    
    read=fscanf(instream, "%li", &from);
    if (read != 1) { 
      IGRAPH_ERROR("parsing edgelist file failed 6", IGRAPH_PARSEERROR); 
    }
    read=fscanf(instream, "%li", &to);
    if (read != 1) { 
      IGRAPH_ERROR("parsing edgelist file failed 7", IGRAPH_PARSEERROR); 
    }
    read=fscanf(instream, "%li", &w);
    if (read != 1) { 
      IGRAPH_ERROR("parsing edgelist file failed 8", IGRAPH_PARSEERROR); 
    }

    IGRAPH_CHECK(igraph_vector_push_back(&edges, from));
    IGRAPH_CHECK(igraph_vector_push_back(&edges, to));
    IGRAPH_CHECK(igraph_vector_push_back(&ws, w));
    
    /* skip all whitespace */
    do {
      c = getc (instream);
    } while (isspace (c));
    ungetc (c, instream);    
  }
  IGRAPH_CHECK(igraph_empty(graph, 0, directed));
  IGRAPH_FINALLY(igraph_destroy, graph);
  
  IGRAPH_CHECK(igraph_vector_ptr_init(&vertexattr, 2)); 
  IGRAPH_FINALLY(igraph_vector_ptr_destroy, &vertexattr);
  pvertexattr=&vertexattr;
  labelrec.name="Label";
  labelrec.type=IGRAPH_ATTRIBUTE_NUMERIC;
  labelrec.value=&ls;
  VECTOR(vertexattr)[0]=&labelrec;

  valuerec.name="Value";
  valuerec.type=IGRAPH_ATTRIBUTE_NUMERIC;
  valuerec.value=&vs;
  VECTOR(vertexattr)[1]=&valuerec;

  IGRAPH_CHECK(igraph_add_vertices(graph, nvertices, pvertexattr));

  IGRAPH_CHECK(igraph_vector_ptr_init(&weight, 1)); 
  IGRAPH_FINALLY(igraph_vector_ptr_destroy, &weight);
  pweight=&weight;
  weightrec.name="Weight";
  weightrec.type=IGRAPH_ATTRIBUTE_NUMERIC;
  weightrec.value=&ws;
  VECTOR(weight)[0]=&weightrec;

  IGRAPH_CHECK(igraph_add_edges(graph, &edges, pweight));
  
  if (pweight) {
    igraph_vector_ptr_destroy(pweight);
    IGRAPH_FINALLY_CLEAN(1);
  }
  
  if (pvertexattr) {
    igraph_vector_ptr_destroy(pvertexattr);
    IGRAPH_FINALLY_CLEAN(1);
  }

  igraph_vector_destroy(&edges);
  igraph_vector_destroy(&ws);
  igraph_vector_destroy(&ls);
  igraph_vector_destroy(&vs);
  IGRAPH_FINALLY_CLEAN(1);
  return 0;
}

int print_attributes(const igraph_t *g) {

  igraph_vector_t gtypes, vtypes, etypes;
  igraph_strvector_t gnames, vnames, enames;
  long int i;

  igraph_vector_t vec;
  igraph_strvector_t svec;
  long int j;

  igraph_vector_init(&gtypes, 0);
  igraph_vector_init(&vtypes, 0);
  igraph_vector_init(&etypes, 0);
  igraph_strvector_init(&gnames, 0);
  igraph_strvector_init(&vnames, 0);
  igraph_strvector_init(&enames, 0);

  igraph_cattribute_list(g, &gnames, &gtypes, &vnames, &vtypes, 
			 &enames, &etypes);

  /* Graph attributes */
  for (i=0; i<igraph_strvector_size(&gnames); i++) {
    printf("%s=", STR(gnames, i));
    if (VECTOR(gtypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) {
      printf("%g ", GAN(g, STR(gnames,i)));
    } else {
      printf("\"%s\" ", GAS(g, STR(gnames,i)));
    }
  }
  printf("\n");

  for (i=0; i<igraph_vcount(g); i++) {
    long int j;
    printf("Vertex %li: ", i);
    for (j=0; j<igraph_strvector_size(&vnames); j++) {
      printf("%s=", STR(vnames, j));
      if (VECTOR(vtypes)[j]==IGRAPH_ATTRIBUTE_NUMERIC) {
	printf("%g ", VAN(g, STR(vnames,j), i));
      } else {
	printf("\"%s\" ", VAS(g, STR(vnames,j), i));
      }
    }
    printf("\n");
  }

  for (i=0; i<igraph_ecount(g); i++) {
    long int j;
    printf("Edge %li (%i-%i): ", i, (int)IGRAPH_FROM(g,i), (int)IGRAPH_TO(g,i));
    for (j=0; j<igraph_strvector_size(&enames); j++) {
      printf("%s=", STR(enames, j));
      if (VECTOR(etypes)[j]==IGRAPH_ATTRIBUTE_NUMERIC) {
	printf("%g ", EAN(g, STR(enames, j), i));
      } else {
	printf("\"%s\" ", EAS(g, STR(enames, j), i));
      }
    }
    printf("\n");
  }

  /* Check vector-based query functions */
  igraph_vector_init(&vec, 0);
  igraph_strvector_init(&svec, 0);
  
  for (j=0; j<igraph_strvector_size(&vnames); j++) {
    if (VECTOR(vtypes)[j]==IGRAPH_ATTRIBUTE_NUMERIC) {
      igraph_cattribute_VANV(g, STR(vnames, j), igraph_vss_all(), &vec);
      for (i=0; i<igraph_vcount(g); i++) {
	igraph_real_t num=VAN(g, STR(vnames, j), i);
	if (num != VECTOR(vec)[i] &&
	    (!isnan(num) || !isnan(VECTOR(vec)[i]))) {
	  exit(51);
	}
      }
    } else {
      igraph_cattribute_VASV(g, STR(vnames, j), igraph_vss_all(), &svec);
      for (i=0; i<igraph_vcount(g); i++) {
	const char *str=VAS(g, STR(vnames, j), i);
	if (strcmp(str,STR(svec, i))) {
	  exit(52);
	}
      }
    }
  }

  for (j=0; j<igraph_strvector_size(&enames); j++) {
    if (VECTOR(etypes)[j]==IGRAPH_ATTRIBUTE_NUMERIC) {
      igraph_cattribute_EANV(g, STR(enames, j), 
			     igraph_ess_all(IGRAPH_EDGEORDER_ID), &vec);
      for (i=0; i<igraph_ecount(g); i++) {
	igraph_real_t num=EAN(g, STR(enames, j), i);
	if (num != VECTOR(vec)[i] && 
	    (!isnan(num) || !isnan(VECTOR(vec)[i]))) {
	  exit(53);
	}
      }
    } else {
      igraph_cattribute_EASV(g, STR(enames, j), 
			     igraph_ess_all(IGRAPH_EDGEORDER_ID), &svec);
      for (i=0; i<igraph_ecount(g); i++) {
	const char *str=EAS(g, STR(enames, j), i);
	if (strcmp(str,STR(svec, i))) {
	  exit(54);
	}
      }
    }
  }

  igraph_strvector_destroy(&svec);
  igraph_vector_destroy(&vec);

  igraph_strvector_destroy(&enames);
  igraph_strvector_destroy(&vnames);
  igraph_strvector_destroy(&gnames);
  igraph_vector_destroy(&etypes);
  igraph_vector_destroy(&vtypes);
  igraph_vector_destroy(&gtypes);

  return 0;
}

int main() {
  FILE *file;
  igraph_t g;

  file=fopen("red_xwel", "r");
  if (file==0) {
    printf("Cannot open input file\n");
    exit(1);
  }

  /* turn on attribute handling */
  igraph_i_set_attribute_table(&igraph_cattribute_table);

  igraph_read_graph_extended_weighted_edgelist(&g, file, 0, IGRAPH_DIRECTED);
  fclose(file);

  print_attributes(&g);
  
  igraph_destroy(&g);
  return 0;
}