#pragma once

#include "logger.h"

#include <CoPrtCnv/tetra_telegram_ids.h>
#include <nglsettings/nglsettings_settings.h>
#include <TrainingAreaBase/training_area_telegrams.h>

#include <QObject>
#include <QHash>
#include <QMap>
#include <QSet>
#include <map>
#include <memory>
#include <vector>

namespace N_CoPrtCnv
{
class CoPrtCnvRadioTelegram;
}

#define MAX_BROADCAST_INDEX 65535


namespace PrtCnv
{
class PrtCnvDbThread;



class PrtCnvBroadcastMgr final : public QObject
{
  Q_OBJECT
public:

  

  enum E_State
  {
    e_ST_UNDEFINED,
    e_ST_COLLECT,
    e_ST_SEND_NACHFORDERUNG
  };

  PrtCnvBroadcastMgr();

  

  bool handleRadioTelegram(const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram);


  

  int32_t create(NGL::Settings *settings);

  

  int32_t init();

  

  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNextBroadcastTelegramToSend(const uint16_t a_beginSearchWithBroadcastIndex,
                                                                                    const time_t a_currentTime);

  

  void setDbThread(PrtCnvDbThread *a_dbThread);


  

  void cleanAndInit(const bool a_deleteTelegrams);


  

  void handleOverrunOfBroadcastCounter(const bool a_doRestore = false);

  

  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNextNachforderungTelegramToSend();

  

  void dump();


  

  void restoreAfterCrash();


  

  uint16_t getBroadcastIndex() const;

  

  uint16_t getNextBroadcastIndex();

  

  void addBroadcastOnlyTelegramToMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_broadcastOnlyTelegram);

  

  void incTickAndSetTrafficLoad(const bool a_isHighLoad, const bool a_isFullLoad);

  

  bool isEffectSimulationIdDeactivated(const uint16_t effectsimulationId) const;

  

  void handleNachforderungBroadcastTelegram(int identity, int broadcastIndex, int resetCounter);

protected:
  struct EquipNoBcIndex
  {
    int equipNo = 0;
    int bcIndex = 0;

    EquipNoBcIndex() = default;
    EquipNoBcIndex(int e, int b) : equipNo(e), bcIndex(b) {}
  };
  

  std::vector<EquipNoBcIndex> m_claimerArray;
  

  uint16_t m_ClaimWindow;
  

  uint16_t m_HighLoadFactor;
  

  uint16_t m_BroadcastLimit;
  

  NGL::Settings *m_Config;
  

  uint16_t m_ActClaimWindow;
  

  PrtCnvBroadcastMgr::E_State m_State;
  uint16_t m_TickCounter;
  

  PrtCnvDbThread *m_DbThread;


  

  std::map<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_BroadcastMap;

  std::vector<std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_broadcastTelegamsToSend;

  

  std::map<gef_telegramm_id_et, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_LastTelegramMap;


  

  std::multimap<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_WirkfeldTelegramMapByKennung;


  

  std::multimap<time_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_WirkfeldTelegramMapByTime;


  

  std::map<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_FunktionsraumTelegramMap;


  

  std::map<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>> m_TechnikFunktionsraumTelegramMap;


  

  uint16_t m_BroadcastIndex;

  

  bool m_IsFullLoad;
  

  uint16_t m_FinishedBroadcastIndex;
  

  uint16_t m_FirstBroadcastIndexOfBc1;

  

  void addToBroadcastMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);

  

  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNachforderungsTelegram(int curBcIndex, int startBcIndex, int &nextBcIndex);

  

  int getSammeltelegramIndex(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_sammelTelegram,
                             const uint16_t a_kennung) const;

  

  void moveTelegramInBroadcastMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram,
                                  const uint16_t a_newBroadcastIndex,
                                  const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_attachTelegram = {});

  

  void removeFromBroadcastMap(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);
  void removeFromBroadcastMapFunc(const std::function<bool(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &)> &pred);
  void removeDusMineDeactivationFromBroadcastMap(int dusMineId);

  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccumulationTelegram(int curBcIndex,
                                                                                int startBcIndex,
                                                                                gef_telegramm_id_et telId,
                                                                                const QMap<int, int> &bcIndex2Type,
                                                                                int maxIdsPerTelegram,
                                                                                int sizeOfSumField) const;

  bool removeFromDeactivatedAesArea(int aesAreaId);
  bool addToDeactivatedAesArea(int aesAreaId, int bcIndex);
  
  QHash<int, int> m_deactivatedAesArea2bcIndex;
  
  QMap<int, int> m_deactivatedBcIndex2AesArea;
  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>createAccuTeleDeactivatedAesAreas(int curBcIndex, int startBcIndex) const;

  bool removeFromDeactivatedFuncArea(int aesAreaId);
  bool addToDeactivatedFuncArea(int aesAreaId, int bcIndex);
  
  QHash<int, int> m_deactivatedFuncArea2bcIndex;
  
  QMap<int, int> m_deactivatedBcIndex2FuncArea;
  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>createAccuTeleDeactivatedFuncAreas(int curBcIndex, int startBcIndex) const;

  bool removeFromDeactivatedDusMine(int dusMineId);
  bool addToDeactivatedDusMine(int dusMineId, int bcIndex);
  
  QHash<int, int> m_deactivatedDusMine2bcIndex;
  
  QMap<int, int> m_deactivatedBcIndex2DusMine;
  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccuTeleDeactivatedDusMines(int curBcIndex, int startBcIndex) const;

  bool removeFromActivatedDusMine(int dusMineId);
  void addToActivatedDusMine(int dusMineId);
  QSet<int> m_activatedDusMines;
  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> createAccuTeleActivatedDusMines(int curBcIndex);

  

  bool removeFromSammeltelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_sammelTelegram,
                                const uint16_t a_kennung,
                                const uint16_t a_anzahlPos,
                                const uint8_t a_anzahlSize,
                                bool &a_sammelTelRemoved);

  

  void replaceLastTelegramAndAddAtEnd(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_newRadioTelegram);


  

  std::string dumpSammeldeaktivierung(const N_CoPrtCnv::CoPrtCnvRadioTelegram *sammelTelegram);

  

  void getAllFinishedBroadcastsFromDb(const bool a_doRestore = false);


  

  void removeExpiredTelegrams();

  

  void removeWirkfeldTelegrams(const uint16_t a_kennung);

  

  void addWirkfeldTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram,
                           const uint16_t a_wirkfeldKennung, const gef_telegramm_id_et a_telId = GEF_BESTAETIGUNG,
                           const uint16_t a_minenKennung = 0);

  

  bool deactivateEinzelmineFromMinensperre(const uint16_t a_wirkfeldKennung, const uint16_t a_minenKennung, const uint16_t a_broadcastIndex);

  

  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> getNopTelegram(const uint16_t a_from, const uint16_t a_to);
  

  void removeFromAllMaps(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);

  

  void detachTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);

  

  void removeFromFunktionsAndBroadcastMaps(const uint16_t a_funktionsraumKennung);
  void removeFromTechnikFunktionsAndBroadcastMaps(const uint16_t a_funktionsraumKennung);

  

  void removeFromWirkfeldAndBroadcastMaps(const std::multimap<uint16_t, std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram>>::iterator &a_wirkfeldTelegramMapByKennungIterator);

  

  void reactivateDusMine(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);

  

  void deactivateSingleMine(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_radioTelegram);

  

  void prepareForSendNachforderungen();

  

  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> evaluateNextNachforderungToSend();

Q_SIGNALS:
  void areaEffectSimulationActivated(int wirkfeldKennung);
  void areaEffectSimulationDeactivated(int wirkfeldKennung);

private:
  

  NGL::INGLLogger &m_logger;
  NGL::INGLLogger &m_loggerBcRequest;
};

}