Account.h

#ifndef ERIS_PLAYER_H
#define ERIS_PLAYER_H

#include "Types.h"

#include "TransferInfo.h"

#include <Atlas/Objects/ObjectsFwd.h>

#include <sigc++/signal.h>

#include <vector>
#include <map>
#include <memory>

namespace Eris
{

class Connection;
class Avatar;
class AccountRouter;
class TimedEvent;
class SpawnPoint;

typedef std::map<std::string, Atlas::Objects::Entity::RootEntity> CharacterMap;

typedef std::map<std::string, Avatar*> ActiveCharacterMap;

typedef std::map<std::string, SpawnPoint> SpawnPointMap;


class Account : virtual public sigc::trackable
{
public:

    explicit Account(Connection *con);

    virtual ~Account();


    Result login(const std::string &uname, const std::string &pwd);

    /* Create a new account on the server, if possible.
    Server-side failures, such as an account already existing with the specified
    username, will cause the 'LoginFailure' signal to be emitted with an error message
    and a code. As for 'login', LoginSuccess wil be emitted if everything goes as plan.

    @param uname The desired username of the account (eg 'ajr')
    @param fullName The real name of the user (e.g 'Al Riddoch')
    @param pwd The plaintext password for the new account
    */

    Result createAccount(const std::string &uname,
        const std::string &fullName,
        const std::string &pwd);

    /* Create a new account on the server, if possible.
    Server-side failures, such as an account already existing with the specified
    username, will cause the 'LoginFailure' signal to be emitted with an error message
    and a code. As for 'login', LoginSuccess wil be emitted if everything goes as plan.

    This variant allows you to specify your own Account op, which is useful when you
    want to create an account different from the standard one.

    @param accountOp The account operation, which will be wrapped in a "Create" op.
    */
    Result createAccount(const Atlas::Objects::Entity::Account& accountOp);



    Result logout();


    bool isLoggedIn() const;

    const std::vector<std::string> & getCharacterTypes() const;


    const CharacterMap& getCharacters();

    Result refreshCharacterInfo();


    Result takeTransferredCharacter(const std::string &id, const std::string &key);


    Result takeCharacter(const std::string &id);

    Result createCharacter(const Atlas::Objects::Entity::RootEntity &character);

    //void createCharacter();

    bool canCreateCharacter();

    const ActiveCharacterMap& getActiveCharacters() const;

    const SpawnPointMap& getSpawnPoints() const;

    Result deactivateCharacter(Avatar* av);

    const std::string& getId() const;

    const std::string& getUsername() const;

    const std::string& getParent() const;

    Connection* getConnection() const;

    void avatarLogoutRequested(Avatar* avatar);


// signals
    sigc::signal<void, const Atlas::Objects::Entity::RootEntity&> GotCharacterInfo;

    sigc::signal<void> GotAllCharacters;


    sigc::signal<void, const std::string &> LoginFailure;

    sigc::signal<void> LoginSuccess;


    sigc::signal<void, bool> LogoutComplete;

    sigc::signal<void, Avatar*> AvatarSuccess;

    sigc::signal<void, const std::string &> AvatarFailure;

    sigc::signal<void, Avatar*> AvatarDeactivated;

    sigc::signal<void, const std::string&> ErrorMessage;

protected:
    friend class AccountRouter;
    friend class Avatar; // so avatar can call deactivateCharacter

    void sightCharacter(const Atlas::Objects::Operation::RootOperation& op);

    void loginComplete(const Atlas::Objects::Entity::Account &p);
    void loginError(const Atlas::Objects::Operation::Error& err);

    Result internalLogin(const std::string &unm, const std::string &pwd);
    void internalLogout(bool clean);

    void netConnected();

    bool netDisconnecting();
    void netFailure(const std::string& msg);

    void loginResponse(const Atlas::Objects::Operation::RootOperation& op);
    void logoutResponse(const Atlas::Objects::Operation::RootOperation& op);
    void possessResponse(const Atlas::Objects::Operation::RootOperation& op);
        void avatarCreateResponse(const Atlas::Objects::Operation::RootOperation& op);
    void avatarLogoutResponse(const Atlas::Objects::Operation::RootOperation& op);

    void destroyAvatar(const std::string& avatarId);

    void handleLogoutTimeout();
//  void recvRemoteLogout(const Atlas::Objects::Operation::Logout &lo);

    void handleLoginTimeout();

    typedef enum
    {
        DISCONNECTED = 0,   
        LOGGING_IN,         
        LOGGED_IN,          
        LOGGING_OUT,         

        TAKING_CHAR,        
        CREATING_CHAR       
    } Status;

    void internalDeactivateCharacter(Avatar* av);
    virtual void updateFromObject(const Atlas::Objects::Entity::Account &p);

    Connection* m_con;  
    Status m_status;    
    AccountRouter* m_router;

    std::string m_accountId;    
    std::string m_username; 
    std::string m_pass;

    std::string m_parent;
    std::vector< std::string > m_characterTypes;
    CharacterMap _characters;   
    StringSet m_characterIds;
    bool m_doingCharacterRefresh; 

    ActiveCharacterMap m_activeCharacters;
    std::unique_ptr<TimedEvent> m_timeout;

    SpawnPointMap m_spawnPoints;
};

inline bool Account::canCreateCharacter()
{
    return false;
}

inline const ActiveCharacterMap& Account::getActiveCharacters() const
{
    return m_activeCharacters;
}

inline const std::string& Account::getId() const
{
    return m_accountId;
}

inline const std::string& Account::getUsername() const
{
    return m_username;
}

inline const std::string& Account::getParent() const
{
    return m_parent;
}


inline Connection* Account::getConnection() const
{
    return m_con;
}

inline const SpawnPointMap& Account::getSpawnPoints() const
{
    return m_spawnPoints;
}


} // of namespace Eris

#endif