#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2013 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_SCENE_GRAPH_CHILDENTITYSET_H
#define NUCLEX_SCENE_GRAPH_CHILDENTITYSET_H

#include "Nuclex/Scene/Config.h"

#include <vector>
#include <memory>
#include <cassert>

namespace Nuclex { namespace Scene { namespace Graph {

  // ------------------------------------------------------------------------------------------- //

  class Entity;

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Stores an entities children</summary>
  class ChildEntitySet {

    #pragma region class Iterator

    /// <summary>Iterates over the entities in the set</summary>
    public: class Iterator {

      /// <summary>Initializes a new entity iterator</summary>
      /// <param name="childEntitySet">Child entity set that will be enumerated</param>
      /// <param name="index">Index the iterator will be placed at</param>
      public: NUCLEX_SCENE_API Iterator(
        const ChildEntitySet &childEntitySet, std::size_t index = 0
      ) :
        childEntitySet(&childEntitySet),
        index(index) {}

      /// <summary>Initializes an iterator as copy of another iterator</summary>
      /// <param name="other">Other iterator that will be copied</param>
      public: NUCLEX_SCENE_API Iterator(const Iterator &other) :
        childEntitySet(other.childEntitySet),
        index(other.index) {}

      /// <summary>Tests whether another iterator is at a different position</summary>
      /// <param name="other">Other iterator that will be compared</param>
      /// <returns>True if the other iterator is at a different position</returns>
      public: NUCLEX_SCENE_API bool operator !=(const Iterator &other) {
        using namespace std;
        assert(
          (this->childEntitySet == other.childEntitySet) &&
          "Compared iterators must belong to the same component set"
        );

        return this->index != other.index;
      }

      /// <summary>Advances the iterator to the next position</summary>
      /// <returns>The iterator itself after incrementing</returns>
      public: NUCLEX_SCENE_API Iterator &operator ++() {
        ++this->index;
        return *this;
      }

      /// <summary>Accesses the element at the iterator's current position</summary>
      /// <returns>The entity at the enumerator's current position</returns>
      public: NUCLEX_SCENE_API const std::shared_ptr<Entity> &operator *() {
        using namespace std;
        assert(
          (this->index < this->childEntitySet->entities.size()) &&
          "Iterator must be on a valid position to be dereferenced"
        );

        return this->childEntitySet->entities[this->index];
      }

      /// <summary>Accesses the element at the iterator's current position</summary>
      /// <returns>The type of the component at the enumerator's current position</returns>
      public: NUCLEX_SCENE_API Iterator &operator =(const Iterator &other) {
        this->childEntitySet = other.childEntitySet;
        this->index = other.index;
        return *this;
      }

      /// <summary>Component set whose types the iterator is iterating over</summary>      
      private: const ChildEntitySet *childEntitySet;
      /// <summary>Current position of the enumerator</summary>      
      private: std::size_t index;

    };

    #pragma endregion // class Iterator

    /// <summary>Initializes a new child entity set</summary>
    /// <param name="parent">Parent that will be assigned to all children</param>
    public: NUCLEX_SCENE_API ChildEntitySet(Entity &parent) :
      parent(parent) {}

    /// <summary>Adds the specified child to the set</summary>
    /// <param name="child">Child that will be added to the set</param>
    public: NUCLEX_SCENE_API void Add(const std::shared_ptr<Entity> &child);

    /// <summary>Removes the specified child from the set</summary>
    /// <param name="child">Child that will be removed from the set</param>
    /// <returns>True if the child was found and has been removed, otherwise false</returns>
    public: NUCLEX_SCENE_API bool Remove(const std::shared_ptr<Entity> &child);

    /// <summary>Returns the number of child entities in the set</summary>
    public: NUCLEX_SCENE_API std::size_t Count() const {
      return this->entities.size();
    }

    /// <summary>An iterator pointing to the first entry in the entity list</summary>
    public: NUCLEX_SCENE_API Iterator begin() {
      return Iterator(*this);
    }

    /// <summary>An iterator pointing one past the end of the entity list</summary>
    public: NUCLEX_SCENE_API Iterator end() {
      return Iterator(*this, this->entities.size());
    }

    private: ChildEntitySet(const ChildEntitySet &);
    private: ChildEntitySet &operator =(const ChildEntitySet &);

    /// <summary>List holding child entities</summary>
    private: typedef std::vector<std::shared_ptr<Entity>> EntityList;

    /// <summary>Parent the children will have assigned</summary>
    private: Entity &parent;
    /// <summary>Stores the child entities</summary>
    private: EntityList entities;

  };

  // ------------------------------------------------------------------------------------------- //

}}} // namespace Nuclex::Scene::Graph

#endif // NUCLEX_SCENE_GRAPH_CHILDENTITYSET_H