#ifndef __XMLIO_CObjectTemplate_impl__
#define __XMLIO_CObjectTemplate_impl__

#include "object_factory.hpp"
#include "context.hpp"
#include "buffer_in.hpp"
#include "attribute.hpp"
#include "event_client.hpp"
#include "context_client.hpp"
#include "object_template.hpp"

namespace xmlioserver
{
   /// ////////////////////// Définitions ////////////////////// ///
   template <class T>
      xios_map<StdString,
      xios_map<StdString,
      boost::shared_ptr<T> > > CObjectTemplate<T>::AllMapObj;

   template <class T>
      xios_map<StdString,
      std::vector<boost::shared_ptr<T> > > CObjectTemplate<T>::AllVectObj;

   template <class T>
      xios_map<StdString,long int> CObjectTemplate<T>::GenId;

   template <class T>
      CObjectTemplate<T>::CObjectTemplate(void)
         : tree::CAttributeMap()
         , CObject()
   { /* Ne rien faire de plus */ }

   template <class T>
      CObjectTemplate<T>::CObjectTemplate(const StdString & id)
         : tree::CAttributeMap()
         , CObject(id)
   { /* Ne rien faire de plus */ }

   template <class T>
      CObjectTemplate<T>::CObjectTemplate
         (const CObjectTemplate<T> & object, bool withAttrList, bool withId)
         : tree::CAttributeMap()
         , CObject()
   {
      if (object.hasId() && withId)
         this->setId(object.getId());
      ERROR("CObjectTemplate<T> construtor 3", << "Not completly implemented yet !");
   }
   
   template <class T>
      CObjectTemplate<T>::~CObjectTemplate(void)
   { /* Ne rien faire de plus */ }

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

   template <class T>
      std::vector<boost::shared_ptr<T> > &
         CObjectTemplate<T>::GetAllVectobject(const StdString & contextId)
   { 
      return (CObjectTemplate<T>::AllVectObj[contextId]); 
   }
   
   //---------------------------------------------------------------
   
   template <class T>
      StdString CObjectTemplate<T>::toString(void) const
   {
      StdOStringStream oss;
      oss << "<" << T::GetName();
      if (this->hasId())
         oss << " id=\"" << this->getId() << "\"";
      oss << " " << SuperClassMap::toString() << "/>";
      return (oss.str());
   }

   template <class T>
      void CObjectTemplate<T>::fromString(const StdString & str)
   { 
      ERROR("CObjectTemplate<T>::fromString(str)",
            << "[ str = " << str << "] Not implemented yet !"); 
   }
   
   //---------------------------------------------------------------
   
   template <class T>
      void CObjectTemplate<T>::toBinary(StdOStream & os) const
   {
      SuperClassMap::toBinary(os);    
   }
      
   template <class T>
      void CObjectTemplate<T>::fromBinary(StdIStream & is)
   {
      SuperClassMap::fromBinary(is); 
   }
   
   //---------------------------------------------------------------

   template <class T>
      void CObjectTemplate<T>::parse(xml::CXMLNode & node)
   {
      xml::THashAttributes attributes = node.getAttributes();
      CAttributeMap::setAttributes(attributes);
   }

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

   template <class T>
      tree::ENodeType CObjectTemplate<T>::getType(void) const
   {
      return (T::GetType());
   }
  
   template <class T>
   string CObjectTemplate<T>::getName(void) const
   {
      return (T::GetName());
   }
  
   //---------------------------------------------------------------

   template <class T>
      bool CObjectTemplate<T>::hasChild(void) const
   { 
      return (false); 
   }

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

   template <class T>
      void CObjectTemplate<T>::solveDescInheritance(const CAttributeMap * const parent)
   { 
      SuperClassMap::setAttributes(parent); 
   }

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

   template <class T>
      void CObjectTemplate<T>::ClearAllAttributes(void)
   {
      std::vector<boost::shared_ptr<T> > & avect =
         CObjectTemplate<T>::GetAllVectobject(CObjectFactory::GetCurrentContextId());
      typename std::vector<boost::shared_ptr<T> >::iterator
            it = avect.begin(), end = avect.end();

      for (;it != end; it++)
      {
         CAttributeMap & amap = **it;
         amap.clearAllAttributes();
      }
   }

   template <class T>
   void CObjectTemplate<T>::sendAttributToServer(const string& id)
   {
      CAttributeMap & attrMap = *this;
      CAttribute* attr=attrMap[id] ;
      sendAttributToServer(*attr) ;
   }

   template <class T>
   void CObjectTemplate<T>::sendAttributToServer(tree::CAttribute& attr)
   {
     shared_ptr<CContext> context=CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId()) ;
     
    if (!context->hasServer)
    {
       CContextClient* client=context->client ;

       CEventClient event(getType(),EVENT_ID_SEND_ATTRIBUTE) ;   
       if (client->isServerLeader())
       {
         CMessage msg ;
         msg<<this->getId() ;
         msg<<attr.getName() ;
         msg<<attr ;
         event.push(client->getServerLeader(),1,msg) ;
         client->sendEvent(event) ;
       }
       else client->sendEvent(event) ;
    }
      
   }
   
   template <class T>
   void CObjectTemplate<T>::recvAttributFromClient(CEventServer& event)
   {
      
      CBufferIn* buffer=event.subEvents.begin()->buffer;
      string id,attrId;
      *buffer>>id ;
      CAttributeMap & attrMap = *get(id);
      *buffer>>attrId ;
      CAttribute* attr=attrMap[attrId] ;
      info(50)<<"attribut recu "<<attrId<<"  " ;
      if (attr->isEmpty()) info(50)<<"--> empty"<<endl ;
      else info(50) /*<attr->getValue()*/<<endl ;
      *buffer>>*attr ;
       info(50)<<"attribut recu "<<attrId<<"  " ;
      if (attr->isEmpty()) info(50)<<"--> empty"<<endl ;
      else info(50) /*attr->getValue()*/<<endl ;
  }

   template <class T>
   bool CObjectTemplate<T>::dispatchEvent(CEventServer& event)
   {
      switch(event.type)
      {
         case EVENT_ID_SEND_ATTRIBUTE :
           recvAttributFromClient(event) ;
           return true ;
           break ;
       
         default :
         return false ;
//           ERROR("void CObjectTemplate<T>::recvEvent(CEventServer& event)",
//                 <<"Unknown Event") ;
      }
   }
   
   template <typename T>
   bool CObjectTemplate<T>::has(const string & id)
   {
     return CObjectFactory::HasObject<T>(id) ;
   }

   template <typename T>
   boost::shared_ptr<T> CObjectTemplate<T>::get(const string & id)
   {
     return CObjectFactory::GetObject<T>(id) ;
   }

   template <typename T>
   boost::shared_ptr<T> CObjectTemplate<T>::create(const string & id)
   {
     return CObjectFactory::CreateObject<T>(id) ;
   }   ///--------------------------------------------------------------

  template <typename T>
  boost::shared_ptr<T> CObjectTemplate<T>::get(void)
  {
    return CObjectFactory::GetObject<T>((T*)this) ;
  }
  
   template <typename T>
   void CObjectTemplate<T>::generateCInterface(ostream& oss)
   {
     string className=getName() ;
     int found=className.find_first_of("_") ;
     if (found!=string::npos) className.replace(found,1,0,'x') ;
     
     oss<<"/* ************************************************************************** *"<<iendl ;
     oss<<" *               Interface auto generated - do not modify                   *"<<iendl ;
     oss<<" * ************************************************************************** */"<<iendl;
     oss<<iendl ;
     oss<<"#include <boost/multi_array.hpp>"<<iendl ;
     oss<<"#include <boost/shared_ptr.hpp>"<<iendl ;
     oss<<"#include \"xmlioserver.hpp\""<<iendl;
     oss<<"#include \"attribute_template_impl.hpp\""<<iendl ;
     oss<<"#include \"object_template_impl.hpp\""<<iendl;
     oss<<"#include \"group_template_impl.hpp\""<<iendl ;
     oss<<"#include \"icutil.hpp\""<<iendl ;
     oss<<iendl ;
     oss<<"extern \"C\""<<iendl ;
     oss<<"{"<<iendl++ ;
     oss<<"typedef xmlioserver::tree::"<<getStrType<T>()<<"*  "<<className<<"_Ptr;"<<iendl;
     oss<<iendl ;
     SuperClassMap::generateCInterface(oss,className) ;
     oss<<iendl-- ;
     oss<<"}"<<iendl ;
   }

   template <typename T>
   void CObjectTemplate<T>::generateFortran2003Interface(ostream& oss)
   {
     string className=getName() ;
     int found=className.find_first_of("_") ;
     if (found!=string::npos) className.replace(found,1,0,'x') ;
     
     oss<<"! * ************************************************************************** *"<<iendl ;
     oss<<"! *               Interface auto generated - do not modify                     *"<<iendl ;
     oss<<"! * ************************************************************************** *"<<iendl;
     oss<<iendl ;
     oss<<"MODULE "<<className<<"_interface_attr"<<iendl++ ;
     oss<<"USE, INTRINSIC :: ISO_C_BINDING"<<iendl ;
     oss<<iendl ;
     oss<<"INTERFACE ! Do not call directly / interface FORTRAN 2003 <-> C99"<<iendl++ ;
     oss<<iendl ;   
     oss<<iendl ;
     SuperClassMap::generateFortran2003Interface(oss,className) ;
     oss<<"END INTERFACE"<<iendl-- ;
     oss<<iendl-- ;
     oss<<"END MODULE "<<className<<"_interface_attr"<<iendl ;
   }
  
   template <typename T>
   void CObjectTemplate<T>::generateFortranInterface(ostream& oss)
   {
     string className=getName() ;
     int found=className.find_first_of('_') ;
     if (found!=string::npos) className.erase(found,1) ;
     string superClassName=getName();
     found=superClassName.find("_group") ;
     if (found!=string::npos) superClassName.erase(found,6) ;
     
     oss<<"! * ************************************************************************** *"<<iendl ;
     oss<<"! *               Interface auto generated - do not modify                     *"<<iendl ;
     oss<<"! * ************************************************************************** *"<<iendl;
     oss<<"#include \"xios_fortran_prefix.hpp\""<<iendl ;
     oss<<iendl ;
     oss<<"MODULE i"<<className<<"_attr"<<iendl++ ;
     oss<<"USE, INTRINSIC :: ISO_C_BINDING"<<iendl ;
     oss<<"USE i"<<superClassName<<iendl ;
     oss<<"USE "<<className<<"_interface_attr"<<iendl ;
//     oss<<"TYPE txios("<<className<<")"<<iendl ;
//     oss<<"  INTEGER(kind = C_INTPTR_T) :: daddr"<<iendl ;
//     oss<<"END TYPE txios("<<className<<")"<<iendl ;
     oss<<iendl-- ;
     oss<<"CONTAINS"<<iendl++ ;
     oss<<iendl ;
     SuperClassMap::generateFortranInterface_id(oss,className) ;
     oss<<iendl ;
     SuperClassMap::generateFortranInterface_hdl(oss,className) ;
     oss<<iendl ;
     SuperClassMap::generateFortranInterface_hdl_(oss,className) ;
     oss<<iendl ;
     SuperClassMap::generateFortranInterfaceGet_id(oss,className) ;
     oss<<iendl ;
     SuperClassMap::generateFortranInterfaceGet_hdl(oss,className) ;
     oss<<iendl ;
     SuperClassMap::generateFortranInterfaceGet_hdl_(oss,className) ;
     oss<<iendl-- ;
     oss<<"END MODULE i"<<className<<"_attr"<<iendl ;
   }


} // namespace xmlioserver

#endif // __XMLIO_CObjectTemplate_impl__