package com.rti.tools.experiments.reflectionbasedapi;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import shapes.ShapeTypeExtended;

import com.rti.dds.domain.DomainParticipant;
import com.rti.dds.domain.DomainParticipantFactory;
import com.rti.dds.infrastructure.RETCODE_NO_DATA;
import com.rti.dds.infrastructure.ResourceLimitsQosPolicy;
import com.rti.dds.infrastructure.StatusKind;
import com.rti.dds.subscription.DataReader;
import com.rti.dds.subscription.DataReaderAdapter;
import com.rti.dds.subscription.InstanceStateKind;
import com.rti.dds.subscription.SampleInfo;
import com.rti.dds.subscription.SampleInfoSeq;
import com.rti.dds.subscription.SampleStateKind;
import com.rti.dds.subscription.Subscriber;
import com.rti.dds.subscription.ViewStateKind;
import com.rti.dds.topic.Topic;
import com.rti.dds.topic.TypeSupport;
import com.rti.dds.util.Sequence;

public class GenericDataReader<T> {
    
    private final Class<T> typeClass;
    
    private final Class<? extends TypeSupport> typeSupportClass;
    private final TypeSupport typeSupport;
    private final String typeName;
    
    private final DomainParticipant participant;
    private final Topic topic;
    private final Subscriber subscriber;
    private final Listener listener;
    private final DataReader dataReader;
    
    @SuppressWarnings("unchecked")
    public GenericDataReader(DomainParticipant participant, Class<T> type, 
            String topicName) throws ClassNotFoundException, 
            NoSuchMethodException, SecurityException, IllegalAccessException, 
            IllegalArgumentException, InvocationTargetException, 
            InstantiationException {
        this.participant = participant;
        
        typeClass = type;
        String typeClassName = typeClass.getName();
        
        typeSupportClass = (Class<? extends TypeSupport>) Class.forName(
                typeClassName + "TypeSupport");
        Method getInstance = typeSupportClass.getMethod("get_instance");
        typeSupport = (TypeSupport) getInstance.invoke(null);
        
        Method getTypeName = typeSupportClass.getMethod("get_type_name");
        typeName = (String) getTypeName.invoke(null);
        
        // register the type
        participant.register_type(typeName, typeSupport, null);
        
        topic = participant.create_topic(topicName, typeName, 
                DomainParticipant.TOPIC_QOS_DEFAULT, null, 
                StatusKind.STATUS_MASK_NONE);
        
        subscriber = participant.create_subscriber(
                DomainParticipant.SUBSCRIBER_QOS_DEFAULT, null, 
                StatusKind.STATUS_MASK_NONE);
        
        listener = new Listener(typeClassName);
        
        dataReader = participant.create_datareader(topic, 
                Subscriber.DATAREADER_QOS_DEFAULT, listener, 
                StatusKind.DATA_AVAILABLE_STATUS);
        
    }
    
    public void delete() {
        dataReader.set_listener(null, StatusKind.STATUS_MASK_NONE);
        participant.delete_topic(topic);
        subscriber.delete_datareader(dataReader);
        participant.delete_subscriber(subscriber);
    }
    
    protected void sampleArrived(T data, SampleInfo info) {
        if (info.valid_data) {
            // print the sample's data
            System.out.println(data);
        }
    }
    
    private class Listener extends DataReaderAdapter {
        private final Sequence dataSeq;
        private final SampleInfoSeq infoSeq;
        
        public Listener(String typeClassName) throws ClassNotFoundException, 
            InstantiationException, IllegalAccessException {
            Class<?> sequenceClass = Class.forName(typeClassName + "Seq");
            dataSeq = (Sequence) sequenceClass.newInstance();
            
            infoSeq = new SampleInfoSeq();
        }
        
        @SuppressWarnings("unchecked")
        @Override
        public void on_data_available(DataReader dataReader) {
            try {
                dataReader.take_untyped(dataSeq, infoSeq, 
                        ResourceLimitsQosPolicy.LENGTH_UNLIMITED, 
                        SampleStateKind.ANY_SAMPLE_STATE, 
                        ViewStateKind.ANY_VIEW_STATE, 
                        InstanceStateKind.ANY_INSTANCE_STATE);
                
                for(int i = 0; i < dataSeq.size(); i++) {
                    SampleInfo info = (SampleInfo) infoSeq.get(i);
                    T data = (T) dataSeq.get(i);
                    GenericDataReader.this.sampleArrived(data, info);
                }
                
            } catch(RETCODE_NO_DATA noData) {
                // not a problem
                
            } finally {
                dataReader.return_loan_untyped(dataSeq, infoSeq);
            }
        }
    }
    
    public static void main(String[] args) throws Exception {
        final DomainParticipant participant = DomainParticipantFactory
                .get_instance().create_participant(0,
                        DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT, null,
                        StatusKind.STATUS_MASK_NONE);
        
        final GenericDataReader<ShapeTypeExtended> dataReader = 
                new GenericDataReader<ShapeTypeExtended>(participant, 
                        ShapeTypeExtended.class, "Square");
        
        Runtime.getRuntime().addShutdownHook(new Thread() {
            public void run() {
                dataReader.delete();
                participant.delete_contained_entities();
                DomainParticipantFactory.get_instance().delete_participant(
                        participant);
                DomainParticipantFactory.finalize_instance();
            }
        });
    }
}