#ifndef __XMLIO_OBJECT_TEMPLATE__
#define __XMLIO_OBJECT_TEMPLATE__

#include "declare_attribut.hpp"
#include "attribut_registrar.hpp"

// Classes utilisées issues de la STL
using std::pair;
using std::string;
using std::ostream;

using XMLIOSERVER::StrHashMap;

using XMLIOSERVER::XML::XMLNode;
using XMLIOSERVER::XML::THashAttributes;

namespace XMLIOSERVER
{
   template <class T>
      class ObjectTemplate : public AbstractObject, public virtual AttributRegistrar
   {
      public :

         friend ostream& operator<< (ostream& out, const T& c)
         {
            const AttributRegistrar &ar = c;

            if (c.baseObject != NULL)
               out <<  IncIndent << "<-- Référence résolu sur l'instance de "<< T::GetName()
                   <<   " nommée \"" << c.baseObject->getId() << "\" -->" << DecEndl << std::endl;

            if (c.isDefinition())
            {
               out << NIndent << std::endl;
               out << NIndent << "<!-- Groupe de définition dans le contexte \"" << ObjectTemplate<T>::GetCurrentContextId() << "\" courant -->" << std::endl;
            }

            if (c.hasChild())
            {
               out << IncIndent  << "<"  << c.getName()  << c.printId() << ar << ">" << std::endl;
               c.printChild(out); // << Ecriture des objets enfants ici.
               if (c.hasId() && (c.getName().compare("context") == 0))
                  out << NIndent << std::endl;
               out << NIndent    << "</" << c.getName()  << ">" << DecEndl;
            }
            else
               out << IncIndent << "<" << c.getName()  << c.printId() << ar << "/>" << DecEndl;

            return (out);
         }

         bool isDefinition(void) const
         {
            if (!this->hasId()) return (false);
            return (this->getName().compare(this->getId()) == 0);
         }

         string getName(void) const
         {
            if (this->hasId())
               if (T::GetDefName().compare(getId()) == 0)
                  return (T::GetDefName());
            return (T::GetName());
         }

         T* getBaseObject(void) const { return (baseObject); }

         const vector<T*>& getVectRefObject(void) const { return (refObject); }

         bool hasRefObject(void) const { return (!refObject.empty()); }

         const T* addRefObject(T* obj)
         { refObject.push_back (obj); return (obj); }

      public : /* virtual */

         virtual T* getReference(void) const { return (NULL); }
         virtual bool hasChild(void) const { return (false); }

         virtual void printChild(ostream& out) const
         { out << NIndent << "<!-- No child -->" << std::endl; }

         virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0)
         { this->addAttributes(*_parent); }

         virtual void resolveRefInheritance (void)
         {
            std::set<T*> sset;
            T* refer = (T*)this;
            // On remonte le fil des héritages par référence.
            while((refer = refer->getReference()) != NULL)
            {
               if(sset.end() != sset.find(refer))
               { WARNING ("Dépendance circulaire stoppée pour l'objet de type "+T::GetName()+" sur \""+refer->getId()+"\" !"); break; }
               addAttributes(*refer);
               sset.insert(baseObject = refer);
            }
         }

         virtual void parse (XMLNode& _node)
         {
            string name = _node.getElementName();
            THashAttributes attributes;

            /// PARSING GESTION DES ATTRIBUTS ///
            _node.getAttributes(attributes);
            this->setAttributes(attributes);
            attributes.clear();

            /// PARSING POUR GESION DES ENFANTS ///
            // Rien à faire ici.
         }

         virtual ~ObjectTemplate(void)
         {/* Ne rien faire de plus */}

      public : /* static */

         static T* CreateObject(const string& _id) throw (XMLIOUndefinedValueException)
         {
            // Si l'identifiant est répertorié, on retourne l'élément existant.
            if(ObjectTemplate<T>::HasObject(_id))
               return (ObjectTemplate<T>::GetObject(_id));

            // Ajout d'un nouvel objet si l'identifiant n'est pas répertorié.
            ObjectTemplate<T>::AllListObj[CurrContext].addObject(new T(_id));

            return (ObjectTemplate<T>::GetObject(_id));
         }

         static T* CreateObject(void)
         {
            T* value = new T;
            ObjectTemplate<T>::AllListObj[CurrContext].addObject(value);
            return (value);
         }

         static T* GetObject(const string& _id) throw (XMLIOUndefinedValueException)
         { return (ObjectTemplate<T>::AllListObj[CurrContext][_id]); }

         static bool HasObject(const string& _id)
         {
            if(ObjectTemplate<T>::AllListObj.find(CurrContext) ==
               ObjectTemplate<T>::AllListObj.end())
               return (false);
            return (ObjectTemplate<T>::AllListObj[CurrContext].hasMappedValue(_id));
         }

         static const StrHashMap<T>& GetCurrentListObject(void) { return (AllListObj[CurrContext]); }
         static Poco::HashMap<string, StrHashMap<T> >& GetAllListObject(void) { return (AllListObj); }

         static void SetContext(const string& id) { ObjectTemplate<T>::CurrContext = id; }

         static string& GetCurrentContextId(void) { return (ObjectTemplate<T>::CurrContext); }

      protected :

         ObjectTemplate(void)
            : AttributRegistrar(), AbstractObject(), baseObject(NULL), refObject()
         { /* Ne rien faire de plus */ }

         ObjectTemplate(const string& _id)
            : AttributRegistrar(), AbstractObject(_id), baseObject(NULL), refObject()
         { /* Ne rien faire de plus */ }

         ObjectTemplate(const ObjectTemplate<T>& _ot, bool _withAttrList = true, bool _withId = true)
            : AttributRegistrar(), AbstractObject(), baseObject(_ot.baseObject), refObject(_ot.refObject)
         {
            // Si requis, ajout de l'identifiant lors de la copie.
            if (_ot.hasId() && _withId) this->setId(_ot.getId());
            // Si requis, ajout des attributs lors de la copie.
            if (_withAttrList) this->addAttributes(_ot);
         }

         XML::XMLNode getNodeIncludedFile(const string& path, const string& _rootName)
         {
            ifstream istr( path.c_str() , ifstream::in );
            return (XML::XMLNode::CreateNode(istr, _rootName));
         }

         template <class V> static V* CreateInstanceAndParse(XMLNode& _node, const char* defaultId, bool parseAttr = true )
         {
            V* instance_ptr = NULL; string did(defaultId);
            if (defaultId != NULL)
            {
               if (V::HasObject(did))
                  WARNING("Le noeud nommé \""+ did +"\" existe déjà pour les instances de type "+
                           V::GetName()+", le dernier défini complétera le premier dans le context actuel!");
               instance_ptr = (V*)V::CreateObject(did);
               instance_ptr->parse(_node, parseAttr);
            }
            return (instance_ptr);
         }

      private :

         T* baseObject;
         std::vector<T*> refObject;

      private : /* static */

         static string CurrContext;
         static Poco::HashMap<string, StrHashMap<T> > AllListObj;

   };// class ObjectTemplate

   // Initialisation des variables statiques de la classe ObjectTemplate.
   template <class T> string ObjectTemplate<T>::CurrContext ;
   template <class T> Poco::HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj;

}// namespace XMLIOSERVER

#endif // __XMLIO_OBJECT_TEMPLATE__