/*
 * This is another option of writing gcrm data in damsel
 * we create vertices and treat the geodesic grid as an unstructured grid. 
 * The problem here is that for layers we need to define edges as well. 
 * And then there are two types of variables - grid and non-grid. 
 * We need to tag each vertex or edge with corresponding grid/non-grid variables. 
*/

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

#include "mpi.h"
#include "damsel.h"

#define FILENAME "output/gcrm1.h5"

/*Some scalars for global attributes, will tag the container of collection with corners, edges and cells*/
int layers = 256;
int interfaces = 257;
int cells = 1000;//40962;
int corners = 2000; //81920;
int edges = 3000; //122880;
int cellcorners = 6;
int celledges = 6;
int endpoints = 2;
int cellneighbors = 6;
  
//int tag_data[] = {layers, interfaces, cells, corners, edges, cellcorners, celledges, endpoints, cellneighbors};

float cell_lat_data[1000];
float edge_lat_data[3000];
float corner_lat_data[2000];

float cell_pressure[1000][6]; //number of cells and cell corners
//float corner_temp[][];
//float edge_denst[][];

/*Function to define different containers of cells, corners, etc*/
damsel_container *create_containers(damsel_model model);

/*These two functions for defining/setting tags on the collection with all the corners, edges and cells*/
damsel_err_t define_grid_dim_tags(damsel_model model, damsel_handle *tag_handles);
damsel_err_t set_grid_dim_tags(damsel_container container, int tag_data[], damsel_handle tag_handles[]);

/*These two functions are for defining/setting longitude and latitude on all cells, corners and edges*/
/*In this test we are only specifying latitude values, there will be the same steps for longitudes*/
damsel_err_t define_lat_tags(damsel_model model, damsel_handle *lat_tag_handles);
damsel_err_t set_lat_tags(damsel_container *container, damsel_handle *lat_tag_handles);


/*These functions are for defining/setting a solution variable on cells*/
damsel_err_t define_cell_tags(damsel_model model, damsel_data_type dt, damsel_handle *cell_tag_handles);
damsel_err_t set_cell_tags(damsel_container *container, damsel_handle *cell_tag_handles);

int main(int argc, char **argv) {
  int res;
 // damsel_handle tag_handles[9]; //for global attributes like number of cells etc, We may not need them but I am defining them in any case
  damsel_handle cell_tag_handles[3];
  damsel_handle lat_tag_handles[3];
  //damsel_handle edge_coll_handle = 101;
  //damsel_handle corner_coll_handle = 102;
  //damsel_handle grid_coll_handle = 103;
  damsel_container *cec_container;

//  int tag_data[] = {layers, interfaces, cells, corners, edges, cellcorners, celledges, endpoints, cellneighbors};
  
  int i, j;

  for(i=0;i<cells;i++){
	cell_lat_data[i] = 0.1*i;
     for(j=0;j<6;j++)
	cell_pressure[i][j] = 0.1*j+i;
  }
  for(i=0;i<edges;i++)
	edge_lat_data[i] = 0.3*i;

  for(i=0;i<corners;i++)
	corner_lat_data[i] = 0.2*i;
  
#ifndef DAMSEL_SINGLETHREAD
  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &res);
  assert(res == MPI_THREAD_MULTIPLE);
#else
  MPI_Init(&argc, &argv);
#endif

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

  damsel_model model;
  err = DMSLmodel_create(DAMSEL_HANDLE_TYPE_HANDLE64, &model);
  assert(model != NULL);
  
  size_t cell_array_dim[] = {6};
  damsel_data_type cell_array_type = DMSLtype_array_create(DAMSEL_DATA_TYPE_FLOAT, 1, cell_array_dim);
  
  /* we'll create a container for cells, corners and edges, and in damsel we will treat each of them as vertices 
 * all done in create_containers function*/

  cec_container = create_containers(model);
  define_lat_tags(model, lat_tag_handles);
  set_lat_tags(cec_container, lat_tag_handles);

  define_cell_tags(model, cell_array_type, cell_tag_handles);
  set_cell_tags(cec_container, cell_tag_handles);
  
  /*Define Collections for cells, corners, edges and all*/
  /*cells*/
 // DMSLcoll_create(model, (damsel_handle_ptr)(&cell_coll_handle), &cec_container[0], DAMSEL_HANDLE_COLLECTION_TYPE_SET);  

  //damsel_container cell_coll_cont;
  //  err = DMSLcontainer_create_vector(model, (damsel_handle_ptr)&cell_coll_handle, 1);
 
  /* at this point, the in-memory store knows about all the data that
     we have. next we will write the data out to disk.
     we need to invent some handles for the file store too.
  */
  unlink(FILENAME); // maybe it doesn't exist, so we'll just silently ignore any error
  damsel_trait_bundle tb;
  err = DMSLtrait_create(&tb);
  DMSLtrait_put(tb, "mode", "WRITE");

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

  /* Now we can tell damsel to execute everything. */

  damsel_request_t req;
  DMSLmodel_transfer_async(model, DAMSEL_TRANSFER_TYPE_WRITE, &req);
  damsel_status_t status;
  DMSLmodel_wait(req, &status);
  DMSLmodel_close(model);
  model = NULL;

//  DMSLcontainer_close(coll_cont);
//  coll_cont = NULL;

  DMSLlib_finalize(lib);
  lib = NULL;

  MPI_Finalize();
  return 0;
}


/*Functions here*/

damsel_container *create_containers(damsel_model model) {
  
  damsel_err_t err;
  damsel_container *container;
  container = (damsel_container *)malloc(3*sizeof(damsel_container));
  err = DMSLcontainer_create_sequence(model, 1000, cells, 1, &container[0]);
  err = DMSLcontainer_create_sequence(model, 50000, corners, 1, &container[1]);
  err = DMSLcontainer_create_sequence(model, 100000, edges, 1, &container[2]);

  DMSLentity_define(container[0], DAMSEL_ENTITY_TYPE_VERTEX, 1, container[0]);
  DMSLentity_define(container[1], DAMSEL_ENTITY_TYPE_VERTEX, 1, container[1]);
  DMSLentity_define(container[2], DAMSEL_ENTITY_TYPE_VERTEX, 1, container[2]);

  DMSLmodel_map_handles_inventing_file_handles(container[0]);
  DMSLmodel_map_handles_inventing_file_handles(container[1]);
  DMSLmodel_map_handles_inventing_file_handles(container[2]);
  return container;
}

/*Function to define the latitute tags on cells, edges and corners*/
damsel_err_t define_lat_tags(damsel_model model, damsel_handle *lat_tag_handles){
  int i, n = 3;
  char *names[] = {"cell_lat", "corner_lat", "edge_lat"};
 
  for(i = 0; i < n; i++){
     damsel_err_t err = DMSLtag_define(model, (damsel_handle_ptr)(lat_tag_handles+i), DAMSEL_DATA_TYPE_FLOAT, names[i]);
     if(err.id != 0) return DMSL_ERROR_GENERAL;
     DMSLmodel_map_single_handle_inventing_file_handle(model, lat_tag_handles[i]);	
  }
  return DMSL_OK;
}

/*Function to set the latitude tags on the cells, corners and edges, similar functions will be there for lingitute*/
damsel_err_t set_lat_tags(damsel_container *container, damsel_handle *lat_tag_handles){
 
  damsel_err_t err = DMSLmodel_map_tag(cell_lat_data, container[0], &lat_tag_handles[0]);
  if (err.id != 0) return DMSL_ERROR_GENERAL;
  
  err = DMSLmodel_map_tag(corner_lat_data, container[1], &lat_tag_handles[1]);
  if (err.id != 0) return DMSL_ERROR_GENERAL;
  
  err = DMSLmodel_map_tag(edge_lat_data, container[2], &lat_tag_handles[2]);
  if (err.id != 0) return DMSL_ERROR_GENERAL;

  return DMSL_OK;
}

/*Function to define the cell variable tags on cells, edges and corners*/
damsel_err_t define_cell_tags(damsel_model model, damsel_data_type dt, damsel_handle *cell_tag_handles){
  int i, n = 1;
  char *names[] = {"cell_pressure"};

  for(i = 0; i < n; i++){
     damsel_err_t err = DMSLtag_define(model, (damsel_handle_ptr)(cell_tag_handles+i), dt, names[i]);
     if(err.id != 0) return DMSL_ERROR_GENERAL;
     DMSLmodel_map_single_handle_inventing_file_handle(model, cell_tag_handles[i]);
  }
  return DMSL_OK;
}

/*Function to set the latitude tags on the cells, corners and edges, similar functions will be there for lingitute*/
damsel_err_t set_cell_tags(damsel_container *container, damsel_handle *cell_tag_handles){

  damsel_err_t err = DMSLmodel_map_tag(cell_pressure, container[0], &cell_tag_handles[0]);
  if (err.id != 0) return DMSL_ERROR_GENERAL;

  //err = DMSLmodel_map_tag(corner_lat_data, container[1], &lat_tag_handles[1]);
  //if (err.id != 0) return DMSL_ERROR_GENERAL;

  //err = DMSLmodel_map_tag(edge_lat_data, container[2], &lat_tag_handles[2]);
  //if (err.id != 0) return DMSL_ERROR_GENERAL;

  return DMSL_OK;
}


/*The following two functions are there to represent/edfine the scalrs for GCRM geodesic grid, not using them right now*/
damsel_err_t define_grid_dim_tags(damsel_model model, damsel_handle *tag_handles)
{
  int i, n = 9;
  char *names[] = {"g_layers", "g_interfaces", "g_cells", "g_corners", "g_edges", "g_cornercells", "g_celledges", "g_endpoints", "g_cellneighbors"};
  for (i=0; i<n; i++) {
    damsel_err_t err = DMSLtag_define(model, (damsel_handle_ptr)(tag_handles+i), DAMSEL_DATA_TYPE_INTEGER, names[i]);
        if (err.id != 0) return DMSL_ERROR_GENERAL;
    DMSLmodel_map_single_handle_inventing_file_handle(model, tag_handles[i]);
  }
  return DMSL_OK;
}

damsel_err_t set_grid_dim_tags(damsel_container container, int tag_data[], damsel_handle *tag_handles)
{
  int i, n=9;

  for (i=0; i<n; i++) {
    damsel_err_t err = DMSLmodel_map_tag(&tag_data[i], container, &tag_handles[i]);
        if (err.id != 0) return DMSL_ERROR_GENERAL;
  }

  return DMSL_OK;
}