#include<iostream>
#include<thread>
#include<string>
#include<fstream>

#include <nats/nats.h>

std::ofstream outputFile("C:/Users/l0185/Desktop/nats-client-prattice/bin/Debug/publishMessage.txt");
void ThreadPublish(jsCtx*js,std::string subject,std::string Mess)
{
    natsStatus      s;
    jsPubAck *pa = NULL;
    int   index = 0;
    if(!outputFile.is_open()){
        std::cout<<"can't open the file"<<std::endl;
    }
    while(1)
    {
        std::string tempMesage = Mess+std::to_string(index);
        s = js_Publish(&pa, js, subject.c_str(), tempMesage.c_str(), tempMesage.size(), NULL, nullptr);
        if (s == NATS_OK)
        {
            std::cout<<"publish:"<<tempMesage<<std::endl;
            outputFile<<tempMesage+"\n";
        }
        index++;

    }
    outputFile.close();
}



static void
_jsPubErr(jsCtx *js, jsPubAckErr *pae, void *closure)
{
    int *errors = (int*) closure;

    printf("Error: %u - Code: %u - Text: %s\n", pae->Err, pae->ErrCode, pae->ErrText);
    printf("Original message: %.*s\n", natsMsg_GetDataLength(pae->Msg), natsMsg_GetData(pae->Msg));

    *errors = (*errors + 1);

    // If we wanted to resend the original message, we would do something like that:
    //
    // js_PublishMsgAsync(js, &(pae->Msg), NULL);
    //
    // Note that we use `&(pae->Msg)` so that the library set it to NULL if it takes
    // ownership, and the library will not destroy the message when this callback returns.

    // No need to destroy anything, everything is handled by the library.
}

int main()
{
    std::string errCode;
    natsConnection      *conn  = NULL;
    natsStatistics      *stats = NULL;
    natsOptions         *opts  = NULL;
    jsCtx               *js    = NULL;
    jsOptions           jsOpts;
    jsErrCode           jerr  ;
    natsStatus          s;
    int                 dataLen=0;
    volatile int        errors = 0;
    bool                delStream = false;
    bool                async = false;
    char * stream = "foostream";
    char * durable = "foodurable";
    const char ** subj=new const char *[3];
    subj[0]="foo1";
    subj[1]="foo2";
    subj[2]="foo3";
    s=natsOptions_Create(&opts);
      natsOptions_SetURL(opts,"nats://localhost:42342");
    s = natsConnection_Connect(&conn, opts);

    if (s == NATS_OK)
        s = jsOptions_Init(&jsOpts);

    if (s == NATS_OK)
    {
        if (async)
        {
            jsOpts.PublishAsync.ErrHandler           = _jsPubErr;
            jsOpts.PublishAsync.ErrHandlerClosure    = (void*) &errors;
        }
        s = natsConnection_JetStream(&js, conn, &jsOpts);
        std::cout<<"natsConnection_JetStream OK"<<std::endl;
    }
    if (s == NATS_OK)
    {
        jsStreamInfo    *si = NULL;

        // First check if the stream already exists.
        s = js_GetStreamInfo(&si, js, stream, NULL, &jerr);
        if (s == NATS_NOT_FOUND)
        {
            jsStreamConfig  cfg;

            // Since we are the one creating this stream, we can delete at the end.
            delStream = true;

            // Initialize the configuration structure.
            jsStreamConfig_Init(&cfg);
            cfg.Name = stream;
            // Set the subject
            cfg.Subjects = subj;
            cfg.SubjectsLen = 3;
            // Make it a memory stream.
            cfg.Storage = js_MemoryStorage;
            // Add the stream,
            s = js_AddStream(&si, js, &cfg, NULL, &jerr);
        }
        if (s == NATS_OK)
        {
            printf("Stream %s has %" PRIu64 " messages (%" PRIu64 " bytes)\n",
                si->Config->Name, si->State.Msgs, si->State.Bytes);

            // Need to destroy the returned stream object.
            jsStreamInfo_Destroy(si);
        }
        else {
            errCode = natsStatus_GetText(s);
            std::cout<<(int)s<<":"<<errCode<<std::endl;
        }
    }

    std::thread ThreadPublish1(ThreadPublish,js,"foo1","hellofoo1_");
    std::thread ThreadPublish2(ThreadPublish,js,"foo2","hellofoo2_");
    std::thread ThreadPublish3(ThreadPublish,js,"foo3","hellofoo3_");
    ThreadPublish1.detach();
    ThreadPublish2.detach();
    ThreadPublish3.detach();
    std::string end;
    std::cin>>end;
    // Destroy all our objects to avoid report of memory leak
    jsCtx_Destroy(js);
    // natsStatistics_Destroy(stats);
    natsConnection_Destroy(conn);
    natsOptions_Destroy(opts);
    // To silence reports of memory still in used with valgrind
    nats_Close();

    return 0;
}