1NiM-WatingRoom-WatchController/components/spit/include/sad_DetectedServer.hpp

#pragma once

#include <list>
#include <memory>
#include <string>
#include <unordered_map>

using namespace std;

namespace spit {

class SadDetectedServer;
class ISadClient {
  public:
    virtual void eventServerDetected(SadDetectedServer &server) = 0;
    virtual void eventServerChanged(SadDetectedServer &server) = 0;
    virtual void eventServerLost(SadDetectedServer &server) = 0;
};

class SadDetectedServer {
  public:
    SadDetectedServer(string name, string iD, string computerName,
                       string iP, string port, string clientIP,
                       string additions, string projName)
        : mName(name),
          mID(iD),
          mComputerName(computerName),
          mIP(iP),
          mPort(port),
          mClientIP(clientIP),
          mAdditions(additions),
          mServerProjectName(projName) {
    }

  private:
    string mName{};
    string mID{};
    string mComputerName{};
    string mIP{};
    string mPort{};
    string mClientIP{};
    string mAdditions{};
    string mServerProjectName{};
    bool mNew{true};
    bool mChanged{};
    bool mFoundAgain{};

  public:
    string getID() const { return mID; }
    string getName() const { return mName; }
    string getComputerName() const { return mComputerName; }
    string getIP() const { return mIP; }
    string getPort() const { return mPort; }
    string getClientIP() const { return mClientIP; }
    string getAdditions() const { return mAdditions; }
    string getProjectName() const { return mServerProjectName; }
    bool getNew() const { return mNew; }
    bool getChanged() const { return mChanged; }
    bool getFoundAgain() const { return mFoundAgain; }

    void setChanged() { mChanged = true; }
    void setKnown() { mNew = false; }
    void setFoundAgain() { mFoundAgain = true; }
    void updateProjectName(string newProjectName) {
        mServerProjectName = newProjectName;
        if (mServerProjectName != newProjectName) {
            mChanged = true;
        }
    }

    // SAD_Client mThreadSend will send to Multicast addresses
    void resetFlags() {
        mChanged = false;
        mFoundAgain = false;
        mNew = false;
    }

  private:
    static unordered_map<string, unique_ptr<SadDetectedServer>> sKnownServers;

  public:
    enum ParamIndex {
        PARAM_PRECODE = 0,
        PARAM_SPITTASKID = 1,
        PARAM_NAME = 2,
        PARAM_ID = 3,
        PARAM_COMPUTERNAME = 4,
        PARAM_PORT = 5,
        PARAM_CLIENTIP = 6,
        PARAM_ADDITIONS = 7,
        PARAM_SERVERPROJECTNAME = 8,
        PARAM_IP = 9,
    };
    
    /**
     * Used by SAD_Client to add a found SPITServer - don't use this manually
     * @param id the id of the server, every instance of a SPITServer has an own id
     * @param p_ServerParams the server's parameter
     */
    static void addDetectedServer(unique_ptr<SadDetectedServer> detected) {
        if (auto i = sKnownServers.find(detected->getID()); i != sKnownServers.end()) {
            auto &known = *(i->second.get());
            known.setFoundAgain();
            if (detected->getProjectName() != known.getProjectName()) {
                known.updateProjectName(detected->getProjectName());
            }
            return;
        }
        sKnownServers[detected->getID()] = move(detected);
    }
    static void removeDetectedServer(SadDetectedServer &server) {
        auto i = sKnownServers.find(server.getID());
        if (i != sKnownServers.end()) {
            sKnownServers.erase(i);
        }
    }
    static void clearDetectedServers() {
        sKnownServers.clear();
    }

    static void resetServerFlags() {
        for (auto &srv : sKnownServers) {
            srv.second->resetFlags();
        }
    }
    /**
     * Used by SAD_Client internally -don't use this manually
     */
    static void evaluateDetectedServers(ISadClient &sadClient) {
        for (auto &srv : sKnownServers) {
            SadDetectedServer &known = *srv.second;
            if (known.getNew()) {
                known.setKnown();
                sadClient.eventServerDetected(known);
            } else if (known.getChanged()) {
                sadClient.eventServerChanged(known);
            } else if (known.getFoundAgain() == false) {
                sadClient.eventServerLost(known);
                removeDetectedServer(known);
            }
        }
    }

    /**
     * Returns a reference of the DetectedServer with the id p_ServerID.<br>
     * If no DetectedServer is found an eyception is thrown.
     * @param id the id of the SPITServer
     * @return the reference of the SadDetectedServer instance with getID() == p_ServerID
     */
    static const SadDetectedServer &getRefDetectedServer(const string &id) {
        return *sKnownServers.at(id);
    }
};

}