#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_COMPONENTSET_H
#define NUCLEX_SCENE_GRAPH_COMPONENTSET_H

#include "Nuclex/Scene/Config.h"

#include <typeinfo>
#include <vector>
#include <memory>
#include <functional>
#include <cassert>

namespace Nuclex { namespace Scene { namespace Graph {

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

  /// <summary>Stores the components added to an entity</summary>
  class ComponentSet {

    #pragma region struct TypeComponentPair

    /// <summary>Stores a component and its type</summary>
    private: struct TypeComponentPair {

      /// <summary>Initializes a new type/component pair</summary>
      /// <param name="type">Type of component the pair is storing</param>
      /// <param name="component">Component being stored<param>
      /// <param name="deleter">Function that will be used to delete the component</param>
      public: NUCLEX_SCENE_API TypeComponentPair(
        const std::type_info &type, void *component, const std::function<void(void *)> &deleter
      ) : Type(&type), Component(component), deleter(deleter) {}

      /// <summary>Constructs a new instance by taking over another instance</summary>
      /// <param name="other">Other instance that will be taken over</param>
      public: NUCLEX_SCENE_API TypeComponentPair(TypeComponentPair &&other) :
        Type(other.Type),
        Component(other.Component),
        deleter([](void *) {}) {
        std::swap(this->deleter, other.deleter);
      }

      /// <summary>Moves the contents of another instance into this instance</summary>
      /// <param name="other">Other instance that will be moved into this one</param>
      /// <returns>This instance</returns>
      public: NUCLEX_SCENE_API TypeComponentPair &operator =(TypeComponentPair &&other) {
        this->deleter(this->Component);
        this->Type = other.Type;
        this->Component = other.Component;
        this->deleter = other.deleter;
        other.deleter = [](void *) {};

        return *this;
      }

      /// <summary>Destroys a new type/component pair, deleting the component</summarx>
      public: NUCLEX_SCENE_API ~TypeComponentPair() {
        this->deleter;
      }

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

      /// <summary>Type the container is storing</summary>
      public: const std::type_info *Type;
      /// <summary>Component stored by the container</summary>
      public: void *Component;

      /// <summary>Whether this component is built-in and must not be deleted</summary>
      private: std::function<void(void *)> deleter;

    };

    #pragma endregion // struct TypeComponentPair

    #pragma region class Iterator

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

      /// <summary>Initializes a new component type iterator</summary>
      /// <param name="componentSet">Component set whose types will be enumerated</param>
      /// <param name="index">Index the iterator will be placed at</param>
      public: NUCLEX_SCENE_API Iterator(const ComponentSet &componentSet, std::size_t index = 0) :
        componentSet(&componentSet),
        index(index) {}

      /// <summary>Initializes a component type 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) :
        componentSet(other.componentSet),
        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->componentSet == other.componentSet) &&
          "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 type of the component at the enumerator's current position</returns>
      public: NUCLEX_SCENE_API const std::type_info &operator *() {
        using namespace std;
        assert(
          (this->index < this->componentSet->components.size()) &&
          "Iterator must be on a valid position to be dereferenced"
        );

        return *this->componentSet->components[this->index].Type;
      }

      /// <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->componentSet = other.componentSet;
        this->index = other.index;
        return *this;
      }

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

    };

    #pragma endregion // class Iterator

    /// <summary>Initializes a new component set</summary>
    public: NUCLEX_SCENE_API ComponentSet() {}

    /// <summary>Destroys the component set, deleting all its components</summary>
    public: NUCLEX_SCENE_API ~ComponentSet() {}

    /// <summary>Adds a new component to the entity</summary>
    /// <typeparam name="TComponent">Type of component that will be added</typeparam>
    /// <param name="component">Component that will be added</param>
    public: template<typename TComponent> void Add(std::unique_ptr<TComponent> component) {
      Add(
        typeid(TComponent),
        component.release(),
        [](void *component) { delete static_cast<TComponent *>(component); }
      );
    }

    /// <summary>Adds a new component to the entity</summary>
    /// <typeparam name="TComponent">Type of component that will be added</typeparam>
    /// <param name="component">Component that will be added</param>
    /// <param name="deleter">Function that will be used to delete the component</param>
    public: NUCLEX_SCENE_API void Add(
      const std::type_info &componentType,
      void *component,
      const std::function<void(void *)> &deleter
    ) {
      this->components.push_back(
        TypeComponentPair(componentType, component, deleter)
      );
    }

    /// <summary>Removes the component of the specified type from the entity</summary>
    /// <typeparam name="TComponent">Type of component that will be removed</typeparam>
    /// <returns>True if the component was present and has been removed</returns>
    public: template<typename TComponent> bool Remove() {
      return Remove(typeid(TComponent));
    }

    /// <summary>Removes the component of the specified type from the entity</summary>
    /// <param name="componentType">Type of component that will be removed</typeparam>
    /// <returns>True if the component was present and has been removed</returns>
    public: NUCLEX_SCENE_API bool Remove(const std::type_info &componentType) {
      for(std::size_t index = 0; index < this->components.size(); ++index) {
        if(*this->components[index].Type == componentType) {
          this->components.erase(this->components.begin() + index);
          return true;
        }
      }

      return false;
    }

    /// <summary>Accesses the component of the specified type</summary>
    /// <typeparam name="TComponent">Type of component that will be accessed</typeparam>
    /// <returns>A reference to the specified component</return>
    public: template<typename TComponent> TComponent &Access() {
      void *component = Access(typeid(TComponent));
      return *static_cast<TComponent *>(component);
    }

    /// <summary>Accesses the component of the specified type</summary>
    /// <typeparam name="TComponent">Type of component that will be accessed</typeparam>
    /// <returns>A reference to the specified component</return>
    public: template<typename TComponent> const TComponent &Access() const {
      const void *component = Access(typeid(TComponent));
      return *static_cast<const TComponent *>(component);
    }

    /// <summary>Accesses the component of the specified type</summary>
    /// <typeparam name="TComponent">Type of component that will be accessed</typeparam>
    /// <returns>A reference to the specified component</return>
    public: NUCLEX_SCENE_API void *Access(const std::type_info &componentType) {
      for(std::size_t index = 0; index < this->components.size(); ++index) {
        if(*this->components[index].Type == componentType) {
          return this->components[index].Component;
        }
      }
      
      throw std::exception("Entity does not have the requested component");
    }

    /// <summary>Accesses the component of the specified type</summary>
    /// <typeparam name="TComponent">Type of component that will be accessed</typeparam>
    /// <returns>A reference to the specified component</return>
    public: NUCLEX_SCENE_API const void *Access(const std::type_info &componentType) const {
      for(std::size_t index = 0; index < this->components.size(); ++index) {
        if(*this->components[index].Type == componentType) {
          return this->components[index].Component;
        }
      }
      
      throw std::exception("Entity does not have the requested component");
    }

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

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

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

    /// <summary>List holding type/component pairs</summary>
    private: typedef std::vector<TypeComponentPair> ComponentList;

    /// <summary>Stores the components in the component set</summary>
    private: ComponentList components;

  };

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

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

#endif // NUCLEX_SCENE_GRAPH_COMPONENTSET_H