/* TrackCUDEEvent_subscriber.cxx
*/

#include <stdio.h>
#include <stdlib.h>
#include "TrackCUDEEvent.h"
#include "TrackCUDEEventSupport.h"
#include "ndds/ndds_cpp.h"

#include "ndds/ndds_namespace_cpp.h"

using namespace DDS;

class TrackCUDEEventListener : public DataReaderListener {
  public:
    virtual void on_requested_deadline_missed(
        DataReader* /*reader*/,
        const RequestedDeadlineMissedStatus& /*status*/) {}
    
    virtual void on_requested_incompatible_qos(
        DataReader* /*reader*/,
        const RequestedIncompatibleQosStatus& /*status*/) {}
    
    virtual void on_sample_rejected(
        DataReader* /*reader*/,
        const SampleRejectedStatus& /*status*/) {}

    virtual void on_liveliness_changed(
        DataReader* /*reader*/,
        const LivelinessChangedStatus& /*status*/) {}

    virtual void on_sample_lost(
        DataReader* /*reader*/,
        const SampleLostStatus& /*status*/) {}

    virtual void on_subscription_matched(
        DataReader* /*reader*/,
        const SubscriptionMatchedStatus& /*status*/) {}

    virtual void on_data_available(DataReader* reader);
};

void TrackCUDEEventListener::on_data_available(DataReader* reader)
{
    TrackCUDEEventDataReader *TrackCUDEEvent_reader = NULL;
    TrackCUDEEventSeq data_seq;
    SampleInfoSeq info_seq;
    ReturnCode_t retcode;
    int i;

    TrackCUDEEvent_reader = TrackCUDEEventDataReader::narrow(reader);
    if (TrackCUDEEvent_reader == NULL) {
        printf("DataReader narrow error\n");
        return;
    }

    retcode = TrackCUDEEvent_reader->take(
        data_seq, info_seq, LENGTH_UNLIMITED,
        ANY_SAMPLE_STATE, ANY_VIEW_STATE, ANY_INSTANCE_STATE);

    if (retcode == RETCODE_NO_DATA) {
        return;
    } else if (retcode != RETCODE_OK) {
        printf("take error %d\n", retcode);
        return;
    }

    for (i = 0; i < data_seq.length(); ++i) {
        if (info_seq[i].valid_data) {
            TrackCUDEEventTypeSupport::print_data(&data_seq[i]);
        }
    }

    retcode = TrackCUDEEvent_reader->return_loan(data_seq, info_seq);
    if (retcode != RETCODE_OK) {
        printf("return loan error %d\n", retcode);
    }
}

/* Delete all entities */
static int shutdown(
    DomainParticipant *participant)
{
    ReturnCode_t retcode;
    int status = 0;

    if (participant != NULL) {
        retcode = participant->delete_contained_entities();
        if (retcode != RETCODE_OK) {
            printf("delete_contained_entities error %d\n", retcode);
            status = -1;
        }

        retcode = TheParticipantFactory->delete_participant(participant);
        if (retcode != RETCODE_OK) {
            printf("delete_participant error %d\n", retcode);
            status = -1;
        }
    }

    /* RTI Connext provides the finalize_instance() method on
       domain participant factory for people who want to release memory used
       by the participant factory. Uncomment the following block of code for
       clean destruction of the singleton. */
/*
    retcode = DomainParticipantFactory::finalize_instance();
    if (retcode != RETCODE_OK) {
        printf("finalize_instance error %d\n", retcode);
        status = -1;
    }
*/
    return status;
}

extern "C" int subscriber_main(int domainId, int sample_count)
{
    DomainParticipant *participant = NULL;
    Subscriber *subscriber = NULL;
    Topic *topic = NULL;
    TrackCUDEEventListener *reader_listener = NULL; 
    DataReader *reader = NULL;
    ReturnCode_t retcode;
    const char *type_name = NULL;
    
    Publisher *publisher = NULL;
    DataWriter *writer = NULL;
    TrackCUDEEventDataWriter * TrackCUDEEvent_writer = NULL;
    TrackCUDEEvent *instance = NULL;
    InstanceHandle_t instance_handle = HANDLE_NIL;
    
    int count = 0;
    Duration_t receive_period = {4,0};
    int status = 0;

    /* To customize the participant QoS, use 
       the configuration file USER_QOS_PROFILES.xml */
    participant = TheParticipantFactory->create_participant(
        domainId, PARTICIPANT_QOS_DEFAULT, 
        NULL /* listener */, STATUS_MASK_NONE);
    if (participant == NULL) {
        printf("create_participant error\n");
        shutdown(participant);
        return -1;
    }

    /* To customize the subscriber QoS, use 
       the configuration file USER_QOS_PROFILES.xml */
    subscriber = participant->create_subscriber(
        SUBSCRIBER_QOS_DEFAULT, NULL /* listener */, STATUS_MASK_NONE);
    if (subscriber == NULL) {
        printf("create_subscriber error\n");
        shutdown(participant);
        return -1;
    }
    /* To customize publisher QoS, use 
       the configuration file USER_QOS_PROFILES.xml */
    publisher = participant->create_publisher(
        PUBLISHER_QOS_DEFAULT, NULL /* listener */, STATUS_MASK_NONE);
    if (publisher == NULL) {
        printf("create_publisher error\n");
        shutdown(participant);
        return -1;
    }

    /* Register the type before creating the topic */
    type_name = TrackCUDEEventTypeSupport::get_type_name();
    retcode = TrackCUDEEventTypeSupport::register_type(
        participant, type_name);
    if (retcode != RETCODE_OK) {
        printf("register_type error %d\n", retcode);
        shutdown(participant);
        return -1;
    }

    /* To customize the topic QoS, use 
       the configuration file USER_QOS_PROFILES.xml */
    topic = participant->create_topic(
        "Example TrackCUDEEvent",
        type_name, TOPIC_QOS_DEFAULT, NULL /* listener */,
        STATUS_MASK_NONE);
    if (topic == NULL) {
        printf("create_topic error\n");
        shutdown(participant);
        return -1;
    }

    /* Create a data reader listener */
    reader_listener = new TrackCUDEEventListener();

    /* To customize the data reader QoS, use 
       the configuration file USER_QOS_PROFILES.xml */
    reader = subscriber->create_datareader(
        topic, DATAREADER_QOS_DEFAULT, reader_listener,
        STATUS_MASK_ALL);
    if (reader == NULL) {
        printf("create_datareader error\n");
        shutdown(participant);
        delete reader_listener;
        return -1;
    }
    
    /* To customize data writer QoS, use 
       the configuration file USER_QOS_PROFILES.xml */
    writer = publisher->create_datawriter(
        topic, DATAWRITER_QOS_DEFAULT, NULL /* listener */,
        STATUS_MASK_NONE);
    if (writer == NULL) {
        printf("create_datawriter error\n");
        shutdown(participant);
        return -1;
    }
    TrackCUDEEvent_writer = TrackCUDEEventDataWriter::narrow(writer);
    if (TrackCUDEEvent_writer == NULL) {
        printf("DataWriter narrow error\n");
        shutdown(participant);
        return -1;
    }

    /* Create data sample for writing */
    instance = TrackCUDEEventTypeSupport::create_data();    
    if (instance == NULL) {
        printf("TrackCUDEEventTypeSupport::create_data error\n");
        shutdown(participant);
        return -1;
    }

    /* Main loop */
    for (count=0; (sample_count == 0) || (count < sample_count); ++count) {
	instance->event_count = count;
        retcode = TrackCUDEEvent_writer->write(*instance, instance_handle);
        if (retcode != RETCODE_OK) {
            printf("write error %d\n", retcode);
        }

        printf("TrackCUDEEvent subscriber sleeping for %d sec...\n",
               receive_period.sec);

        NDDSUtility::sleep(receive_period);
    }

    /* Delete all entities */
    status = shutdown(participant);
    delete reader_listener;

    return status;
}

int main(int argc, char *argv[])
{
    int domainId = 0;
    int sample_count = 0; /* infinite loop */

    if (argc >= 2) {
        domainId = atoi(argv[1]);
    }
    if (argc >= 3) {
        sample_count = atoi(argv[2]);
    }


    /* Uncomment this to turn on additional logging
    NDDSConfigLogger::get_instance()->
        set_verbosity_by_category(NDDS_CONFIG_LOG_CATEGORY_API, 
                                  NDDS_CONFIG_LOG_VERBOSITY_STATUS_ALL);
    */
                                  
    return subscriber_main(domainId, sample_count);
}