/*******************************************************************************
 * Copyright (c) 2004, 2007 Boeing.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Boeing - initial API and implementation
 *******************************************************************************/
package org.eclipse.osee.ote.messaging.dds.entity;

import java.util.Collection;
import java.util.concurrent.CopyOnWriteArrayList;
import org.eclipse.osee.framework.jdk.core.type.CompositeKeyHashMap;
import org.eclipse.osee.ote.messaging.dds.DataStoreItem;
import org.eclipse.osee.ote.messaging.dds.IDestination;
import org.eclipse.osee.ote.messaging.dds.ISource;
import org.eclipse.osee.ote.messaging.dds.NotImplementedException;
import org.eclipse.osee.ote.messaging.dds.ReturnCode;
import org.eclipse.osee.ote.messaging.dds.StatusKind;
import org.eclipse.osee.ote.messaging.dds.listener.DataWriterListener;
import org.eclipse.osee.ote.messaging.dds.listener.DomainParticipantListener;
import org.eclipse.osee.ote.messaging.dds.listener.Listener;
import org.eclipse.osee.ote.messaging.dds.listener.PublisherListener;
import org.eclipse.osee.ote.messaging.dds.listener.SubscriberListener;
import org.eclipse.osee.ote.messaging.dds.listener.TopicListener;
import org.eclipse.osee.ote.messaging.dds.service.DomainId;
import org.eclipse.osee.ote.messaging.dds.service.TopicDescription;
import org.eclipse.osee.ote.messaging.dds.service.TypeRegistry;
import org.eclipse.osee.ote.messaging.dds.service.TypeSignature;
import org.eclipse.osee.ote.messaging.dds.service.TypeSupport;

/**
 * Provides functionality for applications to participate within a domain as described in the DDS specification. The
 * DomainParticipant is a factory used by the application to create {@link Publisher}'s and {@link Subscriber}'s to
 * interact with the system.
 * <p>
 * In addition to the functionality described in the DDS specification, this class provides particular functionality to
 * interact with middleware which could be used to link this with another data system. The middleware is provided a
 * special publisher to inject data into this system, and receives data from all other publishers by means of the
 * {@link DomainParticipantListener}.
 * 
 * @author Robert A. Fisher
 * @author David Diepenbrock
 */
public class DomainParticipant extends Entity implements EntityFactory {
   private final DomainId domainId;
   // These collections REALLY need to be thread safe!!!
   private final CopyOnWriteArrayList<Publisher> publishers;
   private final CopyOnWriteArrayList<Subscriber> subscribers;
   private final CompositeKeyHashMap<String, String, Topic> topics;

   private final TypeRegistry typeRegistry;
   private Publisher middlewarePublisher; // Publisher who can send anything

   // DONT_NEED The builtinSubscriber is here for future functionality that is described in the DDS specification but has not been implemented or used.
   private final Subscriber builtinSubscriber;

   /**
    * @param domainId The domain this participant will belong to
    * @param domain A reference to the collection of all participants in this domain.
    * @param enabled Flag which indicates if this is enabled.
    * @param listener The listener attached to this.
    * @param parentFactory A reference to the factory that is creating this.
    * @param threadedPublishing <code>True</code> if we should create a separate thread for processing published data.
    * If <code>False</code>, the published data will be processed within the thread which makes the call to write data
    * into the system (or resume publications).
    * @param typeCapacity The initial capacity to use when creating the <code>Map</code> for the {@link TypeRegistry}.
    * @param typeFactor The load factor to use when creating the <code>Map</code> for the {@link TypeRegistry}.
    */
   DomainParticipant(DomainId domainId, Collection<DomainParticipant> domain, boolean enabled, DomainParticipantListener listener, EntityFactory parentFactory, boolean threadedPublishing, int typeCapacity, float typeFactor) {
      super(enabled, listener, parentFactory);

      this.domainId = domainId;
      this.publishers = new CopyOnWriteArrayList<>(); // Thread Safe
      this.subscribers = new CopyOnWriteArrayList<>(); // Thread Safe
      this.topics = new CompositeKeyHashMap<>(512, true);
      this.middlewarePublisher = null;
      this.typeRegistry = new TypeRegistry(typeCapacity, typeFactor);

      this.builtinSubscriber = null;
   }

   /**
    * Creates the DomainParticipant with default settings for typeCapacity and typeFactor.
    * 
    * @see DomainParticipant#DomainParticipant(DomainId, Collection, boolean, DomainParticipantListener, EntityFactory,
    * boolean, int, float)
    */
   DomainParticipant(DomainId domainId, Collection<DomainParticipant> domain, boolean enabled, DomainParticipantListener listener, EntityFactory parentFactory, boolean threadedPublishing) {
      this(domainId, domain, enabled, listener, parentFactory, threadedPublishing, 256, .75f);
   }

   /**
    * This method is here for future functionality that is described in the DDS specification but has not been
    * implemented or used.
    * 
    * @return Returns the builtinSubscriber.
    */
   public Subscriber getBuiltinSubscriber() {
      // DONT_NEED This method has not been implemented, but is called out in the spec
      if (true) {
         throw new NotImplementedException();
      }
      return builtinSubscriber;
   }

   /**
    * Gets the listener attached to this <code>DomainParticipant</code>.
    */
   public DomainParticipantListener getListener() {
      return (DomainParticipantListener) super.getBaseListener();
   }

   /**
    * Sets the listener attached to this <code>DomainParticipant</code>. This replaces the existing listener.
    * 
    * @param listener The listener to attach.
    * @param mask A mask identifying which communication statuses the listener should be invoked.
    * @return The {@link ReturnCode}returned by {@link Entity#setBaseListener(Listener, StatusKind)}.
    * @see Entity#setBaseListener(Listener, StatusKind)
    */
   public ReturnCode setListener(DomainParticipantListener listener, StatusKind mask) {
      return super.setBaseListener(listener, mask);
   }

   /**
    * Creates a publisher with the passed listener attached.
    * 
    * @param publisherListener The listener to attach to the newly created Publisher.
    * @return The newly created publisher, or null if an error occurred in creation.
    */
   private Publisher createAPublisher(PublisherListener publisherListener) {
      Publisher publisher = null;
      try {
         publisher = new Publisher(this, this.isEnabled(), publisherListener);
         publishers.add(publisher);
      } catch (OutOfMemoryError er) {
         er.printStackTrace();
         publisher = null;
      }

      return publisher;
   }

   /**
    * Creates a middlewarePublisher. If a middlewarePublisher has already been created this will return a reference to
    * the existing middlewarePublisher. The middlewarePublisher is provided as a link for an outside system to be able
    * to inject data into this system.
    * 
    * @param publisherListener The listener to attach to the newly created <code>Publisher</code>. Note that this can be
    * null.
    * @return A <code>Publisher</code> with the passed in listener assigned to it, or null if an error occurred in
    * creation.
    */
   public Publisher getMiddlewarePublisherInstance(PublisherListener publisherListener) {
      if (middlewarePublisher == null) {
         middlewarePublisher = createAPublisher(publisherListener);
      }
      return middlewarePublisher;
   }

   /**
    * Creates a new <code>Publisher</code> with a particular listener assigned to it. The publisher will be created
    * enabled iff this <code>DomainParticipant</code> is enabled. If an OutOfMemoryError is thrown while attempting get
    * the new publisher, <b>null </b> will be returned.
    * 
    * @param publisherListener The listener to be attached.
    * @return The newly created <code>Publisher</code>, or null if an error occurred in creation.
    */
   public Publisher createPublisher(PublisherListener publisherListener) {
      Publisher publisher = createAPublisher(publisherListener);
      if (publisher != null) {
         publishers.add(publisher);
      }
      return publisher;
   }

   /**
    * Removes the passed <code>Publisher</code> iff the publisher was created by this <code>DomainParticipant</code> and
    * does not have any attached <code>DataWriter</code> 's.
    * 
    * @param publisher The publisher to be removed.
    * @return {@link ReturnCode#OK}if the publisher was successfully removed, {@link ReturnCode#PRECONDITION_NOT_MET}if
    * the publisher had writers or was not created by this DomainParticipant, or {@link ReturnCode#ERROR}.
    */
   public ReturnCode deletePublisher(Publisher publisher) {

      // Check that the Entity is enabled before proceeding (See description of enable on the Entity object in the DDS spec)
      if (!isEnabled()) {
         return ReturnCode.NOT_ENABLED;
      }

      // Check that a publisher was supplied
      if (publisher == null) {
         return ReturnCode.ERROR;
      }

      // Check the pre-condition
      if (publisher.hasDataWriters()) {
         return ReturnCode.PRECONDITION_NOT_MET;
      }

      // Attempt to remove, if it did not exist in our list then return an error,
      // since it can only be removed from the <code>DomainParticipant</code> which created it.
      if (publishers.remove(publisher)) {
         return ReturnCode.OK;
      } else {
         return ReturnCode.PRECONDITION_NOT_MET;
      }
   }

   /**
    * Creates a <code>Subscriber</code> with the provided listener attached.
    * 
    * @param subscriberListener The listener to be attached.
    * @return The newly created <code>Subscriber</code>, or null if an error occurred in creation.
    */
   public Subscriber createSubscriber(SubscriberListener subscriberListener) {
      Subscriber subscriber = null;
      try {
         subscriber = new Subscriber(this, this.isEnabled(), subscriberListener);
         subscribers.add(subscriber);
      } catch (OutOfMemoryError er) {
         er.printStackTrace();
         subscriber = null;
      }
      return subscriber;
   }

   /**
    * Removes the passed <code>Subscriber</code> iff the subscriber was created by this <code>DomainParticipant</code>
    * and does not have any attached <code>DataReader</code> 's.
    * 
    * @param subscriber The subscriber to be removed.
    * @return {@link ReturnCode#OK}if the subscriber was successfully removed, {@link ReturnCode#PRECONDITION_NOT_MET}if
    * the subscriber had readers or was not created by this DomainParticipant, or {@link ReturnCode#ERROR}.
    */
   public ReturnCode deleteSubscriber(Subscriber subscriber) {

      // Check that the Entity is enabled before proceeding (See description of enable on the Entity object in the DDS spec)
      if (!isEnabled()) {
         return ReturnCode.NOT_ENABLED;
      }

      // Check that a subscriber was supplied
      if (subscriber == null) {
         return ReturnCode.ERROR;
      }

      // Check the pre-condition
      if (subscriber.hasDataReaders()) {
         return ReturnCode.PRECONDITION_NOT_MET;
      }

      // Attempt to remove, if it did not exist in our list then return an error,
      // since it can only be removed from the <code>DomainParticipant</code> which created it.
      if (subscribers.remove(subscriber)) {
         return ReturnCode.OK;
      } else {
         return ReturnCode.PRECONDITION_NOT_MET;
      }
   }

   /**
    * Creates a <code>Topic</code> on this <code>DomainParticipant</code> with the give name. If a <code>Topic</code>
    * already exists with the given name, then the existing topic will be returned IF the typeName matches that of the
    * existing <code>Topic</code>. If the type's do not match, <b>null </b> is returned.
    * 
    * @param name The name of the topic to create.
    * @param typeName The name of the type associated with the topic.
    * @param topicListener The listener to be attached to the created topic if it is newly created. If the topic already
    * exists, the provided listener is ignored.
    * @return A new <code>Topic</code> if one does not already exist, or an existing topic with the same
    * <code>name</code> and <code>typeName</code>, otherwise <b>null </b>
    */
   public Topic createTopic(String name, String namespace, String typeName, TopicListener topicListener) {

      Topic topic = null;

      // Even before that, check that the type was registered
      TypeSignature typeSignature = typeRegistry.lookupSignature(typeName);
      if (typeSignature == null) {
         throw new RuntimeException(String.format("No type signature with name [%s] was found.", typeName));
      } else {

         // First check to see if the topic already exists
         TopicDescription topicDescription = lookupTopicDescription(namespace, name);
         if (topicDescription != null && topicDescription instanceof Topic) {

            topic = (Topic) topicDescription;

            // Make sure that the type name is the same, otherwise it is failure
            if (topic.getTypeName().equals(typeName)) {
               // Track that another create has been called for this topic
               topic.incrementCount();
            } else {
               // There is a violation, and no topic will be returned since a topic
               // with this name already exists, but the types do not match
               throw new RuntimeException(
                  String.format(
                     "found topic name:[%s] namespace:[%s] but there was a type incompatibility between [%s] (from topic [%s]) and [%s].",
                     name, namespace, topic.getTypeName(), topic.getName(), typeName));
            }
         } else { // Otherwise, the topic did not already exist
            topic = new Topic(this, typeSignature, name, namespace, this.isEnabled(), topicListener, this);
            topics.put(namespace, name, topic);
         }
      }
      return topic;
   }

   /**
    * This method deletes a <code>Topic</code> previously created by this <code>DomainParticipant</code>. No action will
    * be taken if the topic still has data readers/writers attached to it, or if it was not created by this
    * <code>DomainParticipant</code>.
    * 
    * @param topic The topic to delete.
    * @return {@link ReturnCode#OK}if the topic was successfully removed, {@link ReturnCode#PRECONDITION_NOT_MET}if the
    * topic has readers/writers or was not created by this DomainParticipant, {@link ReturnCode#NOT_ENABLED}if this
    * DomainParticipant is not enabled, or {@link ReturnCode#ERROR}.
    */
   public ReturnCode deleteTopic(Topic topic) {

      // Check that the Entity is enabled before proceeding (See description of enable on the Entity object in the DDS spec)
      if (!isEnabled()) {
         return ReturnCode.NOT_ENABLED;
      }

      // Check the pre-condition
      if (topic.hasDataReaders()) {
         return ReturnCode.PRECONDITION_NOT_MET;
      }
      // Check the pre-condition
      if (topic.hasDataWriters()) {
         return ReturnCode.PRECONDITION_NOT_MET;
      }

      // Check that a topic was supplied
      if (topic == null) {
         return ReturnCode.ERROR;
      }

      // Attempt to remove, if it did not exist in our list then return an error,
      // since it can only be removed from the <code>DomainParticipant</code> which created it.
      if (topics.containsKey(topic.getNamespace() + topic.getName())) {
         // Reduce the count of creations by 1
         topic.decrementCount();

         // If the creation count is zero, then remove it from the list
         if (topic.getCount() <= 0) {
            topics.removeValues(topic.getNamespace() + topic.getName());
         }

         return ReturnCode.OK;
      } else {
         return ReturnCode.PRECONDITION_NOT_MET;
      }
   }

   /**
    * Get a <code>TopicDescription</code> that matches a particular name. PARTIAL: Since the
    * <code>ContentFilteredTopic</code> and <code>MultiTopic</code> classes are not implemented, this method simply
    * searches the list of <code>Topic</code> classes.
    * 
    * @param namespace The name to match against the <code>TopicDescription</code>.
    * @return The <code>TopicDescription</code> that has the specified name, <b>null </b> if no such one exists.
    */
   public TopicDescription lookupTopicDescription(String namespace, String topic) {
      //PARTIAL ContentFilteredTopic and MultiTopic are not implemented, so this only searches Topic.
      return findTopicByName(namespace, topic);
   }

   /**
    * Searches the current list of Topics for this DomainParticipant for a topic whose name matches the provided
    * topicName
    * 
    * @param topicName The topic name to match
    * @return A reference to the existing topic whose name matches topicName, or null if no such topic exists.
    */
   private Topic findTopicByName(String namespace, String topicName) {
      return topics.get(namespace, topicName);
   }

   /**
    * This method is here for future functionality that is described in the DDS specification but has not been
    * implemented or used.
    * 
    * @return {@link ReturnCode#OK}if the participant was successfully set to be ignored, {@link ReturnCode#NOT_ENABLED}
    * if this DomainParticipant is not enabled, or {@link ReturnCode#ERROR}.
    */
   public ReturnCode ignoreParticipant() {
      // UNSURE this is stubbed for now, until we determine it's necessity

      // Check that the Entity is enabled before proceeding (See description of enable on the Entity object in the DDS spec)
      if (!isEnabled()) {
         return ReturnCode.NOT_ENABLED;
      }

      return ReturnCode.ERROR;
   }

   /**
    * This method is here for future functionality that is described in the DDS specification but has not been
    * implemented or used.
    * 
    * @return {@link ReturnCode#OK}if the topic was successfully set to be ignored, {@link ReturnCode#NOT_ENABLED}if
    * this DomainParticipant is not enabled, or {@link ReturnCode#ERROR}.
    */
   public ReturnCode ignoreTopic() {
      // UNSURE This method has not been implemented, but is called out in the spec
      if (true) {
         throw new NotImplementedException();
      }

      // Check that the Entity is enabled before proceeding (See description of enable on the Entity object in the DDS spec)
      if (!isEnabled()) {
         return ReturnCode.NOT_ENABLED;
      }

      return ReturnCode.ERROR;
   }

   /**
    * This method is here for future functionality that is described in the DDS specification but has not been
    * implemented or used.
    * 
    * @return {@link ReturnCode#OK}if the publication was successfully set to be ignored, {@link ReturnCode#NOT_ENABLED}
    * if this DomainParticipant is not enabled, or {@link ReturnCode#ERROR}.
    */
   public ReturnCode ignorePublication() {
      // UNSURE This method has not been implemented, but is called out in the spec
      if (true) {
         throw new NotImplementedException();
      }

      // Check that the Entity is enabled before proceeding (See description of enable on the Entity object in the DDS spec)
      if (!isEnabled()) {
         return ReturnCode.NOT_ENABLED;
      }

      return ReturnCode.ERROR;
   }

   /**
    * This method is here for future functionality that is described in the DDS specification but has not been
    * implemented or used.
    * 
    * @return {@link ReturnCode#OK}if the subscription was successfully set to be ignored,
    * {@link ReturnCode#NOT_ENABLED}if this DomainParticipant is not enabled, or {@link ReturnCode#ERROR}.
    */
   public ReturnCode ignoreSubscription() {
      // UNSURE This method has not been implemented, but is called out in the spec
      if (true) {
         throw new NotImplementedException();
      }

      // Check that the Entity is enabled before proceeding (See description of enable on the Entity object in the DDS spec)
      if (!isEnabled()) {
         return ReturnCode.NOT_ENABLED;
      }

      return ReturnCode.ERROR;
   }

   /**
    * Gets the <code>DomainId</code> that this <code>DomainParticipant</code> belongs to.
    * 
    * @return The <code>DomainId</code> of this participant.
    */
   public DomainId getDomainId() {
      return domainId;
   }

   /**
    * Performs a deep deletion of contained entities (Publishers, Subscribers, Topics). This will cause a recursive call
    * of <code>deleteContainedEntities</code> through out all of the contained entities. This can only be performed if
    * the <code>DomainParticipant</code> is enabled.
    * 
    * @return {@link ReturnCode#OK}if the all entities were successfully deleted, or {@link ReturnCode#NOT_ENABLED}if
    * this DomainParticipant is not enabled.
    */
   public ReturnCode deleteContainedEntities() {

      // Check that the Entity is enabled before proceeding (See description of enable on the Entity object in the DDS spec)
      if (!isEnabled()) {
         return ReturnCode.NOT_ENABLED;
      }

      for (Publisher publisher : publishers) {
         publisher.deleteContainedEntities();
      }
      publishers.clear();

      for (Subscriber subscriber : subscribers) {
         subscriber.deleteContainedEntities();
      }

      subscribers.clear();

      this.middlewarePublisher = null;

      // Topics do not contain anything else
      topics.clear();

      return ReturnCode.OK;
   }

   /**
    * This method is here for future functionality that is described in the DDS specification but has not been
    * implemented or used.
    */
   public void assertLiveliness() {
      // UNSURE This method has not been implemented, but is called out in the spec
      if (true) {
         throw new NotImplementedException();
      }
   }

   /**
    * Returns true iff this <code>DomainParticipant</code> contains at least one publisher, subscriber or topic.
    * 
    * @return <b>true </b> if this contains an entity, <b>false </b> otherwise.
    */
   public boolean hasEntities() {
      return !(publishers.isEmpty() && subscribers.isEmpty() && topics.isEmpty());
   }

   /**
    * Propagates the published data to each <code>Subscriber</code> of this <code>DomainParticipant</code>. Notifies the
    * middleware (by means of the {@link DomainParticipantListener}of the new data unless it originated from the
    * middlewarePublisher. The middleware is only notified of data originating from this <code>DomainPariticipant</code>
    * , that is, data published from other participants in the domain will not be sent to the middleware.
    * 
    * @param destination TODO
    * @param source TODO
    * @param dataStoreItem The <code>DataStoreItem</code> that was published.
    */
   void processPublishedData(IDestination destination, ISource source, DataStoreItem dataStoreItem) { // package scope since it is a
      // system-level call

      // Notify the middleware of new data, unless it was published by the middlewarePublisher
      // When data is published by the middlewarePublisher it does not have an associated DataWriter

      DataWriter writer = dataStoreItem.getTheWriter();
      if (writer != null) {
         // Invoke the DomainParticipantListener if available
         DomainParticipantListener domainParticipantListener = getListener();
         if (domainParticipantListener != null) {
            domainParticipantListener.onPublishNotifyMiddleware(destination, source, dataStoreItem);
         }

         // If the writer has a listener, then invoke it
         DataWriterListener writerListener = writer.getListener();
         if (writerListener != null) {
            writerListener.onDataSentToMiddleware(writer);
         }

      }

      if (writer == null || writer != null && writer.isPublishBackToLocalDDSReaders()) {
         // Notify all of the subscribers in our domain
         for (Subscriber domainSubscribers : subscribers) {
            domainSubscribers.processNewData(dataStoreItem);
         }
      }
   }

   /**
    * Gets the <code>TypeRegistry</code> used by {@link TypeSupport}to store the types registered for this
    * <code>DomainParticipant</code>.
    * 
    * @return Returns the typeRegistry.
    */
   public TypeRegistry getTypeRegistry() {
      return typeRegistry;
   }

   /**
    * Gets the Middleware <code>Publisher</code> if one has been created.
    * 
    * @return Returns the <code>Publisher</code> for the middleware, or null if it has not been created.
    * @see DomainParticipant
    */
   public Publisher getMiddlewarePublisher() {
      return middlewarePublisher;
   }

   /**
    * Gets the current <code>Collection</code> of <code>Publisher</code>'s for this <code>DomainPariticpant</code>.
    * 
    * @return Returns the <code>Collection</code> of <code>Publisher</code> 's.
    */
   public CopyOnWriteArrayList<Publisher> getPublishers() {
      return publishers;
   }

   public void dispose() {
      for (Topic topic : topics.values()) {
         topic.clearDataReaders();
         topic.clearDataWriters();
      }
      topics.clear();
      for (Subscriber subscriber : subscribers) {
         if (subscriber.deleteContainedEntities() == ReturnCode.NOT_ENABLED) {
            System.err.println("failed to delete subscriber because it was not enabled");
         }
      }
      subscribers.clear();

      for (Publisher publisher : publishers) {
         publisher.dispose();
      }
      publishers.clear();

      typeRegistry.clear();
   }
}