#include "mpi_test_incl.h"

class Master : public MasterBase
{
public:
    Master(int slaves, int iters, FILE* fpLog) : MasterBase(slaves, iters, fpLog) {}
    void RcvSyncP2P();
};

void Master::RcvSyncP2P()
{
    MPI_Request send_request, recv_request;
    MPI_Status  status;

    int  retErr     = MPI_SUCCESS;
    int  testSndNum;
    int  slaveRank = 1;
    int  slaveIdx  = 0;
    int  flag;

    while(mSlavesFinished < mSlaves)
    {
        slaveRank = slaveIdx + 1;
        fflush(mFpLog);
        MPI_Irecv(&(mRcvNumsBuf[slaveIdx]), 1, MPI::INT, slaveRank, MPI::ANY_TAG, MPI_COMM_WORLD, &recv_request);
        retErr = MPI_Wait(&recv_request, &status);

        // if ((retErr != MPI_SUCCESS) && ((retErr&0xFFFFFF) != 0x29A20F) )
        if (retErr != MPI_SUCCESS)
        {
            handleMPIerror(mFpLog, "Receive error ", retErr, &status);
            mIsSlaveLives[slaveIdx] = 0;
            ++mSlavesFinished;
        }
        else
        {
            // receive OK. Test for end of iterations
            // fprintf(mFpLog, "From rank %d, Got number = %d  \n", slaveRank, mRcvNumsBuf[slaveIdx]);
            ++mSlavesRcvIters[slaveIdx];
            if (mSlavesRcvIters[slaveIdx] == nIters)// no more receive
            {
                fprintf(mFpLog, "\n\nFrom rank %d, Got number = %d  \n", slaveRank, mRcvNumsBuf[slaveIdx]);
                fprintf(mFpLog, "Slave %d finished\n\n", slaveRank);
                ++mSlavesFinished;
            }
        }
        int nLoopIters = 0;
        do {
            slaveIdx = (slaveIdx + 1) % mSlaves;
        } while(!mIsSlaveLives[slaveIdx] && nLoopIters++<mSlaves);

        fflush(mFpLog);
    }

    fprintf(mFpLog, "\n\n\nEnd of master subroutine\n");

    SendEndOfCommunication();
}


void SndSyncSlave(int rank, FILE* fpLog)
{
    MPI_Status  status;
    MPI_Request request;

    int masterRank  = 0;
    int testSndNum = -1, testRcvNum = -1;
    int retErr;
    int passIter = 0;

    for(int i=1; i<nIters+1; ++i)
    // for(int i=1; i<1000000; ++i)
    {
        testSndNum = rank * Scale + i;
        MPI_Isend(&testSndNum, 1, MPI_INT, masterRank, 0, MPI_COMM_WORLD, &request);
        retErr = MPI_Wait(&request, &status);
        handleMPIerror(fpLog, "W_MpiSendSync error ", retErr);
        // fprintf(fpLog, "Sent number = %d  \n", testSndNum);

        FailFunction(rank, i, testSndNum, fpLog);
    }

    fprintf(fpLog, "Last Sent number = %d\n", testSndNum);

    // Wait for final message from master
    retErr = MPI_Recv(&testRcvNum, 1, MPI_INT, masterRank, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
    handleMPIerror(fpLog, "MpiRecv error ", retErr, &status);
    fprintf(fpLog, "Received number = %d\n", testRcvNum);


    fprintf(fpLog, "\n\n\nEnd of slave subroutine\n");
}

int main(int argc, char *argv[])
{
    int size = 1, rank = 0;
    bool isAllSlavesLive = true;
    FILE* fpLog;

    int retErr = mainInit(argc, argv, &size, &rank, &fpLog);
    if (retErr < 0)
        return 0;

    try
    {
        if(rank == 0)
        {
            Master master(size-1, nIters, fpLog);
            master.RcvSyncP2P();
            isAllSlavesLive = master.IsAllSlavesLive();
        }
        else
        {
            SndSyncSlave(rank, fpLog);
        }
    }

    catch(...)
    {
        fprintf(fpLog, "\n\n\nunexpected C++ exception\n\n");
    }

    bool isAbort = ( (rank == 0) && (!isAllSlavesLive) );
    MainFinalize(fpLog, isAbort);

    return 0;
}