/**
 * In this test we are using connectivity to form edges among vertices. 
 * We will then tag the vertices and edges with some data. Five vertices
 * are owned by rank 0, and five vertices are owned by rank 1. Then rank 0
 * define 5 edges using the vertices on rank 0 and 1. Rank 0 tags five vertices 
 * it owns and five edges, and rank 1 tags five vertices. This test case is
 * a baby step to build larger meshes e.g. as in GCRM where data resides on
 * layers, cell centers, edges, corners. 
 * */

#include <assert.h>
#include <stdio.h>
#include <unistd.h>

#include "damsel.h"

#define FILENAME "output/test-edges-parallel.h5"

int proc_ranks[5] = {1,1,1,1,1};

int main(int argc, char **argv) {
  int i, res, myrank, nprocs;
  printf("%s\n", argv[0]);

#ifndef DAMSEL_SINGLETHREAD
  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &res);
  assert(res == MPI_THREAD_MULTIPLE);
#else
  MPI_Init(&argc, &argv);
#endif

  MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);

  damsel_library lib;
  damsel_err_t err = DMSLlib_init(&lib);

  damsel_model model;
  err = DMSLmodel_create(DAMSEL_HANDLE_TYPE_HANDLE64, &model);
  unlink(FILENAME);
  damsel_trait_bundle tb;
  err = DMSLtrait_create(&tb);
  DMSLtrait_put(tb, "mode", "WRITE");
#ifdef DAMSEL_SUBFILE
  DMSLtrait_put(tb, "dmsl_num_subfiles", "2");
#endif

  DMSLmodel_attach(model, FILENAME, MPI_COMM_WORLD, tb);
  DMSLtrait_release(tb);

  /*Rank 0 and rank 1 will define vertices, and will tag them with some value*/
  /*Define damsel handle and Vertices on each rank*/ 

  short int data[5];
  int len = 5;

  damsel_handle vertex_id [len];
  damsel_handle remote_vertex_id[len], local_vertex_id[len];
  /*generating handles and some data values*/
  for(i=0; i<len; i++){
        vertex_id[i] = 100*myrank + i;
        data[i] = 11*i + myrank;
        if(myrank == 0)
		local_vertex_id[i] = 600*myrank + i;
  }

  /*All ranks will define the damsel handles, containers, and entity (5 each in this case)*/
  damsel_container vertex_collection_id;
  err = DMSLcontainer_create_vector(model, vertex_id, len, &vertex_collection_id); //assuming these are application handles?
  damsel_container vertex_handle_collection_id;
  err = DMSLcontainer_create_sequence(model, 200, len, 1, &vertex_handle_collection_id); //these are the handles for entities? Whats the difference between application handes and e.g. vertex handles in entity_define function. 
  DMSLentity_define(vertex_collection_id, DAMSEL_ENTITY_TYPE_VERTEX, 1, vertex_handle_collection_id);
  damsel_container local_vertex_collection_id;
  if(myrank == 0)
     err = DMSLcontainer_create_vector(model, local_vertex_id, len, &local_vertex_collection_id);

  /*All ranks will define this tag handle with the same tag name, i.e. each rank will have pressure value on vertices*/
  damsel_handle data_tag_handle = 1000;
  DMSLtag_define(model, &data_tag_handle, DAMSEL_DATA_TYPE_SHORTINT, "Pressure");
  DMSLmodel_map_tag(data, vertex_collection_id, &data_tag_handle);
  
  DMSLmodel_map_handles_inventing_file_handles(vertex_collection_id); 
  DMSLmodel_map_handles_inventing_file_handles(vertex_handle_collection_id);
  DMSLmodel_map_single_handle_inventing_file_handle(model, data_tag_handle);

  /*SOme stuff for defining edges on Rank 0*/
  damsel_container edge_connect_handle_collect_id, edge_handle_collect_id;
  short int edgedata[] = { 40,50,60,70,80 };
  damsel_handle edgedata_tag_handle = 2000;
  DMSLtag_define(model, &edgedata_tag_handle, DAMSEL_DATA_TYPE_SHORTINT, "Temperature");
  MPI_Status status;
  if(myrank == 1){
	MPI_Send(vertex_id, len, MPI_LONG_LONG_INT, 0, 10, MPI_COMM_WORLD);
	printf("Just finished sending\n");  
}if(myrank == 0) {
	MPI_Recv(remote_vertex_id, len, MPI_LONG_LONG_INT, 1, 10, MPI_COMM_WORLD, &status);
	printf("Just finished receving\n");
}
  ////////////////////////////////
  /*Code for rank 0 only*/
 /*Only on rank 0, map 5 vertices from rank 1 to rank 0
 * */
  /*Create a container of 10 vertices*/
  if (myrank == 0) 
  {
  /*This edge vector will be defined at rank 0*/  
  damsel_handle edge_vector[5] = {100, 101, 102, 103, 104};
  err = DMSLcontainer_create_vector(model, edge_vector, 5, &edge_handle_collect_id);

  DMSLmodel_map_handles_inventing_file_handles(edge_handle_collect_id);

  /* define handle collection for use with defining (edge) entity connectivity */
  damsel_handle edge_connect[10] = {vertex_id[0], local_vertex_id[0], vertex_id[1], local_vertex_id[1], vertex_id[2], local_vertex_id[2], vertex_id[3], local_vertex_id[3], vertex_id[4], local_vertex_id[4]};

  err = DMSLcontainer_create_vector(model, edge_connect, 10, &edge_connect_handle_collect_id);
  DMSLentity_define(edge_handle_collect_id, DAMSEL_ENTITY_TYPE_EDGE, 2, edge_connect_handle_collect_id);

  DMSLmodel_map_handles_inventing_file_handles(edge_connect_handle_collect_id);

  DMSLmodel_map_tag(edgedata, edge_handle_collect_id, &edgedata_tag_handle);
  DMSLmodel_map_single_handle_inventing_file_handle(model, edgedata_tag_handle);

  DMSLmodel_map_global_handles(local_vertex_collection_id, proc_ranks, remote_vertex_id);
  DMSLmodel_map_handles_inventing_file_handles(local_vertex_collection_id);
  }  

  DMSLmodel_transfer_sync(model, DAMSEL_TRANSFER_TYPE_WRITE);
  DMSLmodel_close(model);
  if(myrank == 0) {
  DMSLcontainer_close(edge_connect_handle_collect_id);
  DMSLcontainer_close(edge_handle_collect_id);
  }
  DMSLcontainer_close(vertex_collection_id);
  DMSLcontainer_close(vertex_handle_collection_id);
 
  DMSLlib_finalize(lib);

  MPI_Finalize();
  printf("done!\n");
  return 0;
}