#pragma once

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

using namespace std;

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

class SAD_DetectedServer {
  public:
    SAD_DetectedServer(string p_Name, string p_ID, string p_ComputerName,
                       string p_IP, string p_Port, string p_ClientIP,
                       string p_Additions, string projName)
        : m_Name(p_Name),
          m_ID(p_ID),
          m_ComputerName(p_ComputerName),
          m_IP(p_IP),
          m_Port(p_Port),
          m_ClientIP(p_ClientIP),
          m_Additions(p_Additions),
          m_ServerProjectName(projName) {
    }

  private:
    string m_Name{};
    string m_ID{};
    string m_ComputerName{};
    string m_IP{};
    string m_Port{};
    string m_ClientIP{};
    string m_Additions{};
    string m_ServerProjectName{};
    bool m_New{true};
    bool m_Changed{};
    bool m_FoundAgain{};

  public:
    string getID() const { return m_ID; }
    string getName() const { return m_Name; }
    string getComputerName() const { return m_ComputerName; }
    string getIP() const { return m_IP; }
    string getPort() const { return m_Port; }
    string getClientIP() const { return m_ClientIP; }
    string getAdditions() const { return m_Additions; }
    string getProjectName() const { return m_ServerProjectName; }
    bool getNew() const { return m_New; }
    bool getChanged() const { return m_Changed; }
    bool getFoundAgain() const { return m_FoundAgain; }

    void setChanged() { m_Changed = true; }
    void setKnown() { m_New = false; }
    void setFoundAgain() { m_FoundAgain = true; }
    void updateProjectName(string newProjectName) {
        m_ServerProjectName = newProjectName;
        if (m_ServerProjectName != newProjectName) {
            m_Changed = true;
        }
    }

    // SAD_Client m_ThreadSend will send to Multicast addresses
    void resetFlags() {
        m_Changed = false;
        m_FoundAgain = false;
        m_New = false;
    }

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

  public:
    static constexpr int PARAMINDEX_PRECODE = 0;
    static constexpr int PARAMINDEX_SPITTASKID = 1;
    static constexpr int PARAMINDEX_NAME = 2;
    static constexpr int PARAMINDEX_ID = 3;
    static constexpr int PARAMINDEX_COMPUTERNAME = 4;
    static constexpr int PARAMINDEX_PORT = 5;
    static constexpr int PARAMINDEX_CLIENTIP = 6;
    static constexpr int PARAMINDEX_ADDITIONS = 7;
    static constexpr int PARAMINDEX_SERVERPROJECTNAME = 8;
    static constexpr int PARAMINDEX_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<SAD_DetectedServer> 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(SAD_DetectedServer &server) {
        auto i = sKnownServers.find(server.getID());
        if (i != sKnownServers.end()) {
            i = 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
     * @param p_SADClientInterface
     */
    static void evaluateDetectedServers(I_SAD_Client &sadClient) {
        for (auto &srv : sKnownServers) {
            SAD_DetectedServer &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 p_ServerID the id of the SPITServer
     * @return the reference of the SAD_DetectedServer instance with getID() == p_ServerID
     */
    static const SAD_DetectedServer &getRefDetectedServer(const string &id) {
        return *sKnownServers.at(id);
    }
};