//
//  NodeList.h
//  libraries/networking/src
//
//  Created by Stephen Birarda on 2/15/13.
//  Copyright 2013 High Fidelity, Inc.
//  Copyright 2021 Vircadia contributors.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//

#ifndef hifi_NodeList_h
#define hifi_NodeList_h

#include <stdint.h>
#include <iterator>
#include <assert.h>

#ifndef _WIN32
#include <unistd.h> // not on windows, not needed for mac or windows
#endif

#include <TBBHelpers.h>

#include <QtCore/QElapsedTimer>
#include <QtCore/QMutex>
#include <QtCore/QSet>
#include <QtCore/QSharedPointer>
#include <QtNetwork/QHostAddress>
#include <QtNetwork/QUdpSocket>

#include <DependencyManager.h>
#include <SettingHandle.h>

#include "DomainHandler.h"
#include "LimitedNodeList.h"
#include "Node.h"

const quint64 DOMAIN_SERVER_CHECK_IN_MSECS = 1 * 1000;

using PacketOrPacketList = std::pair<std::unique_ptr<NLPacket>, std::unique_ptr<NLPacketList>>;
using NodePacketOrPacketListPair = std::pair<SharedNodePointer, PacketOrPacketList>;

using NodePacketPair = std::pair<SharedNodePointer, std::unique_ptr<NLPacket>>;
using NodeSharedPacketPair = std::pair<SharedNodePointer, QSharedPointer<NLPacket>>;
using NodeSharedReceivedMessagePair = std::pair<SharedNodePointer, QSharedPointer<ReceivedMessage>>;

class Application;
class Assignment;

class NodeList : public LimitedNodeList {
    Q_OBJECT
    SINGLETON_DEPENDENCY

public:
    void startThread();
    NodeType_t getOwnerType() const { return _ownerType.load(); }
    void setOwnerType(NodeType_t ownerType) { _ownerType.store(ownerType); }

    Q_INVOKABLE qint64 sendStats(QJsonObject statsObject, SockAddr destination);
    Q_INVOKABLE qint64 sendStatsToDomainServer(QJsonObject statsObject);

    DomainHandler& getDomainHandler() { return _domainHandler; }

    const NodeSet& getNodeInterestSet() const { return _nodeTypesOfInterest; }
    void addNodeTypeToInterestSet(NodeType_t nodeTypeToAdd);
    void addSetOfNodeTypesToNodeInterestSet(const NodeSet& setOfNodeTypes);
    void resetNodeInterestSet() { _nodeTypesOfInterest.clear(); }

    void setAssignmentServerSocket(const SockAddr& serverSocket) { _assignmentServerSocket = serverSocket; }
    void sendAssignment(Assignment& assignment);

    void disableDomainPortAutoDiscovery(bool disabled = false) { _domainPortAutoDiscovery = !disabled; };

    void setIsShuttingDown(bool isShuttingDown) { _isShuttingDown = isShuttingDown; }

    void ignoreNodesInRadius(bool enabled = true);
    bool getIgnoreRadiusEnabled() const { return _ignoreRadiusEnabled.get(); }
    void toggleIgnoreRadius() { ignoreNodesInRadius(!getIgnoreRadiusEnabled()); }
    void enableIgnoreRadius() { ignoreNodesInRadius(true); }
    void disableIgnoreRadius() { ignoreNodesInRadius(false); }
    void ignoreNodeBySessionID(const QUuid& nodeID, bool ignoreEnabled);
    bool isIgnoringNode(const QUuid& nodeID) const;
    void personalMuteNodeBySessionID(const QUuid& nodeID, bool muteEnabled);
    bool isPersonalMutingNode(const QUuid& nodeID) const;
    void setAvatarGain(const QUuid& nodeID, float gain);
    float getAvatarGain(const QUuid& nodeID);
    void setInjectorGain(float gain);
    float getInjectorGain();

    void kickNodeBySessionID(const QUuid& nodeID, unsigned int banFlags);
    void muteNodeBySessionID(const QUuid& nodeID);
    void requestUsernameFromSessionID(const QUuid& nodeID);
    bool getRequestsDomainListData() { return _requestsDomainListData; }
    void setRequestsDomainListData(bool isRequesting);

    bool getSendDomainServerCheckInEnabled() { return _sendDomainServerCheckInEnabled; }
    void setSendDomainServerCheckInEnabled(bool enabled) { _sendDomainServerCheckInEnabled = enabled; }

    void removeFromIgnoreMuteSets(const QUuid& nodeID);

    virtual bool isDomainServer() const override { return false; }
    virtual QUuid getDomainUUID() const override { return _domainHandler.getUUID(); }
    virtual Node::LocalID getDomainLocalID() const override { return _domainHandler.getLocalID(); }
    virtual SockAddr getDomainSockAddr() const override { return _domainHandler.getSockAddr(); }

public slots:
    void reset(QString reason, bool skipDomainHandlerReset = false);
    void resetFromDomainHandler() { reset("Reset from Domain Handler", true); }

    void sendDomainServerCheckIn();
    void handleDSPathQuery(const QString& newPath);

    void processDomainList(QSharedPointer<ReceivedMessage> message);
    void processDomainServerAddedNode(QSharedPointer<ReceivedMessage> message);
    void processDomainServerRemovedNode(QSharedPointer<ReceivedMessage> message);
    void processDomainServerPathResponse(QSharedPointer<ReceivedMessage> message);

    void processDomainServerConnectionTokenPacket(QSharedPointer<ReceivedMessage> message);

    void processPingPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);
    void processPingReplyPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);

    void processICEPingPacket(QSharedPointer<ReceivedMessage> message);

    void processUsernameFromIDReply(QSharedPointer<ReceivedMessage> message);

    // FIXME: Can remove these work-arounds in version 2021.2.0. (New protocol version implies a domain server upgrade.)
    bool adjustCanRezAvatarEntitiesPermissions(const QJsonObject& domainSettingsObject, NodePermissions& permissions,
        bool notify);
    void adjustCanRezAvatarEntitiesPerSettings(const QJsonObject& domainSettingsObject);

#if (PR_BUILD || DEV_BUILD)
    void toggleSendNewerDSConnectVersion(bool shouldSendNewerVersion) { _shouldSendNewerVersion = shouldSendNewerVersion; }
#endif

signals:
    void receivedDomainServerList();
    void ignoredNode(const QUuid& nodeID, bool enabled);
    void ignoreRadiusEnabledChanged(bool isIgnored);
    void usernameFromIDReply(const QString& nodeID, const QString& username, const QString& machineFingerprint, bool isAdmin);

private slots:
    void stopKeepalivePingTimer();
    void sendPendingDSPathQuery();
    void handleICEConnectionToDomainServer();

    void startNodeHolePunch(const SharedNodePointer& node);
    void handleNodePingTimeout();

    void pingPunchForDomainServer();

    void sendKeepAlivePings();

    void maybeSendIgnoreSetToNode(SharedNodePointer node);

private:
    Q_DISABLE_COPY(NodeList)
    NodeList() : LimitedNodeList(INVALID_PORT, INVALID_PORT) { 
        assert(false);  // Not implemented, needed for DependencyManager templates compile
    }
    NodeList(char ownerType, int socketListenPort = INVALID_PORT, int dtlsListenPort = INVALID_PORT);

    void processDomainServerAuthRequest(const QByteArray& packet);
    void requestAuthForDomainServer();
    void activateSocketFromNodeCommunication(ReceivedMessage& message, const SharedNodePointer& sendingNode);
    void timePingReply(ReceivedMessage& message, const SharedNodePointer& sendingNode);

    void sendDSPathQuery(const QString& newPath);

    void parseNodeFromPacketStream(QDataStream& packetStream);

    void pingPunchForInactiveNode(const SharedNodePointer& node);

    bool sockAddrBelongsToDomainOrNode(const SockAddr& sockAddr);

    std::atomic<NodeType_t> _ownerType;
    NodeSet _nodeTypesOfInterest;
    DomainHandler _domainHandler;
    SockAddr _assignmentServerSocket;
    bool _isShuttingDown { false };
    QTimer _keepAlivePingTimer;
    bool _requestsDomainListData { false };

    bool _sendDomainServerCheckInEnabled { true };
    bool _domainPortAutoDiscovery { true };

    mutable QReadWriteLock _ignoredSetLock;
    tbb::concurrent_unordered_set<QUuid, UUIDHasher> _ignoredNodeIDs;
    mutable QReadWriteLock _personalMutedSetLock;
    tbb::concurrent_unordered_set<QUuid, UUIDHasher> _personalMutedNodeIDs;
    mutable QReadWriteLock _avatarGainMapLock;
    tbb::concurrent_unordered_map<QUuid, float, UUIDHasher> _avatarGainMap;

    std::atomic<float> _avatarGain { 0.0f };    // in dB
    std::atomic<float> _injectorGain { 0.0f };  // in dB

    void sendIgnoreRadiusStateToNode(const SharedNodePointer& destinationNode);
#if defined(Q_OS_ANDROID)
    Setting::Handle<bool> _ignoreRadiusEnabled { "IgnoreRadiusEnabled", false };
#else
    Setting::Handle<bool> _ignoreRadiusEnabled { "IgnoreRadiusEnabled", false }; // False, until such time as it is made to work better.
#endif

#if (PR_BUILD || DEV_BUILD)
    bool _shouldSendNewerVersion { false };
#endif

    bool _hasDomainAccountManager { false };
};

#endif // hifi_NodeList_h