#pragma once

#include "Tree/Instance.hpp"

#include "Tree/Service.hpp"

#include "Player.hpp"

#include "ChatFilter.hpp"

#include "Utility/SystemAddress.hpp"

#include "Utility/GameMode.hpp"

#include "DataModel/FriendService.hpp"

#include "DataModel/ContentProvider.hpp"

#include "boost/thread/thread.hpp"
#include <boost/thread/condition.hpp>
#include <boost/unordered_set.hpp>
#include <queue>


namespace RakNet
{
class RakPeerInterface;
struct Packet;
class BitStream;
struct SystemAddress;
} // namespace RakNet

namespace Aya
{
class PartInstance;
class ModelInstance;
class Region2;
class Adorn;
class ScriptInformationProvider;
class DataModel;

namespace Network
{

struct MemHash
{
    size_t checkIdx;
    unsigned int value;
    unsigned int failMask;
};

typedef std::vector<MemHash> MemHashVector;
typedef std::vector<MemHashVector> MemHashConfigs;

class ConcurrentRakPeer;

class ChatMessage
{
public:
    enum ChatType
    {
        CHAT_TYPE_ALL,
        CHAT_TYPE_TEAM,
        CHAT_TYPE_WHISPER,
        CHAT_TYPE_GAME,
        // CHAT_TYPE_PARTY
    };

    std::string guid;
    std::string message;
    ChatType chatType;
    shared_ptr<Player> const source;
    shared_ptr<Player> const destination;
    ChatMessage(const ChatMessage& other, const std::string& message);
    ChatMessage(const char* message, ChatType chatType, shared_ptr<Player> source);
    ChatMessage(const char* message, ChatType chatType, shared_ptr<Player> source, shared_ptr<Player> destination);

    bool isVisibleToPlayer(shared_ptr<Player> player) const;
    static bool isVisibleToPlayer(
        shared_ptr<Player> const player, shared_ptr<Player> const source, shared_ptr<Player> const destination, const ChatType chatType);
    std::string getReportAbuseMessage() const;
};

struct AbuseReport
{
    struct Message
    {
        int userID;
        std::string text;
        std::string guid;
    };

    int placeID;
    std::string gameJobID;

    int submitterID;
    int allegedAbuserID;
    std::string comment;
    std::list<Message> messages;
    void addMessage(shared_ptr<Player> reportingPlayer, const ChatMessage& cm);
};

class AbuseReporter
{
    struct data
    {
        std::queue<AbuseReport> queue;
        boost::mutex requestSync; // synchronizes the request queue
    };
    shared_ptr<data> _data;
    scoped_ptr<worker_thread> requestProcessor;

public:
    AbuseReporter(std::string abuseUrl);
    void add(AbuseReport& r, shared_ptr<Player> reportingPlayer, const std::list<ChatMessage>& chatHistory);

private:
    static worker_thread::work_result processRequests(shared_ptr<data> _data, std::string abuseUrl);
};

extern const char* const sPlayers;

class Players
    : public DescribedNonCreatable<Players, Instance, sPlayers>
    , public Service
{
private:
    typedef DescribedNonCreatable<Players, Instance, sPlayers> Super;

public:
    // Unfortunately the RakNet enums are not accessible via the Players class, so this identical enum is created
    // and mapped in PluginInterfaceAdapter::OnReceive.  - Tim
    enum ReceiveResult
    {
        // The plugin used this message and it shouldn't be given to the user.
        PLAYERS_STOP_PROCESSING_AND_DEALLOCATE = 0,

        // The plugin is going to hold on to this message.  Do not deallocate it but do not pass it to other plugins either.
        PLAYERS_STOP_PROCESSING,
    };

    enum ChatOption
    {
        CLASSIC_CHAT = 0,
        BUBBLE_CHAT = 1,
        CLASSIC_AND_BUBBLE_CHAT = 2
    };

    enum PlayerChatType
    {
        PLAYER_CHAT_TYPE_ALL = 0,
        PLAYER_CHAT_TYPE_TEAM = 1,
        PLAYER_CHAT_TYPE_WHISPER = 2
    };


    static bool isNetworkClient(Instance* instance);
    void friendEventFired(int userId, int otherUserId, FriendService::FriendEventType friendEvent);
    void friendStatusChanged(int userId, int otherUserId, FriendService::FriendStatus friendStatus);

private:
    std::string saveDataUrl;
    std::string loadDataUrl;
    std::string saveLeaderboardDataUrl;
    boost::unordered_set<std::string> leaderboardKeys;

    std::string chatFilterUrl;
    std::string buildUserPermissionsUrl;
    std::string sysStatsUrl;

    static bool canKickBecauseRunningInRealGameServer;

    bool characterAutoSpawn;

    scoped_ptr<AbuseReporter> abuseReporter;
    boost::intrusive_ptr<GuidItem<Instance>::Registry> guidRegistry;
    std::list<ChatMessage> chatHistory;

    const boost::intrusive_ptr<GuidItem<Instance>::Registry>& getGuidRegistry();

    copy_on_write_ptr<Instances> players;
    ConcurrentRakPeer* rakPeer;

    int maxPlayers;
    int preferredPlayers;
    int testPlayerNameId;
    int testPlayerUserId;
    shared_ptr<Player> localPlayer;

    ChatOption chatOption;

    bool nonSuperSafeChatForAllPlayersEnabled;

    Aya::signals::connection blockUserClientSignalConnection;
    Aya::signals::connection blockUserFinishedFromServerConnection;
    Aya::signals::connection loadLocalPlayerGuisConnection;

    boost::unordered_map<std::pair<int, int>, std::pair<boost::function<void(std::string)>, boost::function<void(std::string)>>> clientBlockUserMap;

    void raiseChatMessageSignal(const ChatMessage& message);
    void raisePlayerChattedSignal(const ChatMessage& message);

    void loadLocalPlayerGuis();
    void gotBlockUserSuccess(std::string response, bool blockUser, int blockerUserId, int blockeeUserId,
        boost::function<void(std::string)> resumeFunction, boost::function<void(std::string)> errorFunction);
    void gotBlockUserError(std::string error, bool blockUser, int blockerUserId, int blockeeUserId, boost::function<void(std::string)> errorFunction);

    static void onReceivedRawGetUserIdSuccess(weak_ptr<DataModel> weakDataModel, std::string response, boost::function<void(int)> resumeFunction,
        boost::function<void(std::string)> errorFunction);
    static void onReceivedRawGetUserIdError(weak_ptr<DataModel> weakDataModel, std::string error, boost::function<void(std::string)> errorFunction);

    static void onReceivedRawGetUserNameSuccess(weak_ptr<DataModel> weakDataModel, std::string response,
        boost::function<void(std::string)> resumeFunction, boost::function<void(std::string)> errorFunction);
    static void onReceivedRawGetUserNameError(weak_ptr<DataModel> weakDataModel, std::string error, boost::function<void(std::string)> errorFunction);

    void serverMakeBlockUserRequest(bool blockUser, int blockerUserId, int blockeeUserId, boost::function<void(std::string)> resumeFunction,
        boost::function<void(std::string)> errorFunction);
    void clientReceiveBlockUserFinished(int blockerUserId, int blockeeUserId, std::string errorString);

    void internalBlockUser(int blockerUserId, int blockeeUserId, bool isBlocking, boost::function<void(std::string)> resumeFunction,
        boost::function<void(std::string)> errorFunction);

public:
    ReceiveResult OnReceiveChat(Player* sourceValidation, RakNet::RakPeerInterface* peer, RakNet::Packet* packet, unsigned char chatType);
    ReceiveResult OnReceiveReportAbuse(Player* source, RakNet::RakPeerInterface* peer, RakNet::Packet* packet);

#ifdef ENABLE_VOICE_CHAT
    ReceiveResult OnReceiveOpusData(Player* source, RakNet::RakPeerInterface* peer, RakNet::Packet* packet, unsigned char chatType);

    void SendOpusData();
#endif

    Aya::signal<void(shared_ptr<Instance>, shared_ptr<Instance>, FriendService::FriendEventType)> friendRequestEvent;
    Aya::signal<void(shared_ptr<Instance>)> playerAddedEarlySignal;
    Aya::signal<void(shared_ptr<Instance>)> playerAddedSignal;
    Aya::signal<void(shared_ptr<Instance>)> playerRemovingSignal;
    Aya::signal<void(shared_ptr<Instance>)> playerRemovingLateSignal;
    Aya::signal<void(const ChatMessage&)> chatMessageSignal;
    Aya::signal<void(AbuseReport report)> abuseReportedReceived;
    Aya::signal<void(
        const RakNet::SystemAddress&, const shared_ptr<RakNet::BitStream>&, const shared_ptr<Instance>, const std::string&, const std::string&)>
        sendFilteredChatMessageSignal;

    Aya::signal<void(PlayerChatType, shared_ptr<Instance>, std::string, shared_ptr<Instance>)> playerChattedSignal;
    Aya::signal<void(std::string)> gameAnnounceSignal;

    Aya::remote_signal<void(int, int, bool)> blockUserRequestFromClientSignal;
    Aya::remote_signal<void(int, int, std::string)> blockUserFinishedFromServerSignal;

    static Reflection::RefPropDescriptor<Players, Instance> propLocalPlayer;
    static Reflection::PropDescriptor<Players, bool> propCharacterAutoSpawn;
    Players();
    ~Players();

    bool superSafeOn() const;

    shared_ptr<Instance> createLocalPlayer(int userId, bool teleportedIn = false);
    void resetLocalPlayer();

    Player* getLocalPlayer()
    {
        return localPlayer.get();
    }
    const Player* getConstLocalPlayer() const
    {
        return localPlayer.get();
    }
    Instance* getLocalPlayerDangerous() const; // only for reflection

    int getNumPlayers() const
    {
        return (int)players->size();
    }

    void getUserIdFromName(std::string userName, boost::function<void(int)> resumeFunction, boost::function<void(std::string)> errorFunction);
    void getNameFromUserId(int userId, boost::function<void(std::string)> resumeFunction, boost::function<void(std::string)> errorFunction);
    void getFriends(int userId, boost::function<void(shared_ptr<Instance>)> resumeFunction, boost::function<void(std::string)> errorFunction);

    static void setAppearanceParent(shared_ptr<Instance> model, weak_ptr<Instance> instance);
    static void doLoadAppearance(AsyncHttpQueue::RequestResult result, shared_ptr<Instances> instances, std::string contentDescription,
        shared_ptr<ModelInstance> model, shared_ptr<int> amountToLoad, boost::function<void(shared_ptr<Instance>)> resumeFunction,
        boost::function<void(std::string)> errorFunction);
    static void doMakeAccoutrementRequests(std::string response, weak_ptr<DataModel> dataModel, shared_ptr<ModelInstance> model,
        boost::function<void(shared_ptr<Instance>)> resumeFunction, boost::function<void(std::string)> errorFunction);
    static void makeAccoutrementRequests(std::string* response, std::exception* err, weak_ptr<DataModel> dataModel, shared_ptr<ModelInstance> model,
        boost::function<void(shared_ptr<Instance>)> resumeFunction, boost::function<void(std::string)> errorFunction);
    void getCharacterAppearance(
        int userId, boost::function<void(shared_ptr<Instance>)> resumeFunction, boost::function<void(std::string)> errorFunction);

    int getMaxPlayers() const;
    int getPreferredPlayers() const;

    void setMaxPlayers(int value);
    void setPreferredPlayers(int value);
    void setSysStatsUrl(std::string url);

    std::string getSaveDataUrl(int userId) const;
    void setSaveDataUrl(std::string saveDataUrl);

    std::string getLoadDataUrl(int userId) const;
    void setLoadDataUrl(std::string loadDataUrl);

    std::string getSaveLeaderboardDataUrl(int userId) const;
    void setSaveLeaderboardDataUrl(std::string saveLeaderboardDataUrl);
    void addLeaderboardKey(std::string);

    bool hasLeaderboardKey(const std::string& key) const;
    boost::unordered_set<std::string>::const_iterator beginLeaderboardKey() const;
    boost::unordered_set<std::string>::const_iterator endLeaderboardKey() const;

    void setChatOption(ChatOption value);
    void setNonSuperSafeChatForAllPlayersEnabled(bool enabled);
    bool getNonSuperSafeChatForAllPlayersEnabled() const;
    bool getClassicChat() const
    {
        return chatOption == CLASSIC_CHAT || chatOption == CLASSIC_AND_BUBBLE_CHAT;
    }
    bool getBubbleChat() const
    {
        return chatOption == BUBBLE_CHAT || chatOption == CLASSIC_AND_BUBBLE_CHAT;
    }

    shared_ptr<const Instances> getPlayers()
    {
        return players.read();
    }

    // Chat-related functions
    void gamechat(const std::string& message);

    void chat(std::string message);
    void teamChat(std::string);
    void whisperChat(std::string message, shared_ptr<Instance> player);

    void reportAbuse(Player* player, const std::string& comment);
    void reportAbuseLua(shared_ptr<Instance> instance, std::string reason, std::string comment);
    std::list<ChatMessage>::const_iterator chatHistory_begin()
    {
        return chatHistory.begin();
    }
    std::list<ChatMessage>::const_iterator chatHistory_end()
    {
        return chatHistory.end();
    }
    bool canReportAbuse() const;
    void setAbuseReportUrl(std::string value);
    void setChatFilterUrl(std::string value);
    void setBuildUserPermissionsUrl(std::string value);
    bool hasBuildUserPermissionsUrl() const;
    std::string getBuildUserPermissionsUrl(int playerId) const;

    void friendServiceRequest(bool makeFriends, weak_ptr<Player> sourcePlayer, int otherUserId);

    bool getCharacterAutoSpawnProperty() const
    {
        return characterAutoSpawn;
    }
    void setCharacterAutoSpawnProperty(bool value);
    bool getShouldAutoSpawnCharacter() const;

    void blockUser(int blockerUserId, int blockeeUserId, boost::function<void(std::string)> resumeFunction = boost::function<void(bool)>(),
        boost::function<void(std::string)> errorFunction = boost::function<void(std::string)>());
    void unblockUser(int blockerUserId, int blockeeUserId, boost::function<void(std::string)> resumeFunction = boost::function<void(bool)>(),
        boost::function<void(std::string)> errorFunction = boost::function<void(std::string)>());

    void setConnection(ConcurrentRakPeer* rakPeer);

    shared_ptr<Instance> playerFromCharacter(shared_ptr<Instance> character);
    shared_ptr<Instance> getPlayerInstanceByID(int userID);
    shared_ptr<Player> getPlayerByID(int userID);

    static Player* getPlayerFromCharacter(Aya::Instance* character);

    void buildClientRegion(Region2& clientRegion);

    void renderDPhysicsRegions(Adorn* adorn);

    ///////////////////////////////////////////////////////////////////////////
    //
    // STATICS
    //
    // If Client == Client Network Address;  If Server == NetworkOwner::Server()
    static Aya::SystemAddress findLocalSimulatorAddress(const Aya::Instance* context);

    static ModelInstance* findLocalCharacter(Aya::Instance* context);
    static const ModelInstance* findConstLocalCharacter(const Aya::Instance* context);

    static Player* findLocalPlayer(Aya::Instance* context);
    static const Player* findConstLocalPlayer(const Aya::Instance* context);

    static shared_ptr<Player> findAncestorPlayer(const Aya::Instance* context);

    static shared_ptr<Player> findPlayerWithAddress(const Aya::SystemAddress& playerAddres, const Aya::Instance* context);

    static bool clientIsPresent(const Aya::Instance* context, bool testInDatamodel = true);

    static bool serverIsPresent(const Aya::Instance* context, bool testInDatamodel = true);

    static bool frontendProcessing(const Aya::Instance* context, bool testInDatamodel = true);

    static bool backendProcessing(const Aya::Instance* context, bool testInDatamodel = true);

    static int getPlayerCount(const Aya::Instance* context);

    // TODO: Remove this some day!
    static bool getDistributedPhysicsEnabled();

    ///////////////////////////////////////////////////////////////////////////
    //
    // These are here as "official" designation of Big-Picture states
    //
    //						Frontend	Backend
    // GameServer:						x		serverIsPresent (assumes !findLocalPlayer)
    // Visit Online:		x					clientIsPresent && findLocalPlayer
    // Watch Online:		x					clientIsPresent && !findLocalPlayer	(i.e. - visit, no character)
    // Visit Solo:			x			x		!clientIsPresent && !serverIsPresent && findLocalPlayer
    // Local Play:			x					clientIsPresent && findLocalPlayer && userID == 0
    // Edit Mode:			x			x		!clientIsPresent && !serverIsPresent && !findLocalPlayer
    //
    // typedef enum {GAME_SERVER, DPHYS_GAME_SERVER, CLIENT, DPHYS_CLIENT, WATCH_ONLINE, VISIT_SOLO, EDIT} GameMode;

    static Aya::Network::GameMode getGameMode(const Aya::Instance* context)
    {
        bool client = clientIsPresent(context);
        bool server = serverIsPresent(context);
        bool localPlayer = (findConstLocalPlayer(context) != NULL);
        bool dPhysics = getDistributedPhysicsEnabled();

        AYAASSERT(!(server && (client || localPlayer)));

        if (server)
        {
            return dPhysics ? DPHYS_GAME_SERVER : GAME_SERVER;
        }
        if (client && localPlayer)
        {
            return dPhysics ? DPHYS_CLIENT : CLIENT;
        }
        if (client && !localPlayer)
        {
            return WATCH_ONLINE;
        }
        if (!client && localPlayer)
        {
            return VISIT_SOLO;
        }
        else
        {
            return EDIT;
        }
    }

    static Aya::Network::GameMode getGameMode(const Aya::Instance* context, const int placeID)
    {
        bool client = clientIsPresent(context);
        bool server = serverIsPresent(context);
        bool localPlayer = (findConstLocalPlayer(context) != NULL);
        bool dPhysics = getDistributedPhysicsEnabled();

        AYAASSERT(!(server && (client || localPlayer)));
        ;

        if (placeID <= 0)
        {
            return LOCAL_PLAY;
        }
        if (server)
        {
            return dPhysics ? DPHYS_GAME_SERVER : GAME_SERVER;
        }
        if (client && localPlayer)
        {
            return dPhysics ? DPHYS_CLIENT : CLIENT;
        }
        if (client && !localPlayer)
        {
            return WATCH_ONLINE;
        }
        if (!client && localPlayer)
        {
            return VISIT_SOLO;
        }
        else
        {
            return EDIT;
        }
    }

    void onRemoteSysStats(int userId, const std::string& stat, const std::string& message, bool desireKick = true);
    bool hashMatches(const std::string& hash);

    void disconnectPlayer(int userId, int reason);
    void disconnectPlayerLocal(int userId, int reason);

    bool getUseCoreScriptHealthBar();

protected:
    void disconnectPlayer(Instance& instance, int userId, int reason);

    std::map<int, std::set<std::string>> cheatingPlayers;
    bool askAddChild(const Instance* instance) const;
    /*override*/ void onChildAdded(Instance* child);
    /*override*/ void onChildRemoving(Instance* child);
    /*override*/ void onDescendantRemoving(const shared_ptr<Instance>& instance);
    /*override*/ void processRemoteEvent(
        const Reflection::EventDescriptor& descriptor, const Reflection::EventArguments& args, const Aya::SystemAddress& source);

private:
    void reportScriptSecurityError(int userId, std::string hash, std::string error, std::string stack);

    void killPlayer(int userId);

    void addChatMessage(const ChatMessage& message);

    void checkChat(const std::string& message);

    void sendFilteredChatMessageSignalHelper(const RakNet::SystemAddress& systemAddress, const shared_ptr<RakNet::BitStream>& baseData,
        const shared_ptr<Instance> sourceInstance, shared_ptr<ChatMessage> chatEvent, const ChatFilter::Result& response);

    // Instance
    /*override*/ void onServiceProvider(ServiceProvider* oldProvider, ServiceProvider* newProvider);
};

} // namespace Network
} // namespace Aya