#ifndef NETWORK_OBJECT_HH
#define NETWORK_OBJECT_HH

#include <map>

typedef uint32_t NetworkObjectID;
typedef uint16_t NetworkMessageID;

class NetworkObjectController {
    friend class NetworkObject;

    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 (const NetworkPacket &pkt, NetworkNode *node);

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

class NetworkObject_ServerController : 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, const NetworkPacket &pkt, NetworkNode *node);
};

class NetworkObject_ClientController : NetworkObjectController {
    friend class NetworkObject_Client;

    private:
        NetworkNode *server;

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

    public:
        NetworkObject_ClientController (NetworkSession &session, NetworkChannelID channel_id, NetworkNode *server);
        
        CL_Signal_v3<NetworkObject_Client*, NetworkMessageID, const NetworkPacket&>& sig_create (void) { return _sig_create; }
};

class NetworkObject {
    friend class NetworkObjectController;

    private:
        NetworkObjectID obj_id;

        std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, const NetworkPacket&>> _map_sig_message;
        
    protected:
        NetworkObject (NetworkObjectID obj_id, NetworkObjectController &controller);

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

    public:
        CL_Signal_v2<NetworkNode*, const NetworkPacket&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }
};

class NetworkObject_Server : public NetworkObject {
    friend class NetworkObject_ServerController;

    private:
        NetworkObject_ServerController &controller;

    public:
        NetworkObject_Server (NetworkObjectController &controller);

        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);
};

class NetworkObject_Client : public NetworkObject {
    friend class NetworkObject_ClientController;

    private:
        NetworkObject_ClientController &controller;

    protected:
        NetworkObject_Client (NetworkObject_ClientController &controller, NetworkNode *server, NetworkObjectID id);

    public:
        void send (NetworkMessageID msg_id, const NetworkPacket &pkt, bool reliable = true);
}

#endif /* NETWORK_OBJECT_HH */