#ifndef NETWORK_OBJECT_HH
#define NETWORK_OBJECT_HH

#include "NetworkSession.hh"
#include "NetworkNode.hh"
#include "Logger.hh"

#include <map>

typedef uint32_t NetworkObjectID;
typedef uint16_t NetworkMessageID;

// forward-declare
class NetworkObject;
class NetworkObject_Client;
class NetworkObject_Server;

class NetworkObjectController {
    friend class NetworkObject;
    friend class NetworkObject_Server;
    friend class NetworkObject_Client;

    private:
        NetworkSession &session;
        NetworkChannelID channel_id;

        std::map<NetworkObjectID, NetworkObject*> objects;

        CL_Slot slot_message;
    
    protected:
        NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id);
    
    private:
        void on_message (NetworkPacket &pkt, NetworkNode *node);

    protected:
        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node) = 0; 
};

class NetworkObject_ServerController : public NetworkObjectController {
    friend class NetworkObject_Server;

    private:
        NetworkObjectID id_pool;
    
    public:
        NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id);

    protected:
        NetworkObjectID getObjectID (void);

        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node);
};

class NetworkObject_ClientController : public NetworkObjectController {
    friend class NetworkObject_Client;

    private:
        NetworkNode *server;

        CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, NetworkPacket&> _sig_create;
    
    public:
        NetworkObject_ClientController (NetworkSession &session, NetworkChannelID channel_id, NetworkNode *server);

    protected:
        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacket &pkt, NetworkNode *node);
    
    public:  
        CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, NetworkPacket&>& sig_create (void) { return _sig_create; }
};

class NetworkObject {
    friend class NetworkObjectController;
    friend std::ostream& operator<< (std::ostream &s, const NetworkObject &obj);

    protected:
        NetworkObjectID obj_id;

    protected:
        NetworkObject (NetworkObjectController &controller, NetworkObjectID obj_id);
        
        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacket &pkt) = 0;

        void buildPacket (NetworkPacket &pkt, NetworkMessageID msg_id, const NetworkPacket &payload);
};

std::ostream& operator<< (std::ostream &s, const NetworkObject &obj);

class NetworkObject_Server : public NetworkObject {
    friend class NetworkObject_ServerController;

    private:
        NetworkObject_ServerController &controller;

        std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, NetworkPacket&> > _map_sig_message;

    public:
        NetworkObject_Server (NetworkObject_ServerController &controller);
    
    protected:
        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacket &pkt);

    public:
        void send_to (NetworkNode *dst, NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
        void send_all (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
        void send_all_except (NetworkMessageID msg_id, const NetworkPacket &pkt, NetworkNode *black_sheep, bool reliable = true);
    
        CL_Signal_v2<NetworkNode*, NetworkPacket&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }
};

class NetworkObject_Client : public NetworkObject {
    friend class NetworkObject_ClientController;

    private:
        NetworkObject_ClientController &controller;

        std::map<NetworkMessageID, CL_Signal_v1<NetworkPacket&> > _map_sig_message;

    protected:
        NetworkObject_Client (NetworkObject_ClientController &controller, NetworkObjectID id);
        
        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacket &pkt);

    public:
        void send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
        
        CL_Signal_v1<NetworkPacket&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }
};

#endif /* NETWORK_OBJECT_HH */