/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
 *  (C) 2014 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */
#include "mpi.h"
#include "mpitest.h"
#include <stdio.h>
#include <string.h>

/* Communicating a datatype built out of structs
 * This test was motivated by the failure of an example program for
 * RMA involving simple operations on a struct that included a struct
 *
 * The observed failure was a SEGV in the MPI_Get
 *
 *
 */
#define MAX_KEY_SIZE 64
#define MAX_VALUE_SIZE 256
typedef struct {
    MPI_Aint disp;
    int rank;
    void *lptr;
} Rptr;
typedef struct {
    Rptr next;
    char key[MAX_KEY_SIZE], value[MAX_VALUE_SIZE];
} ListElm;
Rptr nullDptr = { 0, -1, 0 };

int testCases = -1;
#define BYTE_ONLY 0x1
#define TWO_STRUCT 0x2
int isOneLevel = 0;

int main(int argc, char **argv)
{
    int errors = 0;
    Rptr headDptr;
    ListElm *headLptr = 0;
    int i, wrank;
    MPI_Datatype dptrType, listelmType;
    MPI_Win listwin;

    MTest_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &wrank);

    for (i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-byteonly") == 0) {
            testCases = BYTE_ONLY;
        }
        else if (strcmp(argv[i], "-twostruct") == 0) {
            testCases = TWO_STRUCT;
        }
        else if (strcmp(argv[i], "-onelevel") == 0) {
            isOneLevel = 1;
        }
        else {
            printf("Unrecognized argument %s\n", argv[i]);
        }
    }

    /* Create the datatypes that we will use to move the data */
    {
        int blens[3];
        MPI_Aint displ[3];
        MPI_Datatype dtypes[3];
        ListElm sampleElm;

        blens[0] = 1;
        blens[1] = 1;
        MPI_Get_address(&nullDptr.disp, &displ[0]);
        MPI_Get_address(&nullDptr.rank, &displ[1]);
        displ[1] = displ[1] - displ[0];
        displ[0] = 0;
        dtypes[0] = MPI_AINT;
        dtypes[1] = MPI_INT;
        MPI_Type_create_struct(2, blens, displ, dtypes, &dptrType);
        MPI_Type_commit(&dptrType);

        if (isOneLevel) {
            blens[0] = sizeof(nullDptr);
            dtypes[0] = MPI_BYTE;
        }
        else {
            blens[0] = 1;
            dtypes[0] = dptrType;
        }
        blens[1] = MAX_KEY_SIZE;
        dtypes[1] = MPI_CHAR;
        blens[2] = MAX_VALUE_SIZE;
        dtypes[2] = MPI_CHAR;
        MPI_Get_address(&sampleElm.next, &displ[0]);
        MPI_Get_address(&sampleElm.key[0], &displ[1]);
        MPI_Get_address(&sampleElm.value[0], &displ[2]);
        displ[2] -= displ[0];
        displ[1] -= displ[0];
        displ[0] = 0;
        for (i = 0; i < 3; i++) {
            MTestPrintfMsg(0, "%d:count=%d,disp=%ld\n", i, blens[i], displ[i]);
        }
        MPI_Type_create_struct(3, blens, displ, dtypes, &listelmType);
        MPI_Type_commit(&listelmType);
    }

    MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_WORLD, &listwin);

    headDptr.rank = 0;
    if (wrank == 0) {
        /* Create 1 list element (the head) and initialize it */
        MPI_Alloc_mem(sizeof(ListElm), MPI_INFO_NULL, &headLptr);
        MPI_Get_address(headLptr, &headDptr.disp);
        headLptr->next.rank = -1;
        headLptr->next.disp = (MPI_Aint) MPI_BOTTOM;
        headLptr->next.lptr = 0;
        strncpy(headLptr->key, "key1", MAX_KEY_SIZE);
        strncpy(headLptr->value, "value1", MAX_VALUE_SIZE);
        MPI_Win_attach(listwin, headLptr, sizeof(ListElm));
    }
    MPI_Bcast(&headDptr.disp, 1, MPI_AINT, 0, MPI_COMM_WORLD);

    MPI_Barrier(MPI_COMM_WORLD);

    if (wrank == 1) {
        ListElm headcopy;

        MPI_Win_lock_all(0, listwin);
        /* Get head element with simple get of BYTES */
        if (testCases & BYTE_ONLY) {
            headcopy.next.rank = 100;
            headcopy.next.disp = 0xefefefef;
            MPI_Get(&headcopy, sizeof(ListElm), MPI_BYTE,
                    headDptr.rank, headDptr.disp, sizeof(ListElm), MPI_BYTE, listwin);
            MPI_Win_flush(headDptr.rank, listwin);
            if (headcopy.next.rank != -1 && headcopy.next.disp != (MPI_Aint) MPI_BOTTOM) {
                errors++;
                printf("MPI_BYTE: headcopy contains incorrect next:<%d,%ld>\n",
                       headcopy.next.rank, (long) headcopy.next.disp);
            }
        }

        if (testCases & TWO_STRUCT) {
            headcopy.next.rank = 100;
            headcopy.next.disp = 0xefefefef;
            /* Get head element using struct of struct type.  This is
             * not an identical get to the simple BYTE one above but should
             * work */
            MPI_Get(&headcopy, 1, listelmType, headDptr.rank, headDptr.disp,
                    1, listelmType, listwin);
            MPI_Win_flush(headDptr.rank, listwin);
            if (headcopy.next.rank != -1 && headcopy.next.disp != (MPI_Aint) MPI_BOTTOM) {
                errors++;
                printf("ListelmType: headcopy contains incorrect next:<%d,%ld>\n",
                       headcopy.next.rank, (long) headcopy.next.disp);
            }
        }

        MPI_Win_unlock_all(listwin);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    if (wrank == 0) {
        MPI_Win_detach(listwin, headLptr);
        MPI_Free_mem(headLptr);
    }
    MPI_Win_free(&listwin);
    MPI_Type_free(&dptrType);
    MPI_Type_free(&listelmType);

    MTest_Finalize(errors);
    MPI_Finalize();
    return MTestReturnValue(errors);
}