NPLJabberClient.h

#pragma once
#include "IParaWebService.h"

#include "JC_Options.h"
#include "JabberEventBinding.h"
#include "ParaRingBuffer.h"

#include "util/mutex.h"
#include <boost/bimap.hpp>
#include <boost/thread.hpp>
#include <boost/asio.hpp>

// in gloox src folder.
#include <gloox.h>
#include <client.h>
#include <message.h>
#include <messagesessionhandler.h>
#include <messageeventhandler.h>
#include <messageeventfilter.h>
#include <chatstatehandler.h>
#include <chatstatefilter.h>
#include <connectionlistener.h>
#include <disco.h>
#include <lastactivity.h>
#include <loghandler.h>
#include <logsink.h>
#include <connectiontcpclient.h>
#include <connectionsocks5proxy.h>
#include <connectionhttpproxy.h>
#include <messagehandler.h>
#include <rostermanager.h>
#include <registration.h>

using namespace gloox;

namespace ParaEngine
{
    using namespace std;

    class CNPLJabberClient : public MessageSessionHandler, ConnectionListener, LogHandler, RegistrationHandler,
        MessageEventHandler, MessageHandler, ChatStateHandler, RosterListener, INPLJabberClient/*, MUCRoomHandler*/
    {
    public:
        typedef boost::bimap<int, std::string>  StringMap_Type;
        
        CNPLJabberClient(boost::asio::io_service& io_service, const char* sJID);
        virtual ~CNPLJabberClient(void);

    public:
        int ProcessMessage(int timeout = 10);

        //
        // handlers 
        //
        virtual void handleLog( LogLevel level, LogArea area, const std::string& message );

        virtual void onConnect();
        virtual void onDisconnect( ConnectionError e );
        virtual bool onTLSConnect( const CertInfo& info );
        virtual void handleMessage( const gloox::Message & stanza, MessageSession * /*session*/ );
        virtual void handleMessageEvent( const JID& from, MessageEventType event );
        virtual void handleChatState( const JID& from, ChatStateType state );
        virtual void handleMessageSession( MessageSession *session );


        virtual void onResourceBindError( ResourceBindError error );
        virtual void onSessionCreateError( SessionCreateError error );
        virtual void handleItemSubscribed( const JID& jid );
        virtual void handleItemAdded( const JID& jid );
        virtual void handleItemUnsubscribed( const JID& jid );
        virtual void handleItemRemoved( const JID& jid );
        virtual void handleItemUpdated( const JID& jid );
        virtual void handleRoster( const Roster& roster );
        virtual void handleRosterError( const gloox::IQ & /*stanza*/ );
        virtual void handleRosterPresence( const RosterItem& item, const std::string& resource,
            gloox::Presence::PresenceType presence, const std::string& /*msg*/ );
        virtual void handleSelfPresence( const RosterItem& item, const std::string& resource,
            gloox::Presence::PresenceType presence, const std::string& /*msg*/ );
        virtual bool handleSubscriptionRequest( const JID& jid, const std::string& /*msg*/ );
        virtual bool handleUnsubscriptionRequest( const JID& jid, const std::string& /*msg*/ );
        virtual void handleNonrosterPresence( const gloox::Presence & );

        virtual void handleRegistrationFields( const JID& /*from*/, int fields, std::string instructions );
        virtual void handleRegistrationResult( const JID& /*from*/, RegistrationResult result );
        virtual void handleAlreadyRegistered(const JID& /*from*/ );
        virtual void handleDataForm( const JID& /*from*/, const DataForm& /*form*/ );
        virtual void handleOOB( const JID& /*from*/, const OOB& oob );
    public:
        //
        // exposed functions
        //

        bool Connect();

        void Close();

        static void AddStringMap(int nID, const char* sString);

        static void ClearStringMap();

        bool WriteNPLMessage(const char* to, const char* neuronfile,  const char* sCode);

        bool WriteRawString(const char* rawstring);


        bool SendMessage(int t, const char* to, const char* body);

        bool SendMessage(const char* to, const char* body);

        bool Login();












        bool SetPresence(int t,const char* status,const char* show,int priority);

        enum MessageType
        {
            MsgType_normal = -1,
            MsgType_error,
            MsgType_chat,
            MsgType_groupchat,
            MsgType_headline
        };

        const char* GetRoster();

        bool Subscribe(const char* jid, const char* name, const char* groups, const char* msg);

        void Unsubscribe(const char* to, const char* msg);


        virtual void RegisterCreateAccount(const char* username, const char* password);
        virtual void RegisterChangePassword(const char* password);
        virtual void RegisterRemoveAccount();


        virtual StatisticsJabber GetStatistics();

        // following are obsoleted methods

        void RemoveRosterItem(const char* to, const char* msg);

        bool AllowSubscription(const char* to, bool bAllow);


        void GetAgents();

        bool Register(const char* jid);


        const char* GetRosterItemDetail(const char* jid);

        const char* GetRosterGroups();

        const char* GetRosterItems();


        //
        // event functions
        //

        void AddEventListener(int nListenerType, const char*  callbackScript);
        void AddEventListener1(const char* sListenerType, const char*  callbackScript);
        void RemoveEventListener(int nListenerType, const char*  callbackScript);
        void RemoveEventListener1(const char* sListenerType, const char*  callbackScript);
        void ClearEventListener(int nListenerType);
        void ClearEventListener1(const char* sListenerType);
        void ResetAllEventListeners();

        //
        // misc 
        //

        const std::string GetID();

        const string& GetStatus() const;

        int GetConnectionStatus() const;

        int GetAuthError()  const;


        void  WhitespacePing (); 

        void  XmppPing (const string & sTo);

        const std::string &  GetXmlLang () const ;
        void  SetXmlLang (const std::string &xmllang);


        void  SetClientCert (const std::string &clientKey, const std::string &clientCerts);

    public:
        //
        // properties
        //

        const char* GetUser();
        void SetUser(const char* sValue);

        int GetPriority();
        void SetPriority(int nValue){m_Options.PRIORITY = nValue;}

        const char* GetPassword();
        void SetPassword(const char* sValue);


        bool GetAutoLogin() {return m_Options.AUTO_LOGIN;}
        void SetAutoLogin(bool nValue){m_Options.AUTO_LOGIN = nValue;}


        bool GetAutoRoster(){return m_Options.AUTO_ROSTER;}
        void SetAutoRoster(bool nValue){m_Options.AUTO_ROSTER = nValue;}

        bool GetAutoIQErrors() {return m_Options.AUTO_IQ_ERRORS;}
        void SetAutoIQErrors(bool nValue){m_Options.AUTO_IQ_ERRORS = nValue;}

        bool GetAutoPresence(){return m_Options.AUTO_PRESENCE;}
        void SetAutoPresence(bool nValue){m_Options.AUTO_PRESENCE = nValue;}

        const char* GetResource();
        void SetResource(const char* sValue){m_Options.RESOURCE = sValue;}

        bool GetIsAuthenticated();
        void SetIsAuthenticated(bool bValue);

        const char* GetServer();
        void SetServer(const char* Server);

        const char* GetNetworkHost(){return m_Options.NETWORK_HOST.c_str();}
        void SetNetworkHost(const char* sValue){m_Options.NETWORK_HOST = sValue;}

        int GetPort();
        void SetPort(int nValue);

        bool GetPlaintextAuth(){return m_Options.PLAINTEXT;}
        void SetPlaintextAuth(bool bValue){m_Options.PLAINTEXT = bValue;}

        bool IsSSLon(){return m_Options.SSL;}

        bool IsCompressionOn(){return m_Options.AUTO_COMPRESS;}

        bool GetSSL(){return m_Options.SSL;}
        void SetSSL(bool bValue){m_Options.SSL = bValue;}

        bool GetAutoStartTLS(){return m_Options.AUTO_TLS;}
        void SetAutoStartTLS(bool bValue);

        bool GetAutoStartCompression();
        void SetAutoStartCompression(bool bValue);

        float GetKeepAlive(){return m_fKeepAlive;   }
        void SetKeepAlive(float KeepAlive){m_fKeepAlive = KeepAlive;}

        float GetAutoReconnect(){return m_fAutoReconnect;}
        void SetAutoReconnect(float AutoReconnect){m_fAutoReconnect = AutoReconnect;}

        const char* GetServerVersion() { return GLOOX_VERSION.c_str();}

        bool GetRequiresSASL(){return m_Options.SASL;}
        void SetRequiresSASL(bool bValue);

    protected:
        virtual bool AddEvent(int nEventType, const char* precode=NULL, const char* postcode=NULL);
        virtual bool CallEvent(int nEventType, const char* precode=NULL, const char* postcode=NULL);

        const char* GetStringByID(int nID);
        int GetIDByString(const char* sString);

        const string& GetJIDKey() {return m_sThisJIDKey;}
        void SetJIDKey(const string& sJIDKey) {m_sThisJIDKey = sJIDKey;}

    protected:
        Client *m_client;
        MessageSession *m_session;
        MessageEventFilter *m_messageEventFilter;
        ChatStateFilter *m_chatStateFilter;
        Registration *m_reg;

        JCOptions m_Options;
        bool m_bIsAuthenticated;
        float m_fKeepAlive;
        float m_fAutoReconnect;
        CJabberEventBinding m_eventbinding;

        string m_sUsername;
        string m_sPassword;
        string m_sStatus;
        string m_sThisJIDKey;
        static StringMap_Type g_mapStringMap;

        boost::asio::io_service * m_pIOService;

        ParaEngine::mutex m_mutex;
    };

}