/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
 *
 *  (C) 2018 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

#ifndef DTPOOLS_INTERNAL_H_INCLUDED
#define DTPOOLS_INTERNAL_H_INCLUDED

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "mpi.h"
#include "dtpools.h"

#define ERR_STRING_MAX_LEN (512)

#ifdef DEBUG_DTPOOLS
#define FPRINTF(fd,...)         \
    do {                        \
        fprintf(fd,__VA_ARGS__);\
        fflush(fd);             \
    } while (0)
#else
#define FPRINTF(...)
#endif

#define DTPI_OBJ_ALLOC_OR_FAIL(obj, size)                           \
    do {                                                            \
        obj = malloc(size);                                         \
        if (!obj) {                                                 \
            err = DTP_ERR_OTHER;                                    \
            fprintf(stdout, "Out of memory in %s\n", __FUNCTION__); \
            fflush(stdout);                                         \
            goto fn_fail;                                           \
        }                                                           \
        memset(obj, 0, size);                                       \
    } while (0)

/*
 * Simple derived datatype layouts:
 * - block length = 1
 * - stride       = 2
 * - count        = N
 */
enum {
    DTPI_OBJ_LAYOUT_SIMPLE__BASIC,
    DTPI_OBJ_LAYOUT_SIMPLE__CONTIG,
    DTPI_OBJ_LAYOUT_SIMPLE__VECTOR,
    DTPI_OBJ_LAYOUT_SIMPLE__INDEXED,
    DTPI_OBJ_LAYOUT_SIMPLE__BLOCK_INDEXED,
    DTPI_OBJ_LAYOUT_SIMPLE__HVECTOR,
    DTPI_OBJ_LAYOUT_SIMPLE__HINDEXED,
    DTPI_OBJ_LAYOUT_SIMPLE__BLOCK_HINDEXED,
    DTPI_OBJ_LAYOUT_SIMPLE__NUM
};

/*
 * Complex derived datatype layouts:
 * - block length = implementation defined
 * - stride       = implementation defined
 * - count        = implementation defined
 */
enum {
    DTPI_OBJ_LAYOUT_LARGE_BLK__VECTOR = DTPI_OBJ_LAYOUT_SIMPLE__NUM,
    DTPI_OBJ_LAYOUT_LARGE_BLK__INDEXED,
    DTPI_OBJ_LAYOUT_LARGE_BLK__BLOCK_INDEXED,
    DTPI_OBJ_LAYOUT_LARGE_BLK__HVECTOR,
    DTPI_OBJ_LAYOUT_LARGE_BLK__HINDEXED,
    DTPI_OBJ_LAYOUT_LARGE_BLK__BLOCK_HINDEXED,
    DTPI_OBJ_LAYOUT_LARGE_BLK__SUBARRAY_C,
    DTPI_OBJ_LAYOUT_LARGE_BLK__SUBARRAY_F,
    DTPI_OBJ_LAYOUT_LARGE_CNT__VECTOR,
    DTPI_OBJ_LAYOUT_LARGE_CNT__INDEXED,
    DTPI_OBJ_LAYOUT_LARGE_CNT__BLOCK_INDEXED,
    DTPI_OBJ_LAYOUT_LARGE_CNT__HVECTOR,
    DTPI_OBJ_LAYOUT_LARGE_CNT__HINDEXED,
    DTPI_OBJ_LAYOUT_LARGE_CNT__BLOCK_HINDEXED,
    DTPI_OBJ_LAYOUT_LARGE_CNT__SUBARRAY_C,
    DTPI_OBJ_LAYOUT_LARGE_CNT__SUBARRAY_F,
    DTPI_OBJ_LAYOUT_LARGE_BLK_STRD__VECTOR,
    DTPI_OBJ_LAYOUT_LARGE_BLK_STRD__INDEXED,
    DTPI_OBJ_LAYOUT_LARGE_BLK_STRD__BLOCK_INDEXED,
    DTPI_OBJ_LAYOUT_LARGE_BLK_STRD__HVECTOR,
    DTPI_OBJ_LAYOUT_LARGE_BLK_STRD__HINDEXED,
    DTPI_OBJ_LAYOUT_LARGE_BLK_STRD__BLOCK_HINDEXED,
    DTPI_OBJ_LAYOUT_LARGE_BLK_STRD__SUBARRAY_C,
    DTPI_OBJ_LAYOUT_LARGE_BLK_STRD__SUBARRAY_F,
    DTPI_OBJ_LAYOUT_LARGE_CNT_STRD__VECTOR,
    DTPI_OBJ_LAYOUT_LARGE_CNT_STRD__INDEXED,
    DTPI_OBJ_LAYOUT_LARGE_CNT_STRD__BLOCK_INDEXED,
    DTPI_OBJ_LAYOUT_LARGE_CNT_STRD__HVECTOR,
    DTPI_OBJ_LAYOUT_LARGE_CNT_STRD__HINDEXED,
    DTPI_OBJ_LAYOUT_LARGE_CNT_STRD__BLOCK_HINDEXED,
    DTPI_OBJ_LAYOUT_LARGE_CNT_STRD__SUBARRAY_C,
    DTPI_OBJ_LAYOUT_LARGE_CNT_STRD__SUBARRAY_F,
    /* TODO: add LOWER BOUND use case */
    DTPI_OBJ_LAYOUT_LARGE__NUM
};

/*
 * Only one layouts for struct datatype.
 * TODO: extend struct with multiple
 *       additional layouts ... ?
 */
enum {
    DTPI_OBJ_LAYOUT_SIMPLE__STRUCT,
    DTPI_OBJ_LAYOUT__STRUCT_NUM
};

typedef enum {
    DTPI_OBJ_TYPE__BASIC,
    DTPI_OBJ_TYPE__CONTIG,
    DTPI_OBJ_TYPE__VECTOR,
    DTPI_OBJ_TYPE__HVECTOR,
    DTPI_OBJ_TYPE__BLOCK_INDEXED,
    DTPI_OBJ_TYPE__BLOCK_HINDEXED,
    DTPI_OBJ_TYPE__INDEXED,
    DTPI_OBJ_TYPE__HINDEXED,
    DTPI_OBJ_TYPE__SUBARRAY_C,
    DTPI_OBJ_TYPE__SUBARRAY_F,
    DTPI_OBJ_TYPE__STRUCT,
    DTPI_OBJ_TYPE__NUM
} DTPI_obj_type_e;

/*
 * Internal object information
 */
typedef struct {
    DTPI_obj_type_e obj_type;

    MPI_Aint type_basic_size;   /* e.g., sizeof(int) */
    MPI_Aint type_extent;       /* total extent of type in bytes */
    MPI_Aint type_lb;           /* lower bound in bytes */
    MPI_Aint type_ub;           /* upper bound in bytes */

    union {
        struct {
            int stride;
            int blklen;
        } contig;
        struct {
            int stride;         /* stride in basic types */
            int blklen;         /* # of blocks in stride */
        } vector;
        struct {
            MPI_Aint stride;
            int blklen;
        } hvector;
        struct {
            int stride;
            int blklen;
        } indexed;
        struct {
            MPI_Aint stride;
            int blklen;
        } hindexed;
        struct {
            int stride;
            int blklen;
        } block_indexed;
        struct {
            MPI_Aint stride;
            int blklen;
        } block_hindexed;
        struct {
            int order;
            int arr_sizes[2];
            int arr_subsizes[2];
            int arr_starts[2];
        } subarray;
        struct {
            MPI_Aint *displs;   /* displacement addresses in buf */
        } structure;
    } u;
} DTPI_t;

/*
 * Internal parameter structure used to pass
 * data around. Two types of parameters:
 * - User defined object information
 * - Implementation (core) defined object information
 *
 * NOTE: for pools created with `DTP_pool_create_struct`
 *       user defined count is disregarded and reset
 *       internally to `DTP_basic_type_count`.
 */
struct DTPI_Par {
    struct {
        int val_start;          /* start value to fill buf with */
        int val_stride;         /* increment between values */
        int val_count;          /* number of elements to init in buf */
        int obj_idx;            /* index of object in pool */
    } user;
    struct {
        MPI_Aint type_count;    /* # of elements */
        MPI_Aint type_blklen;   /* length of a block in # of basic types */
        MPI_Aint type_stride;   /* # of basic types between start of each block */
        MPI_Aint type_totlen;   /* tot # of basic types in datatype */
        MPI_Aint type_displ;    /* displ of first elem in buffer in bytes */
    } core;
};

typedef int (*DTPI_Creator) (struct DTPI_Par * par, DTP_t dtp);

int DTPI_Struct_create(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Basic_create(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Contig_create(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Vector_create(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Hvector_create(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Indexed_create(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Hindexed_create(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Block_indexed_create(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Block_hindexed_create(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Subarray_c_create(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Subarray_f_create(struct DTPI_Par *par, DTP_t dtp);

int DTPI_Struct_check_buf(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Basic_check_buf(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Contig_check_buf(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Vector_check_buf(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Hvector_check_buf(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Indexed_check_buf(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Hindexed_check_buf(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Block_indexed_check_buf(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Block_hindexed_check_buf(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Subarray_c_check_buf(struct DTPI_Par *par, DTP_t dtp);
int DTPI_Subarray_f_check_buf(struct DTPI_Par *par, DTP_t dtp);

void DTPI_Print_error(int errcode);
void DTPI_Init_creators(DTPI_Creator * creators);

#endif /* DTPOOLS_INTERNAL_H_INCLUDED */