UserClient.h

/* START_LICENSE_HEADER

Copyright (C) 2000 Martin Piper, original design and program code
Copyright (C) 2001 Replica Software

This program file is copyright (C) Replica Software and can only be used under license.
For more information visit: http://www.replicanet.com/
Or email: info@replicanet.com

END_LICENSE_HEADER */
#include "RNPlatform/Inc/MemoryTracking.h"
#ifndef _USERCLIENT_H_
#define _USERCLIENT_H_
#include "RNLobby/Inc/BaseTransportServer.h"
#include "RNXPSockets/Inc/XPSocket.h"
#include <set>
#include <map>

namespace RNReplicaNet
{

namespace RNLobby
{

class UserInfo
{
public:
    UserInfo();
    virtual ~UserInfo();

    int GetLoginID(void) const;
    std::string GetName(void) const;

    enum
    {
        kAnyLoginID = 0
    };

    enum
    {
        kState_Friend           = (1<<0),
        kState_FriendRequest    = (1<<2),
        kState_Online           = (1<<3),
        kState_GameInvite       = (1<<5),
        kState_Speaking         = (1<<6),
        kState_Ignored          = (1<<7),
        kState_InARoom          = (1<<8),   // MPi: TODO: Implement
        kState_PlayingAGame     = (1<<9)
    };
    int GetState(void) const;

    std::string GetGameInvite(void) const;

    std::string GetLastOnlineTime(void) const;

    std::string GetPlayingAGameURL(void) const;

    int mID;
    int mLoginID;
    std::string mName;
    int mState;
    std::string mGameInvite;
    std::string mLastOnlineTime;
    std::string mPlayingAGameURL;
};

class UserClient : public BaseTransportServer
{
public:

    UserClient();
    virtual ~UserClient();

    bool Start(void);

    bool Stop(void);

    void SetServer(const XPAddress &address);

    bool CreateLoginUser(const char *name,const char *password,const char *emailAddress = "",const char *optionalID = "");

    bool LoginUser(const char *name,const char *password);

    bool ChangePassword(const char *password = "");

    bool ChangeEmail(const char *emailAddress = "");


    int GetLoginID(void);

    std::string GetLoginName(void);

    bool LogoutUser(void);

    bool DeleteUser(void);

    bool SendMessageTo(const int loginID,const char *message = "");

    bool AddFriend(const int friendLoginID);

    bool AuthoriseFriendRequest(const int friendLoginID);

    bool DenyFriendRequest(const int friendLoginID);

    bool RemoveFriend(const int friendLoginID);

    void AnswerMessage(const int fromLoginID = UserInfo::kAnyLoginID);

    enum Reason
    {
        kReason_ClientForcedLogout = 0,
        kReason_ServerForcedLogout,
        kReason_ChatRoomFull,
        kReason_ChatRoomUserLeft,
        kReason_ChatRoomClosed,
        kReason_ChatRoomKickedByAdmin,
        kReason_ChatRoomWrongPassword,
        kReason_ChatRoomDoesNotExist,
        kReason_ChatRoomBanned,
        kReason_IncorrectLoginDetails,
        kReason_AccountBlocked
    };

    enum
    {
        kState_Online           = (1<<0),
        kState_FriendRequest    = (1<<1),
        kState_GameInvite       = (1<<2),
        kState_Message          = (1<<3)
    };

    int GetState(void);

    bool SendGameInvite(const int friendLoginID,const char *invite = "");

    bool CancelGameInvite(const int friendLoginID);

    bool AnswerGameInvite(const int friendLoginID = UserInfo::kAnyLoginID);

    enum VariableAccess
    {
        kPrivateRead                    = 0,        // Values set by the statistics server.
        kPrivateReadWrite               = 1,        // Values set by the owner or the statistics server.
        kPublicReadPrivateReadWrite     = 2,        // Values set by the owner or the statistics server.
        kPublicReadPrivateRead          = 3         // Values set by the statistics server.
    };

    bool SetVariable(const int section,const char *name,const char *value = 0,const VariableAccess access = kPrivateReadWrite);

    bool GetVariable(const int section,const char *name,const VariableAccess access = kPrivateReadWrite);

    bool GetVariable(const int loginID,const int section,const char *name,const VariableAccess access = kPublicReadPrivateRead);

    bool AddUserInfo(const int loginID,const bool useCache = true,const bool trackChanges = false);

    bool RemoveUserInfo(const int loginID);

    bool GetUserInfo(const int loginID,UserInfo *result);

    bool CreateChatRoom(const char *password = 0);

    bool LeaveChatRoom(void);

    bool EnterChatRoom(const int chatRoomID,const char *password = 0);

    int GetCurrentRoom(void);

    bool ChatRoomAdminMessage(const char *text,const unsigned int flags = 0);

    bool ChatRoomSay(const char *text,const unsigned int flags = 0);

    bool ChatRoomWhisper(const int loginID,const char *text,const unsigned int flags = 0);

    bool ChatRoomKickUser(const int loginID,const bool ban = false,const char *reason = "");

    bool GlobalKickUser(const int loginID,const bool ban = false,const char *reason = "");

    bool GlobalRestoreUser(const int loginID);

    bool IsRoomAdmin(void);

    bool IsSuperAdmin(void);

    bool PlayingAGame(const bool playing = false,const char *url = "");

    bool GetPlayingAGame(void);
    std::string GetPlayingAGameURL(void);

    std::string GetLastOnlineTime(void);

    bool RequestUserNonce(const int seconds);

    bool RequestNamesLike(const char *match = "",const bool banned = false);

    int GetPendingGetVariableRequests(void);

protected:

    virtual void CallbackConnectionEstablished(Transport *transport) {}

    virtual void CallbackUserLogin(const int loginID) {}

    virtual void CallbackUserLoginFailed(const Reason reason) {}

    virtual void CallbackUserLogout(const Reason reason) {}

    virtual void CallbackUserAlreadyExists(const int loginID) {}

    virtual void CallbackUserLoginFromOtherClient(void) {}

    virtual void CallbackMessageReceived(const int fromLoginID,const char *message) {}

    virtual void CallbackFriendDeleted(const int loginID) {}

    virtual void CallbackFriendAdded(const UserInfo &user) {}

    virtual void CallbackFriendUpdated(const UserInfo &user) {}

    virtual void CallbackStateChange(const int previousState,const int newState) {}

    virtual void CallbackGotVariable(const int loginID,const int section,const char *name,const char *value,const VariableAccess access) {}

    virtual void CallbackVariableNotFound(const int loginID,const int section,const char *name,const VariableAccess access) {}

    virtual void CallbackUserInfoDeleted(const int loginID) {}

    virtual void CallbackUserInfoAdded(const UserInfo &user) {}

    virtual void CallbackUserInfoUpdated(const UserInfo &user) {}

    virtual void CallbackChatRoomCreated(const int chatRoomID) {}

    virtual void CallbackChatRoomEntered(const int chatRoomID) {}

    virtual void CallbackChatRoomEnterFailed(const int chatRoomID,const Reason reason) {}

    virtual void CallbackChatRoomLeft(const Reason reason) {}

    // When entering a room the first callback will be CallbackChatRoomEntered() followed by any number of CallbackChatRoomUserEntered().
    // The last callback will be CallbackChatRoomUserEntered() with the current user ID to signify the end of the list.
    virtual void CallbackChatRoomUserEntered(const UserInfo &user) {}

    virtual void CallbackChatRoomUserLeft(const RNReplicaNet::RNLobby::UserInfo &user,const Reason reason) {}

    virtual void CallbackChatRoomMessage(const char *text,const UserInfo &user,const bool whispered,const bool isAdminMessage,const unsigned int flags) {}

    virtual void CallbackChatRoomKicked(const char *reason,bool banned,const UserInfo &user) {}

    virtual void CallbackGlobalKicked(const char *reason,bool banned,const UserInfo &user) {}

    virtual void CallbackPasswordChanged(void) {}

    virtual void CallbackCannotChangePassword(void) {}

    virtual void CallbackEmailChanged(void) {}

    virtual void CallbackCannotChangeEmail(void) {}

    virtual void CallbackGotUserNonce(const char *userNonce,const int seconds) {}

    virtual void CallbackNewStatsAvailable(const int lastUpdatedTitleID) {}

    virtual void CallbackNamesLikeBegin(const char *match,const bool banned) {}

    virtual void CallbackNamesLike(const UserInfo &user) {}

    virtual void CallbackNamesLikeEnd(void) {}

protected:
    // These callbacks from BaseTransportServer are implemented by this class. If they are implemented by the user this implementation must be called.
    void CallbackTidy(void);

    bool CallbackPoll(void);

    bool CallbackParseValidMessage(Transport *transport,DynamicMessageHelper &message,const size_t length);

private:

    // Called after a logout or other similar event
    void InitInternalState(void);

    XPAddress mServerAddress;

    bool mLoginTried;
    int mMyLoginID;

    std::set<int> mPendingFriendIDs;

    MutexClass mInternalLists;

    std::map<int,UserInfo> mUsers;
    int mPreviousState;
    int mCurrentState;
    bool mMessagePending;
    bool mGameInvitePending;

    void DoStateChangeCalc(void);
    int mInCurrentRoom;
    bool mRoomMode;
    bool mIsRoomAdmin;
    bool mIsGlobalAdmin;
    std::string mMyLoginName;
    bool mServerAddressSet;
    bool mLastPlayingAGame;
    std::string mLastOnlineTime;
    std::string mLastPlayingAGameURL;

    int mPendingGetVariables;
};

} // namespace RNLobby

} // namespace RNReplicaNet

#endif