#include "context.hpp"

#include "attribute_template_impl.hpp"
#include "object_template_impl.hpp"
#include "group_template_impl.hpp"

namespace xmlioserver
{
   namespace tree
   {
      /// ////////////////////// Définitions ////////////////////// ///

      CContext::CContext(void)
         : CObjectTemplate<CContext>(), CContextAttributes()
      { /* Ne rien faire de plus */ }

      CContext::CContext(const StdString & id)
         : CObjectTemplate<CContext>(id), CContextAttributes()
      { /* Ne rien faire de plus */ }

      CContext::~CContext(void)
      { /* Ne rien faire de plus */ }

      StdString CContext::GetName(void)   { return (StdString("context")); }
      StdString CContext::GetDefName(void){ return (CContext::GetName()); }

      boost::shared_ptr<CContextGroup> CContext::GetContextGroup(void)
      {  static boost::shared_ptr<CContextGroup> group_context
                             (new CContextGroup(xml::CXMLNode::GetRootName()));
         return (group_context); }

      void CContext::parse(xml::CXMLNode & node)
      {
         CContext::SuperClass::parse(node);

         // PARSING POUR GESTION DES ENFANTS
         xml::THashAttributes attributes;

         if (node.getElementName().compare(CContext::GetName()))
            DEBUG("Le noeud est mal nommé mais sera traité comme un contexte !");

         if (!(node.goToChildElement()))
         {
            DEBUG("Le context ne contient pas d'enfant !");
         }
         else
         {
            do { // Parcours des contextes pour traitement.

               StdString name = node.getElementName();
               attributes.clear();
               attributes = node.getAttributes();

               if (attributes.end() != attributes.find("id"))
               { DEBUG(<< "Le noeud de définition possède un identifiant,"
                       << " ce dernier ne sera pas pris en compte lors du traitement !"); }

#define DECLARE_NODE(Name_, name_)    \
   if (name.compare(C##Name_##Definition::GetDefName()) == 0) \
   { CObjectFactory::CreateObject<C##Name_##Definition>(C##Name_##Definition::GetDefName()) -> parse(node); \
      continue; }
#define DECLARE_NODE_PAR(Name_, name_)
#include "../config/node_type.conf"

               DEBUG(<< "L'élément nommé \'"     << name
                     << "\' dans le contexte \'" << CObjectFactory::GetCurrentContextId()
                     << "\' ne représente pas une définition !");

            } while (node.goToNextElement());

            node.goToParentElement(); // Retour au parent
         }
      }

      void CContext::ShowTree(StdOStream & out)
      {
         StdString currentContextId =
            CObjectFactory::GetCurrentContextId();
         std::vector<boost::shared_ptr<CContext> > def_vector =
             CContext::GetContextGroup()->getChildList();

         out << "<? xml version=\"1.0\" ?>" << std::endl;
         out << "< "  << xml::CXMLNode::GetRootName() << " >" << std::endl;
         BOOST_FOREACH(boost::shared_ptr<CContext> context, def_vector)
         {
            CObjectFactory::SetCurrentContextId(context->getId());
            CGroupFactory::SetCurrentContextId(context->getId());
            out << *context << std::endl;

         }
         out << "</ " << xml::CXMLNode::GetRootName() << " >" << std::endl;

         CObjectFactory::SetCurrentContextId(currentContextId);
          CGroupFactory::SetCurrentContextId(currentContextId);
      }

      StdString CContext::toString(void) const
      {
         StdOStringStream oss;
         oss << "< " << CContext::GetName()
             << " id=\"" << this->getId() << "\" "
             << SuperClassAttribute::toString() << ">" << std::endl;
         if (!this->hasChild())
         {
            //oss << "<!-- No definition -->" << std::endl; // fait planter l'incrémentation
         }
         else
         {

#define DECLARE_NODE(Name_, name_)    \
   if (CObjectFactory::HasObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())) \
      oss << *CObjectFactory::GetObject<C##Name_##Definition>(C##Name_##Definition::GetDefName()) << std::endl;
#define DECLARE_NODE_PAR(Name_, name_)
#include "../config/node_type.conf"

         }

         oss << "</ " << CContext::GetName() << " >";

         return (oss.str());
      }

      void CContext::solveDescInheritance(const CAttributeMap * const UNUSED(parent))
      {
#define DECLARE_NODE(Name_, name_)    \
   if (CObjectFactory::HasObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())) \
      CObjectFactory::GetObject<C##Name_##Definition>(C##Name_##Definition::GetDefName())->solveDescInheritance();
#define DECLARE_NODE_PAR(Name_, name_)
#include "../config/node_type.conf"
      }

      bool CContext::hasChild(void) const
      {
         return (false ||
#define DECLARE_NODE(Name_, name_)    \
   CObjectFactory::HasObject<C##Name_##Definition>  (C##Name_##Definition::GetDefName())   ||
#define DECLARE_NODE_PAR(Name_, name_)
#include "../config/node_type.conf"
         false);
      }

      void CContext::solveFieldRefInheritance(void)
      {
         if (!this->hasId()) return;
         std::vector<boost::shared_ptr<CField> > allField
                  = CObjectTemplate<CField>::GetAllVectobject(this->getId());
         BOOST_FOREACH(boost::shared_ptr<CField> field, allField)
            field->solveRefInheritance();
      }

   } // namespace tree
} // namespace xmlioserver