// **************************************************************************
//
//  (C) Copyright 2009   Swiss SIMTEC AG
//
// **************************************************************************
//
//  $HeadURL$
//  $LastChangedBy$
//  $LastChangedDate$
//  $LastChangedRevision$
//
//  Implementation of the Class PrtCnvDbThread
// **************************************************************************
#include "PrtCnvDbThread.hpp"
#include "PrtCnvThreadStarter.hpp"
#include "PrtCnvCentralThread.hpp"
#include "PrtCnvMember.hpp"
#include "PrtCnvRadioThread.hpp"
#include "PrtCnvStoredCentralTelegram.hpp"
#include "PrtCnvStoredRadioTelegram.hpp"
#include <CoPrtCnv/CoPrtCnvRadioTelegram.hpp>
#include <CoPrtCnv/CoPrtCnvTelegramConverter.hpp>
#include <CoPrtCnv/CoPrtCnvCentralTelegram.hpp>
#include <CoPrtCnv/CoPrtCnvHexDumpHelper.hpp>
#include <QtCore/QCoreApplication>
#include <QtCore/QDir>
#include <ngldb/dbtransaction.h>
#include <ngldb/nsqlquery.h>
#include <QtSql/QSqlError>
#include <iostream>

namespace PrtCnv
{

// ---------------------------------------------------------------
// Constructor with thread-starter as argument
// ---------------------------------------------------------------
PrtCnvDbThread::PrtCnvDbThread(const QString &dbDriver,
                               const QString &dbHostName,
                               const QString &dbDatabaseName,
                               const QString &schemaName,
                               const QString &dbUserName,
                               const QString &dbPassword,
                               PrtCnv::PrtCnvThreadStarter *a_parent)
  : PrtCnvThread(a_parent, "PrtCnvDbThread")
  , m_BattleFieldOpStateMutex(QMutex::Recursive)
  , m_MemberListByIdMutex(QMutex::Recursive)
  , m_CentralListMutex(QMutex::Recursive)
  , m_OldCentralAckCounter(0)
  , m_RadioListMutex(QMutex::Recursive)
  , m_SqlCmdListMutex(QMutex::Recursive)
  , m_BroadcastMapMutex(QMutex::Recursive)
  , m_DoClean(false)
  , m_DoWaitUntilSqlWritten(false)
  , m_DoStorePermanent(false)
  , m_ResetCounter(0)
  , m_BattleFieldOperatingState(0)
  , m_EnvironmentTelegram(nullptr)
  , m_DoProceedCleanup(false)
  , m_OldCentralCounter(0)
  , m_StorePermanentPending(0)
  , m_NbrOfAttempts(5)
  , m_dbDriver(dbDriver.isEmpty() ? QStringLiteral("QSQLITE") : dbDriver)
  , m_dbHostName(dbHostName)
  , m_dbDatabaseName(dbDatabaseName)
  , m_dbSchemaName(schemaName)
  , m_dbUserName(dbUserName)
  , m_dbPassword(dbPassword)
{
  m_Name = QStringLiteral("Db");
}


PrtCnvDbThread::~PrtCnvDbThread()
{
  closeDb();
  qDeleteAll(m_BroadcastList);
  qDeleteAll(m_RadioList);
  qDeleteAll(m_CentralList);
  for (const auto &p : m_MemberListById)
    delete p.second;
}


// ---------------------------------------------------------------
// reinit database
// ---------------------------------------------------------------
static const int s_iCurrentDatabaseSchemeVersion = 1;
void PrtCnvDbThread::reinitDatabase()
{
  DBTransaction trans(m_db);
  NSqlQuery q(m_db);
  if (m_db.driverName() == QStringLiteral("QSQLITE"))
  {
    q.exec(QStringLiteral("DROP TABLE IF EXISTS %1;").arg(versionTableName()));
    q.exec(QStringLiteral("CREATE TABLE %1 ("
                          "version integer,"
                          "date text,"
                          "product text,"
                          "change text)").arg(versionTableName()));
    q.exec(QStringLiteral("INSERT INTO %1 (version, date, product, change) VALUES "
                          "(1, '2012-11-20', 'TetraInterface', 'Initial version table');").arg(versionTableName()));

    q.exec(QStringLiteral("DROP TABLE IF EXISTS %1;").arg(toCentralTableName()));
    q.exec(QStringLiteral("CREATE TABLE %1 ("
                          "id INTEGER PRIMARY KEY AUTOINCREMENT,"
                          "tel_id INTEGER,"
                          "counter INTEGER DEFAULT 0,"
                          "data BLOB);").arg(toCentralTableName()));
    q.exec(QStringLiteral("CREATE INDEX counterIndex ON %1(counter);").arg(toCentralTableName()));

    q.exec(QStringLiteral("DROP TABLE IF EXISTS %1;").arg(toRadioTableName()));
    q.exec(QStringLiteral("CREATE TABLE %1 ("
                          "id INTEGER PRIMARY KEY AUTOINCREMENT,"
                          "tel_id INTEGER,"
                          "counter INTEGER DEFAULT 0,"
                          "broadcast_index INTEGER DEFAULT 0,"
                          "reset_counter INTEGER DEFAULT 0,"
                          "data BLOB);").arg(toRadioTableName()));
    q.exec(QStringLiteral("CREATE INDEX bcindex ON %1(reset_counter, broadcast_index);").arg(toRadioTableName()));

    q.exec(QStringLiteral("DROP TABLE IF EXISTS %1;").arg(memberTableName()));
    q.exec(QStringLiteral("CREATE TABLE %1 ("
                          "id INTEGER PRIMARY KEY,"
                          "issi INTEGER,"
                          "licensed INTEGER DEFAULT 0,"
                          "claims INTEGER DEFAULT 0,"
                          "exercise_id INTEGER"
                          ");").arg(memberTableName()));

    q.exec(QStringLiteral("DROP TABLE IF EXISTS %1;").arg(statusTableName()));
    q.exec(QStringLiteral("CREATE TABLE %1 ("
                          "id INTEGER PRIMARY KEY,"
                          "reset_counter INTEGER,"
                          "ctas_operating_state INTEGER,"
                          "machine_state INTEGER" /* 0=>normal; 1=>DB-cleanup*/
                          ");").arg(statusTableName()));
  }

  q.exec(QStringLiteral("DELETE FROM %1 WHERE id = 1;").arg(statusTableName()));
  q.exec(QStringLiteral("INSERT INTO %1 "
                        "(id, reset_counter, ctas_operating_state, machine_state) "
                        "VALUES (1, %2, %3, 0);")
         .arg(statusTableName()).arg(int(m_ResetCounter)).arg(int(m_BattleFieldOperatingState)));

  q.exec(QStringLiteral("DELETE FROM %1 WHERE id = 0;").arg(memberTableName()));

  trans.commit();
}

// ---------------------------------------------------------------
// creates or restores the permanent database
// ---------------------------------------------------------------
bool PrtCnvDbThread::createDatabase()
{
  closeDb();

  m_db = QSqlDatabase::addDatabase(m_dbDriver, QStringLiteral("PrtCnv"));
  if (m_dbDriver == QLatin1String("QSQLITE"))
  {
    QString path = m_Config->getString(getName(), QStringLiteral("DatabaseFileName"), QStringLiteral("telegrams.db"));
    if (!QDir::isAbsolutePath(path))
    {
      path = QCoreApplication::applicationDirPath() + QLatin1String("/../") + path;
      QFileInfo fi(path);
      QDir().mkpath(fi.absolutePath());
    }
    m_db.setDatabaseName(path);
    INFO_LOG(m_logger) << "Use db-file: " << path;
    std::cout << "Use db-file: " << qPrintable(path) << std::endl;
  }
  else
  {
    m_db.setDatabaseName(m_dbDatabaseName);
    m_db.setHostName(m_dbHostName);
    m_db.setUserName(m_dbUserName);
    m_db.setPassword(m_dbPassword);
  }


  DEBUG_LOG(m_logger) << "Connection name: " << m_db.connectionName();

  if (!m_db.open())
  {
    FATAL_LOG(m_logger) << "Error while opening database: " << m_db.lastError().text();
    return false;
  }

  if (m_DoCleanDb)
  {
    NOTICE_LOG(m_logger) << "Permanent data will be erased...";
    reinitDatabase();
  }
  else
  {
    NOTICE_LOG(m_logger) << "Check database...";
    NSqlQuery q(m_db);
    if (m_db.driverName() == QStringLiteral("QSQLITE"))
    {
      if (!q.execAndFetch(QStringLiteral("SELECT MAX(version) FROM %1;").arg(versionTableName())))
      {
        ERROR_LOG(m_logger) << "Could not read version table - reinitialize database";
        reinitDatabase();
      }
      else
      {
        // check for correct version see version table in reinitDatabase()!
        int iVersion = q.value(0).toInt();
        if (iVersion != s_iCurrentDatabaseSchemeVersion)
        {
          ERROR_LOG(m_logger) << "Database version does not match (is: "
                              << iVersion << " expected: " << s_iCurrentDatabaseSchemeVersion
                              << " - reinitialize database";
          reinitDatabase();
        }
      }
    }

    if (!q.exec(QStringLiteral("SELECT * from %1 LIMIT 1;").arg(statusTableName())))
    {
      ERROR_LOG(m_logger) << "Failure while checking DB-table Status";
      std::cout << "Failure while checking DB-table Status. Start PrtCnv with --cleandb" << std::endl;
      return false;
    }
    if (!q.exec(QStringLiteral("SELECT * from %1 LIMIT 1;").arg(toCentralTableName())))
    {
      ERROR_LOG(m_logger) << "Failure while checking DB-table ToCentral";
      std::cout << "Failure while checking DB-table ToCentral. Start PrtCnv with --cleandb" << std::endl;
      return false;
    }
    if (!q.exec(QStringLiteral("SELECT * from %1 LIMIT 1;").arg(toRadioTableName())))
    {
      ERROR_LOG(m_logger) << "Failure while checking DB-table ToRadio";
      std::cout << "Failure while checking DB-table ToRadio. Start PrtCnv with --cleandb" << std::endl;
      return false;
    }
    // check whether the broadcast-member is ok
    if (!q.exec(QStringLiteral("SELECT issi FROM %1 WHERE id=0;").arg(memberTableName())))
    {
      ERROR_LOG(m_logger) << "Failure while checking DB-table Member";
      std::cout << "Failure while checking DB-table Member. Start PrtCnv with --cleandb" << std::endl;
      return false;
    }

    const int broadcastIssi = m_Config->getInteger(QStringLiteral("Radio"), QStringLiteral("BroadcastISSI"), 5000);
    if (q.next())
    {
      const int dbBroadcastIssi = q.value(0).toInt();
      if (broadcastIssi != dbBroadcastIssi)
      {
        WARNING_LOG(m_logger) << "Broadcast-ISSI mismatch (DB: " << dbBroadcastIssi << "; Configfile: " << broadcastIssi << ")";
        q.exec(QStringLiteral("DELETE FROM %1 WHERE id = 0;").arg(memberTableName()));
        licenseMember(addMember(0, broadcastIssi));
      }
    }
    else
    {
      licenseMember(addMember(0, broadcastIssi));
    }

    INFO_LOG(m_logger) << "Restore permanent data (after crash)...";
    m_DoStorePermanent = false;

    INFO_LOG(m_logger) << "restoreStatus";
    // restore important varibles
    if (!q.execAndFetch(QStringLiteral("SELECT reset_counter, ctas_operating_state, machine_state FROM %1;").arg(statusTableName())))
    {
      ERROR_LOG(m_logger) << "Error reading Status from DB";
      std::cout << "Error reading Status from DB. Start PrtCnv with --cleandb" << std::endl;
      return false;
    }
    m_ResetCounter = q.value(0).toInt();
    INFO_LOG(m_logger) << "Restore resetCounter=" << (int)m_ResetCounter;
    // check whether the crash happend just while cleaning up DB
    if (1 == q.value(2).toInt())
    {
      INFO_LOG(m_logger) << "Crash happenend while cleaning-DB";
      // crash while cleaning DB => clean-DB and restart
      m_DoStorePermanent = true;
      m_DoProceedCleanup = true;
      return true;
    }
    m_BattleFieldOperatingState = q.value(1).toInt();
    INFO_LOG(m_logger) << "Restore battleFieldOperatingState=" << (int)m_BattleFieldOperatingState;

    // restore the members
    if (!q.exec(QStringLiteral("SELECT id, issi, licensed, claims, exercise_id FROM %1;").arg(memberTableName())))
    {
      ERROR_LOG(m_logger) << "Error reading Member from DB";
      std::cout << "Error reading Member from DB. Start PrtCnv with --cleandb" << std::endl;
      return false;
    }

    while (q.next())
    {
      int id = q.value(0).toInt();
      int issi = q.value(1).toInt();
      bool licensed = q.value(2).toBool();
      int claims = q.value(3).toInt();
      int exerciseId = q.value(4).toInt();
      INFO_LOG(m_logger) << "Restore member: id=" << id << " issi=" << issi << " licensed=" << licensed
                         << " claims=" << claims << " exerciseId " << exerciseId;
      PrtCnvMember *member = addMember(id, issi);
      if (member)
      {
        member->m_ClaimCount = claims;
        member->m_loggedInExerciseId = exerciseId;
        if (licensed)
        {
         bool ok = licenseMember(member);
         if (ok)
         {
           //emit signal
           emit playerLicencedChanged(member->m_Id, N_CoPrtCnv::E_LicensingKind::Success);
         }
        }
      }
    }

    // restore radio-telegrams
    // Sortierung nach resetCounter + broadcastindex weil die Daten dann in
    // getAllFinishedBroadcastsFromDb() der Reihenfolge nach abholt werden
    // also müssen wir sie hier richtig herum in m_RadioList eintragen
    if (!q.exec(QStringLiteral("SELECT id, counter, broadcast_index, data "
                               "FROM %1 ORDER BY reset_counter, broadcast_index, id;").arg(toRadioTableName())))
    {
      ERROR_LOG(m_logger) << "Error reading from ToRadio table";
      std::cout << "Error reading from ToRadio table. Start PrtCnv with --cleandb" << std::endl;
      return false;
    }
    while (q.next())
    {
      const qint64 id = q.value(0).toLongLong();
      const int counter = q.value(1).toInt();
      const int bcIndex = q.value(2).toInt();
      const QByteArray telData(q.value(3).toByteArray());

      auto radioTelegram(std::make_shared<N_CoPrtCnv::CoPrtCnvRadioTelegram>(telData));
      PrtCnvStoredRadioTelegram *storedTelegram =
          new PrtCnvStoredRadioTelegram(radioTelegram);
      storedTelegram->m_Id = id;
      // --------------------------
      // ----------------------------
      if (0 == counter)
      {
        // telegram not yet sent to radio
        m_RadioList.push_back(storedTelegram);
        INFO_LOG(m_logger) << "Restore unsent radiotelegram: id=" << storedTelegram->m_Id
                           << " telId=" << storedTelegram->m_RadioTelegram->getTelID()
                           << " BC=" << storedTelegram->m_RadioTelegram->getBroadcastIndex()
                           << " counter=" << counter;
      }
      else
      {
        // telegram sent to radio
        if (bcIndex == 0)
        {
          if (radioTelegram->getTelID() == GEF_UMGEBUNGS_MELDUNG2)
            m_RadioList.push_back(storedTelegram);
          else
            delete storedTelegram; // normally not possible to get here, but just in case
        }
        else
        {
          // => broadcast-telegram
          radioTelegram->setBroadcastIndex(bcIndex);
          bool dummy;
          radioTelegram->mustBeSentAsBroadcast(0xFFFFFFFF, dummy);
          radioTelegram->mustBeSentAsBroadcast(0xFFFFFFFF, dummy);
          radioTelegram->mustBeSentAsBroadcast(0xFFFFFFFF, dummy);
          m_BroadcastList.push_back(storedTelegram);
          INFO_LOG(m_logger) << "Restore broadcast-radiotelegram: id="
                             << storedTelegram->m_Id << " telId=" << storedTelegram->m_RadioTelegram->getTelID()
                             << " BC=" << storedTelegram->m_RadioTelegram->getBroadcastIndex()
                             << " counter=" << counter;
        }
      }
    }

    // restore central-telegrams
    q.exec(QStringLiteral("UPDATE %1 SET counter=0;").arg(toCentralTableName())); // => resend all not acked telegrams
    if (!q.exec(QStringLiteral("SELECT id, data FROM %1 ORDER BY id;").arg(toCentralTableName())))
    {
      ERROR_LOG(m_logger) << "Error reading from ToCentral table";
      std::cout << "Error reading from ToCentral table. Start PrtCnv with --cleandb" << std::endl;
      return false;
    }
    while (q.next())
    {
      const qint64 id = q.value(0).toLongLong();
      const QByteArray telData(q.value(1).toByteArray());

      N_CoPrtCnv::CoPrtCnvRadioTelegram radioTelegram(telData);
      std::shared_ptr<N_CoPrtCnv::CoPrtCnvCentralTelegram>
          centralTelegram(N_CoPrtCnv::CoPrtCnvTelegramConverter::convertToCentral(&radioTelegram));
      if (centralTelegram)
      {
        PrtCnvStoredCentralTelegram *storedTelegram = new PrtCnvStoredCentralTelegram(centralTelegram, nullptr);
        storedTelegram->m_Id = id;
        m_CentralList.push_back(storedTelegram);
        INFO_LOG(m_logger) << "Restore unsent or unacked centraltelegram: id=" << storedTelegram->m_Id
                           << " telId=" << storedTelegram->m_CentralTelegram->telegramId()
                           << " counter=" << storedTelegram->m_WriteCounter
                           << " size=" << telData.size();
        //NGL::NGLLoggerHelper::hexDumpHelper(m_logger, NGL::LogLevel::Info, telData, blobSize);
      }
      else
        ERROR_LOG(m_logger) << "Internal error: conversion of telegram with telId=" << radioTelegram.getTelID() << " from radio to central failed";
    }

    if (m_db.driverName() == QLatin1String("QSQLITE"))
    {
      q.exec(QStringLiteral("VACUUM;"));
      q.exec(QStringLiteral("PRAGMA journal_mode=WAL;"));
      // Sync mode to NORMAL instead FULL - small speedup at the cost
      // of a little higher risk for data loss on power failure
      q.exec(QStringLiteral("PRAGMA synchronous=NORMAL;"));
    }
  }
  m_DoStorePermanent = true;

  return true;
}

// ---------------------------------------------------------------
// creates this thread and its childs
// ---------------------------------------------------------------
int32_t PrtCnvDbThread::create(NGL::Settings *settings)
{
  INFO_LOG(m_logger) << "create";
  PrtCnvThread::create(settings);
  m_NbrOfAttempts = m_Config->getInteger(QStringLiteral("Central"), QStringLiteral("NbrOfAttempts"), 5);
  if (!createDatabase())
  {
    ERROR_LOG(m_logger) << "Trying to create clean database after error";
    m_DoCleanDb = true;
    if (!createDatabase())
      exit(-2);
  }

  connect(this, &PrtCnvDbThread::doStorePermanent, this, &PrtCnvDbThread::storePermanent, Qt::QueuedConnection);
  connect(this, &PrtCnvDbThread::doClean, this, &PrtCnvDbThread::clean, Qt::QueuedConnection);

  PrtCnvCentralThread *centralThread = qobject_cast<PrtCnvCentralThread *>(m_Parent->getOtherThread(PrtCnvApplication::e_Central));
  connect(this, &PrtCnvDbThread::permanentStored, centralThread, &PrtCnvCentralThread::permanentStored, Qt::QueuedConnection);

  return 0;
}


// ---------------------------------------------------------------
// initializes this thread and its childs
// ---------------------------------------------------------------
int32_t PrtCnvDbThread::init()
{
  INFO_LOG(m_logger) << "init";
  PrtCnvThread::init();
  m_CentralAckCounter = 0;
  m_OldCentralAckCounter = 0;
  m_OldCentralCounter = 0;
  m_DoClean = false;
  m_DoWaitUntilSqlWritten = false;

  return 0;
}


// ---------------------------------------------------------------
// starts this thread and its childs
// ---------------------------------------------------------------
int32_t PrtCnvDbThread::start()
{
  INFO_LOG(m_logger) << "start";
  PrtCnvThread::start();

  return 0;
}


// ---------------------------------------------------------------
// stops this thread and its childs
// ---------------------------------------------------------------
int32_t PrtCnvDbThread::stop()
{
  PrtCnvThread::stop();
  m_db.close();
  m_db = QSqlDatabase();

  return 0;
}


// ---------------------------------------------------------------
// stores the telegram to be sent to central in working-list
// and also in Db. Because storing data in XDR_Wrapper_it-
// format is complicated (has pointer to data), we store them
// in the radio-telegram-format).
// Attention: Be aware that centralTelegram and radioTelegram
// contain the same data.
// The DbThread takes control over centralTelegram and
// radioTelegram and deletes them when no longer needed.
// ---------------------------------------------------------------
void PrtCnvDbThread::storeCentralTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvCentralTelegram> &a_centralTelegram,
                                          const N_CoPrtCnv::CoPrtCnvRadioTelegram &a_radioTelegram)
{
  PrtCnvStoredCentralTelegram *storedTelegram =
      new PrtCnvStoredCentralTelegram(a_centralTelegram,
                                      std::make_shared<N_CoPrtCnv::CoPrtCnvRadioTelegram>(a_radioTelegram));
  QMutexLocker l(&m_CentralListMutex);
  m_CentralList.push_back(storedTelegram);
//  INFO_LOG(m_logger) << "Store Central-Telegram with telId=" << a_telegram->getTelID() << " and rc=" << a_telegram->zaehler();

  sendStorePermanentSignal();
}


// ---------------------------------------------------------------
// returns the next telegram to send to central.
// returns NULL if no telegram found.
// ATTENTION: The caller is responsible to deallocate the
// returned centralTelegram!
// ---------------------------------------------------------------
N_CoPrtCnv::CoPrtCnvCentralTelegram *PrtCnvDbThread::getNextCentralTelegram(PrtCnvStoredCentralTelegram *&a_handle)
{
  // get next telegram to send to central from DB
  QMutexLocker l(&m_CentralListMutex);
  std::vector<PrtCnvStoredCentralTelegram *>::const_iterator iter = m_CentralList.begin();
  std::vector<PrtCnvStoredCentralTelegram *>::const_iterator end = m_CentralList.end();
  for (; iter != end; ++iter)
  {
    PrtCnvStoredCentralTelegram *storedTelegram = *iter;
    if (!storedTelegram || !storedTelegram->m_CentralTelegram)
      continue;
    if (0 == storedTelegram->m_WriteCounter || storedTelegram->m_DoResend)
    {
      const auto &telegram = storedTelegram->m_CentralTelegram;
      storedTelegram->m_DoResend = false;
      a_handle = storedTelegram;
      DEBUG_LOG(m_logger) << "Next telegram to send to central: id=" << storedTelegram->m_Id
                          << " a_telId=" << telegram->telegramId();
      // allocate a central-telegram
      return new N_CoPrtCnv::CoPrtCnvCentralTelegram(*telegram);
    }
  }
  return nullptr;
}


// ---------------------------------------------------------------
// Marks the central-telegram as to be sent
// ---------------------------------------------------------------
void PrtCnvDbThread::centralTelegramSent(const int32_t a_counter, PrtCnvStoredCentralTelegram *a_handle)
{
  // update sendcounter
  QMutexLocker l(&m_CentralListMutex);
  a_handle->m_WriteCounter = a_counter;
  a_handle->m_WriteCounterChanged = true;

  sendStorePermanentSignal();
}


// ---------------------------------------------------------------
// Indicates the Db, which telegrams were successful received
// by central. This will delete this telegrams from Db.
// ---------------------------------------------------------------
void PrtCnvDbThread::ackCentralTelegrams(int32_t a_counter)
{
  //DEBUG_LOG(m_logger) << "Got Ack from Central with wc=" << a_counter;
  m_CentralAckCounter = a_counter;

  sendStorePermanentSignal();
}


// ---------------------------------------------------------------
// Updates the counter for unsuccessful sending the telegram.
// If a maximal value of this counter is reached, the central-
// telegram will be deleted.
// a_handle could be deleted after calling this function!
// This function could block some milliseconds, because it
// must wait until all changes are written to DB.
// ---------------------------------------------------------------
void PrtCnvDbThread::centralTelegramCouldNotBeSent(PrtCnvStoredCentralTelegram *a_handle)
{
  if (a_handle)
  {
    // delete the telegram if much enough unsuccessfully sent
    QMutexLocker l(&m_CentralListMutex);
    if (++(a_handle->m_Attempts) >= 5)
    {
      WARNING_LOG(m_logger) << "Delete unsendable Central-Telegram with id=" << a_handle->m_Id
                            << " telId=" << a_handle->m_CentralTelegram->telegramId()
                            << " rc=" << a_handle->m_CentralTelegram->counter() << " wc=" << a_handle->m_WriteCounter;
      a_handle->m_DoDelete = true;
      // mark in Db telegram as sent
    }
    l.unlock();

    waitUntilDbWritten();
  }
}


// ---------------------------------------------------------------
// Stores the telegram to be sent to radio in working-list and
// also in Db.
// The DbThread takes control over a_telegram and deletes it
// when no longer needed.
// ---------------------------------------------------------------
void PrtCnvDbThread::storeRadioTelegram(const std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> &a_telegram,
                                        const int32_t a_readCounter)
{
  PrtCnvStoredRadioTelegram *storedTelegram = new PrtCnvStoredRadioTelegram(a_telegram);
  storedTelegram->m_ReadCounter = a_readCounter;
  {
    QMutexLocker l(&m_RadioListMutex);
    m_RadioList.push_back(storedTelegram);
  }
  if (a_telegram)
    DEBUG_LOG(m_logger) << "Store Radio-Telegram with telId=" << a_telegram->getTelID()
                        << " rc=" << a_readCounter
                        << " wc=" << int(storedTelegram->m_WriteCounter);

  if (m_DoStorePermanent)
    sendStorePermanentSignal();
}


// ---------------------------------------------------------------
// This function causes acking a central-telegram, which must
// not be stored permanent in Db, because it will be handled
// immediately (i.e.
// AnforderungStatistikBroadcastNachforderungen).
// ---------------------------------------------------------------
void PrtCnvDbThread::centralCounterReadyForAck(const int32_t a_centralCounter)
{
  storeRadioTelegram(nullptr, a_centralCounter);
  DEBUG_LOG(m_logger) << "No Radio-Telegram to store, but rc=" << a_centralCounter << " must be acked";
}


// ---------------------------------------------------------------
// returns the next broadcast-telegram from list.
// Deletes the telegram from this list.
// returns NULL if list empty.
// ---------------------------------------------------------------
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> PrtCnvDbThread::getNextBroadcastTelegram()
{
  QMutexLocker l(&m_BroadcastMapMutex);
  if (m_BroadcastList.empty())
    return nullptr;

  PrtCnvStoredRadioTelegram *storedRadioTelegram = m_BroadcastList.front();
  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> radioTelegram;
  // check whether the telegram is already stored permanent in DB
  if (storedRadioTelegram->m_Id != 0 && !storedRadioTelegram->m_WriteCounterChanged)
  {
    radioTelegram = storedRadioTelegram->m_RadioTelegram;
    m_BroadcastList.pop_front();
    delete storedRadioTelegram;
  }

  return radioTelegram;
}


// ---------------------------------------------------------------
// returns the next telegram to send to radio, respecting the
// priority.
// returns NULL if no radio-telegram found.
// ---------------------------------------------------------------
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> PrtCnvDbThread::getNextRadioTelegram(PrtCnvStoredRadioTelegram *&a_handle)
{
  // get next telegram respecting the priority to send to radio from DB
  std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> telegram;
  uint8_t priority = 255;

  QMutexLocker l(&m_RadioListMutex);
  for (PrtCnvStoredRadioTelegram *storedTelegram: m_RadioList)
  {
    const auto &radioTelegram = storedTelegram->m_RadioTelegram;
    if (radioTelegram)
    {
      if (!storedTelegram->m_IsSent)
      {
        // search the telegram with the lowest priority
        uint8_t newPriority = radioTelegram->getPriority();
        if (newPriority < priority)
        {
          priority = newPriority;
          telegram = radioTelegram;
          a_handle = storedTelegram;
        }
      }
    }
  }
  return telegram;
}

// ---------------------------------------------------------------
// Marks the radio-telegram as to be sent
// ---------------------------------------------------------------
void PrtCnvDbThread::radioTelegramSent(const uint32_t a_sendCounter, PrtCnvStoredRadioTelegram *a_handle, const uint32_t a_broadcastIndex)
{
  QMutexLocker l(&m_RadioListMutex);

  if (a_broadcastIndex)
  {
    DEBUG_LOG(m_logger) << "request update radio telegramm in db - sc: " << a_sendCounter
                        << " telId: " << a_handle->m_RadioTelegram->getTelID()
                        << " BC: " << a_broadcastIndex;
  }

  // update sendcounter in telegram
  a_handle->m_WriteCounter = a_sendCounter;
  a_handle->m_WriteCounterChanged = true;
  a_handle->m_IsSent = true;
  if (a_broadcastIndex != 0)
    a_handle->m_BroadcastIndex = a_broadcastIndex;

  if (a_handle->m_BroadcastIndex != 0)
  {
    // set the time for the 2nd broadcast
    bool dummy;
    a_handle->m_RadioTelegram->mustBeSentAsBroadcast(0xFFFFFFFF, dummy);
    DEBUG_LOG(m_logger) << "Move Radio-Telegram with telId=" << a_handle->m_RadioTelegram->getTelID()
                        << " and BC=" << a_handle->m_RadioTelegram->getBroadcastIndex()
                        << " to BC-List of DB";
//    if (a_handle->m_Id != 0)
//    {
//      M_DEBUG("Remove from radio-list")
//      m_RadioList.remove(a_handle);
//    }
    QMutexLocker l2(&m_BroadcastMapMutex);
    m_BroadcastList.push_back(a_handle);
  }
  else
  {
    // do not delete umgebungsmeldung, because we need it for restore after crash
    if (a_handle->m_RadioTelegram->isNormalTelegram() && (a_handle->m_RadioTelegram->getTelID() == GEF_UMGEBUNGS_MELDUNG2))
    {
      // store only the last Umgebungsmeldung
      if (m_EnvironmentTelegram)
        m_EnvironmentTelegram->m_DoDelete = true;
      m_EnvironmentTelegram = a_handle;
    }
    else
      a_handle->m_DoDelete = true;
  }

  sendStorePermanentSignal();
}


void PrtCnvDbThread::deleteTelegramsFromDbById(const QString &table)
{
  if (m_telegramsToDelete.empty())
    return;

  QStringList sl;
  sl.reserve(m_telegramsToDelete.size());
  for (const int64_t telId : m_telegramsToDelete)
    sl += QString::number(telId);

  NSqlQuery q(m_db);
  q.exec(QStringLiteral("DELETE FROM %1 WHERE id IN (%2);").arg(table, sl.join(QLatin1Char(','))));

  // cleanup
  m_telegramsToDelete.clear();
}

void PrtCnvDbThread::updateTelegramsBroadcast(const QString &table)
{
  if (m_telegramsToUpdateBC.empty())
    return;

  NSqlQuery q(m_db);
  q.prepare(QStringLiteral("UPDATE %1 SET broadcast_index = :broadcast_index WHERE id = :id").arg(table));
  for (const auto &p : m_telegramsToUpdateBC)
  {
    const qint64 telId = p.first;
    const qint32 bcIndex = p.second;

    q.bindValue(QStringLiteral(":broadcast_index"), bcIndex);
    q.bindValue(QStringLiteral(":id"), telId);
    q.exec();

    DEBUG_LOG(m_logger) << "Update broadcastindex for id: " << telId << " to BC: " << bcIndex;
  }

  // cleanup
  m_telegramsToUpdateBC.clear();
}

void PrtCnvDbThread::updateTelegramsWriteCounter(const QString &table)
{
  if (m_telegramsToUpdateCounter.empty())
    return;

  NSqlQuery q(m_db);
  q.prepare(QStringLiteral("UPDATE %1 SET counter = :counter WHERE id = :id").arg(table));
  for (const auto &p : m_telegramsToUpdateCounter)
  {
    const qint64 telId = p.first;
    const qint32 writeCounter = p.second;

    q.bindValue(QStringLiteral(":counter"), writeCounter);
    q.bindValue(QStringLiteral(":id"), telId);
    q.exec();

    DEBUG_LOG(m_logger) << "Update WriteCounter for id: " << telId << " to wc: " << writeCounter;
  }

  // cleanup
  m_telegramsToUpdateCounter.clear();
}

/**
  * Da SQL-Kommandos im Gegensatz zum Auslesen aus dem Socket zu langsam
  * ist und wir hier recht lange Lock-Zeiten haben, müssen wir uns mit einer
  * zweiteiligen Verarbeitung zufrieden geben
  * 1. Step - Auswerten und Aktualiseren der Liste
  * 2. Step - Ausführen der SQL-Kommandos
  * Da wir an Tetra keine Bestätigung verschicken bzw. Tetra im Falle
  * eines Crashes sowieso nicht alles puffern kann, sollte dies ok
  * sein.
  */
void PrtCnvDbThread::storeCentralTelegrams()
{
  QMutexLocker l(&m_CentralListMutex);

  if (m_CentralList.empty())
    return;

  // DEBUG_LOG(m_logger) << "centralTelegrams.size=" << m_CentralList.size();
  int iEmptyCount = 0;
  for (auto &storedCentralTelegram : m_CentralList) // reference is important to be able to make them a nullptr in the vector
  {
    if (!storedCentralTelegram)
    {
      ++iEmptyCount;
      continue;
    }
    const auto centralTelegram = storedCentralTelegram->m_CentralTelegram;

    if (0 == storedCentralTelegram->m_Id)
    {
      // new Telegram from Tetra, not yet in db -> insert it now
      m_telegramsToInsert.emplace_back(std::make_pair(storedCentralTelegram, 0));

      DEBUG_LOG(m_logger) << "Permanent Central-Telegram with id=" << storedCentralTelegram->m_Id
                          << " data=" << centralTelegram->data()
                          << " wc=" << storedCentralTelegram->m_WriteCounter;
    }
    else
    {
      // update counter for all sent central-telegrams
      // ---------------------------------------------
      const int centralAckCnt = m_CentralAckCounter;
      if (storedCentralTelegram->m_WriteCounterChanged)
      {
        m_telegramsToUpdateCounter.emplace_back(std::make_pair(storedCentralTelegram->m_Id,
                                                               storedCentralTelegram->m_WriteCounter));
        storedCentralTelegram->m_WriteCounterChanged = false;

        DEBUG_LOG(m_logger) << "Update Central-Telegram with id=" << storedCentralTelegram->m_Id
                            << " data=" << centralTelegram->data()
                            << " wc=" << storedCentralTelegram->m_WriteCounter;
      }
      // delete all acked telegrams from central-list
      // --------------------------------------------
      else if ((storedCentralTelegram->m_WriteCounter > 0 &&
                storedCentralTelegram->m_WriteCounter <= centralAckCnt) ||
               storedCentralTelegram->m_DoDelete)
      {
        DEBUG_LOG(m_logger) << "Delete Central-Telegram with id=" << storedCentralTelegram->m_Id
                            << " data=" << storedCentralTelegram->m_CentralTelegram->data()
                            << " wc=" << storedCentralTelegram->m_WriteCounter;

        // no need for single delete when centralAckCnt is higher - will be deleted later with where counter <= ackCounter
        if (storedCentralTelegram->m_WriteCounter > centralAckCnt)
          m_telegramsToDelete.push_back(storedCentralTelegram->m_Id);
        // Removing from vector and DB occours some lines down
        delete storedCentralTelegram;
        storedCentralTelegram = nullptr;
      }
    }
  }
  // clean up m_CentralList if really needed
  if (iEmptyCount > 50)
  {
    const auto isNull = [](const PrtCnvStoredCentralTelegram *t) { return t == nullptr; };
    m_CentralList.erase(std::remove_if(m_CentralList.begin(), m_CentralList.end(), isNull),
                        m_CentralList.end());
  }

  l.unlock();
  // DEBUG_LOG(m_logger) << "ready: " << m_CentralList.size();

  // insert new telegrams into db
  if (!m_telegramsToInsert.empty())
  {
    l.relock();
    NSqlQuery q(m_db);
    q.prepare(QStringLiteral("INSERT INTO %1 (tel_id, counter, data)"
                             "VALUES(:tel_id, :counter, :data);").arg(toCentralTableName()));

    // TODO: ist das Locking mittels m_CentralListMutex überhaupt nötig?
    // Wenn nein dann kann man dies hier etwas einfacher gestalten

    for (const auto &p : m_telegramsToInsert)
    {
      PrtCnvStoredCentralTelegram *storedCentralTelegram = p.first;

      storedCentralTelegram->m_WriteCounterChanged = false;
      q.bindValue(QStringLiteral(":tel_id"), storedCentralTelegram->m_CentralTelegram->telegramId());
      q.bindValue(QStringLiteral(":counter"), storedCentralTelegram->m_WriteCounter);
      q.bindValue(QStringLiteral(":data"), storedCentralTelegram->m_RadioTelegram->data());
      q.exec();
      storedCentralTelegram->m_Id = q.lastInsertId().toInt();
    }
    l.unlock();
    // DEBUG_LOG(m_logger) << "added new telegrams to db: " << m_telegramsToInsert.size();
    m_telegramsToInsert.clear();
  }


  // update write counter for a telegramm
  updateTelegramsWriteCounter(toCentralTableName());
  // DEBUG_LOG(m_logger) << "updated write counter in db: " << m_telegramsToUpdateCounter.size();

  // Jetzt alle Telegramme löschen die von der Zentrale bestätigt worden
  // da m_CentralAckCounter von anderen Threads geändert werden kann, kann es
  // sein dass schon mehr Telegramme aus der DB gelöscht werden als vorher
  // aus m_CentralList. Dies wird aber im nächsten Aufruf wieder korrigiert
  const unsigned int centralAckCnt = static_cast<unsigned int>(m_CentralAckCounter);
  if (centralAckCnt > m_OldCentralAckCounter)
  {
    m_OldCentralAckCounter = centralAckCnt;
    // wir arbeiten mit m_OldCentralAckCounter da sich m_CentralAckCounter
    // währenddessen schon ändern kann
    DEBUG_LOG(m_logger) << "Central delete all counter <= " << m_OldCentralAckCounter;

    NSqlQuery q(m_db);
    q.exec(QStringLiteral("DELETE FROM %1 WHERE counter > 0 AND counter <= %2;").arg(toCentralTableName()).arg(m_OldCentralAckCounter));
  }

  // remove all telegrams which were manually marked for deletion
  deleteTelegramsFromDbById(toCentralTableName());
}

int32_t PrtCnvDbThread::storeRadioTelegrams()
{
  QMutexLocker l(&m_RadioListMutex);

  if (m_RadioList.empty())
    return 0;

  //  M_DEBUG("Check for permanent actions on radio-list")
  int32_t centralCounter = 0;

  NSqlQuery q(m_db);
  q.prepare(QStringLiteral("INSERT INTO %1 (tel_id, counter, broadcast_index, reset_counter, data) "
                           "VALUES (:tel_id, :counter, :broadcast_index, :reset_counter, :data);").arg(toRadioTableName()));

  //  DEBUG_LOG(m_logger) << "m_RadioList.size=" << m_RadioList.size();
  std::list<PrtCnvStoredRadioTelegram *>::iterator radioIter = m_RadioList.begin();
  while (radioIter != m_RadioList.end())
  {
    bool doDeleteThisItem = false;
    PrtCnvStoredRadioTelegram *storedRadioTelegram = *radioIter;
    const auto &radioTelegram = storedRadioTelegram->m_RadioTelegram;

    if (radioTelegram)
    {
      DEBUG_LOG(m_logger) << "Handling Radio-Telegram with id=" << storedRadioTelegram->m_Id
                          << " TelID: " << radioTelegram->getTelID()
                          << " rc: " << int(radioTelegram->zaehler())
                          << " BC: " << storedRadioTelegram->m_BroadcastIndex
                          << " wc: " << int(storedRadioTelegram->m_WriteCounter);

      // store radio-telegrams permanent
      // -------------------------------
      if (0 == storedRadioTelegram->m_Id)
      {
        if (storedRadioTelegram->m_ReadCounter > centralCounter)
          centralCounter = storedRadioTelegram->m_ReadCounter;

        storedRadioTelegram->m_WriteCounterChanged = false;
        q.bindValue(QStringLiteral(":tel_id"), radioTelegram->getTelID());
        q.bindValue(QStringLiteral(":counter"), storedRadioTelegram->m_WriteCounter);
        q.bindValue(QStringLiteral(":broadcast_index"), storedRadioTelegram->m_BroadcastIndex);
        q.bindValue(QStringLiteral(":reset_counter"), int(m_ResetCounter));
        q.bindValue(QStringLiteral(":data"), radioTelegram->data());
        q.exec();
        storedRadioTelegram->m_Id = q.lastInsertId().toInt();

        DEBUG_LOG(m_logger) << "Stored Telegramm in DB, id: " << storedRadioTelegram->m_Id;

        // for broadcast-telegrams, we have 2 cases:
        // 1. case: it will be written to DB, before it is sent to radio and then moved to broadcast-list of broadcast-manager
        // 2. case: it will be sent to radio before it is written to DB. In this case we cannot remove it from m_RadioList until
        //          it is written to DB
        // here we check whether case 2 has happenend
        if (storedRadioTelegram->m_RadioTelegram->isMovedToBroadcastList())
        {
          dumpTelegram(m_logger,
                       radioTelegram->getBroadcastCounter(),
                       storedRadioTelegram->m_RadioTelegram.get());
          DEBUG_LOG(m_logger) << "Removed Telegramm from radioList (place 1), id: " << storedRadioTelegram->m_Id;
          doDeleteThisItem = true;
        }
      }
      else
      {
        // delete all acked telegrams from radio-list
        // ------------------------------------------
        // do we have to delete the radio-telegram in the list and DB?
        // we do only delete if the telegram is stored permanent in db and therefore the ack to central is sent
        if (storedRadioTelegram->m_DoDelete)
        {
          DEBUG_LOG(m_logger) << "Delete Telegramm from DB, id: " << storedRadioTelegram->m_Id;
          m_telegramsToDelete.push_back(storedRadioTelegram->m_Id);
          // delete the telegram in the list
          delete storedRadioTelegram;
          doDeleteThisItem = true;
        }
        // update write-counter for all sent radio-telegrams
        // -------------------------------------------------
        else if (storedRadioTelegram->m_WriteCounterChanged)
        {
          m_telegramsToUpdateCounter.emplace_back(std::make_pair(storedRadioTelegram->m_Id,
                                                                 storedRadioTelegram->m_WriteCounter));
          if (storedRadioTelegram->m_BroadcastIndex)
            m_telegramsToUpdateBC.emplace_back(std::make_pair(storedRadioTelegram->m_Id,
                                                              storedRadioTelegram->m_BroadcastIndex));
          storedRadioTelegram->m_WriteCounterChanged = false;

          DEBUG_LOG(m_logger) << "Update Write counter in DB, id: " << storedRadioTelegram->m_Id
                              << " New wc: " << int(storedRadioTelegram->m_WriteCounter)
                              << " new bc: " << storedRadioTelegram->m_BroadcastIndex;

          if (storedRadioTelegram->m_RadioTelegram->isMovedToBroadcastList())
          {
            dumpTelegram(m_logger,
                         storedRadioTelegram->m_BroadcastIndex,
                         storedRadioTelegram->m_RadioTelegram.get());
            DEBUG_LOG(m_logger) << "Removed Telegramm from radioList (place 2), id: " << storedRadioTelegram->m_Id;
            doDeleteThisItem = true;
          }
        }
      }
    }
    else
    {
      // telegrams which will not be stored, but acked (i.e. Anforderung Nachforderungs Statistik)
      if (storedRadioTelegram->m_ReadCounter > centralCounter)
        centralCounter = storedRadioTelegram->m_ReadCounter;
      delete storedRadioTelegram;
      doDeleteThisItem = true;
    }

    if (doDeleteThisItem)
      radioIter = m_RadioList.erase(radioIter);
    else
      ++radioIter;
  }
  l.unlock();

  // update write counter for a telegramm
  static const QString &table = toRadioTableName();
  updateTelegramsWriteCounter(table);
  // DEBUG_LOG(m_logger) << "updated write counter in db: " << m_telegramsToUpdateCounter.size();

  // update BC for a telegramm
  updateTelegramsBroadcast(table);

  // remove all telegrams which were manually marked for deletion
  deleteTelegramsFromDbById(table);

  return centralCounter;
}

void PrtCnvDbThread::handleSqlCommandList()
{
  //  M_DEBUG("Check for permanent actions on sql-command-list")
  std::vector<QString> sqlCommandList;
  {
    QMutexLocker l(&m_SqlCmdListMutex);
    std::swap(m_SqlCommandList, sqlCommandList);
  }

  if (sqlCommandList.empty())
    return;
  NSqlQuery q(m_db);
  for (const QString &sql : sqlCommandList)
  {
    DEBUG_LOG(m_logger) << "execute sql=" << sql;
    q.exec(sql);
  }
}

// ---------------------------------------------------------------
// Stores the radio-telegrams, central-telegrams in Db and
// executes the sql-command-list.
// ---------------------------------------------------------------
void PrtCnvDbThread::storePermanent()
{
  m_StorePermanentPending = 0;

  TRACE_LOG(m_logger) << "storePermanent m_DoClean=" << m_DoClean << " m_DoWaitUntilSqlWritten=" << m_DoWaitUntilSqlWritten;
  if (m_DoClean)
  {
    m_DoWaitUntilSqlWritten = false;
    return;
  }

  // generate the sql-commands on permanent DB
  // -----------------------------------------
  DBTransaction trans(m_db);

  // permanent DB-actions for central
  // ================================
  storeCentralTelegrams();

  // permanent DB-actions for radio
  // ==============================
  const int32_t centralCounter = storeRadioTelegrams();

  // store the sql-commands (member)
  // ======================
  handleSqlCommandList();

  // ready
  trans.commit();

//  M_DEBUG("inform central-thread")
  if (0 != centralCounter && centralCounter != m_OldCentralCounter)
  {
    m_OldCentralCounter = centralCounter;
    emit permanentStored(centralCounter);
  }
  m_DoWaitUntilSqlWritten = false;
//  M_DEBUG("End check for permanent actions")
}



// ---------------------------------------------------------------
// Adds an sql-command in the sql-command-list. On next
// iteration of storePermanent() all command in list will be
// executed.
// ---------------------------------------------------------------
void PrtCnvDbThread::addSqlCommand(const QString &sql)
{
  QMutexLocker l(&m_SqlCmdListMutex);
  m_SqlCommandList.push_back(sql);

  sendStorePermanentSignal();
}



// ---------------------------------------------------------------
// erases and initializes the database
// ---------------------------------------------------------------
void PrtCnvDbThread::cleanAndInit()
{
  // emit a signal to clean, so we can be sure that all pending signals are worked
  m_DoClean = true;
  emit doClean();
  // simply block until clean
  while (m_DoClean)
    QThread::sleep(1);
  m_DoProceedCleanup = false;
}


// ---------------------------------------------------------------
// cleans up this thread and its childs
// ---------------------------------------------------------------
void PrtCnvDbThread::clean()
{
  NSqlQuery q(m_db);
  INFO_LOG(m_logger) << "Delete CentralList";
  {
    QMutexLocker l(&m_CentralListMutex);
    for (PrtCnvStoredCentralTelegram *t : m_CentralList)
      delete t;
    m_CentralList.clear();
    q.exec(QStringLiteral("DELETE FROM %1;").arg(toCentralTableName()));
  }
  m_OldCentralCounter = 0;

  INFO_LOG(m_logger) << "Delete RadioList";
  m_EnvironmentTelegram = nullptr;
  {
    QMutexLocker l(&m_RadioListMutex);
    for (PrtCnvStoredRadioTelegram *t : m_RadioList)
      delete t;
    m_RadioList.clear();
    q.exec(QStringLiteral("DELETE FROM %1;").arg(toRadioTableName()));
  }

  INFO_LOG(m_logger) << "Delete BroadcastList";
  {
    QMutexLocker l(&m_BroadcastMapMutex);
    for (PrtCnvStoredRadioTelegram *t : m_BroadcastList)
      delete t;
    m_BroadcastList.clear();
  }

  // clean the members
  // delete the member-maps
  {
    QMutexLocker l(&m_SqlCmdListMutex);
    m_MemberListByISSI.clear();
    {
      QMutexLocker l2(&m_MemberListByIdMutex);
      for (const auto &p : m_MemberListById)
        delete p.second;
      m_MemberListById.clear();
    }
    INFO_LOG(m_logger) << "Delete SqlList";
    m_SqlCommandList.clear();
    q.exec(QStringLiteral("DELETE FROM %1;").arg(memberTableName()));
  }

  // 'virtual' TNE for broadcasts
  licenseMember(addMember(0, m_Config->getInteger(QStringLiteral("Radio"), QStringLiteral("BroadcastISSI"), 5000)));

  m_DoClean = false;
}


// ---------------------------------------------------------------
// Checks whether central-telegrams have to be resent. If yes,
// all actions will be done, that getNextCentralTelegram()
// delivers the telegram(s) to be resent.
// Returns true if there must telegrams be resent.
// ---------------------------------------------------------------
bool PrtCnvDbThread::resendCentralTelegrams(const int32_t a_lastSendCounter)
{
  const int centralAckCnt = m_CentralAckCounter;
  if (a_lastSendCounter > centralAckCnt)
  {
    bool warnOnce = true;
    QMutexLocker l(&m_CentralListMutex);
    int iCount = 0;
    std::vector<PrtCnvStoredCentralTelegram *>::const_iterator iter = m_CentralList.begin();
    std::vector<PrtCnvStoredCentralTelegram *>::const_iterator end = m_CentralList.end();
    for (; iter != end && iCount < 50; ++iter)
    {
      PrtCnvStoredCentralTelegram *storedTelegram = *iter;
      if (!storedTelegram)
        continue;
      ++iCount;
      if (storedTelegram->m_WriteCounter > centralAckCnt)
      {
        if (warnOnce)
        {
          WARNING_LOG(m_logger) << "Resend central-telegrams from wc=" << a_lastSendCounter
                                << " centralAckCounter=" << centralAckCnt;
          warnOnce = false;
        }
        INFO_LOG(m_logger) << "Resend central-telegram with telId="
                           << storedTelegram->m_CentralTelegram->telegramId()
                           << " wc=" << storedTelegram->m_WriteCounter;
        storedTelegram->m_DoResend = true;
      }
    }
    return true;
  }
  return false;
}



// ---------------------------------------------------------------
// Prepares the telegrams not yet acked from central for
// reconnection. This will be done by setting the write-
// counter to 0.
// ---------------------------------------------------------------
void PrtCnvDbThread::prepareCentralTelegramsForReconnection()
{
  INFO_LOG(m_logger) << "m_CentralAckCounter=" << m_CentralAckCounter;
  waitUntilDbWritten();

  INFO_LOG(m_logger) << "start";
  m_CentralAckCounter = 0;
  m_OldCentralAckCounter = 0;
  m_OldCentralCounter = 0;
  QMutexLocker l(&m_CentralListMutex);
  for (PrtCnvStoredCentralTelegram *storedTelegram : m_CentralList)
  {
    if (!storedTelegram)
      continue;
    if (storedTelegram->m_WriteCounter != 0)
    {
      INFO_LOG(m_logger) << "***Prepare central-telegram with id=" << storedTelegram->m_Id
                         << " telId=" << storedTelegram->m_CentralTelegram->telegramId()
                         << " wc=" << storedTelegram->m_WriteCounter << " wcChg="
                         << storedTelegram->m_WriteCounterChanged
                         << " for resend after reconnection";
      storedTelegram->m_WriteCounter = 0;
      storedTelegram->m_WriteCounterChanged = false;
      storedTelegram->m_DoResend = false;
    }
  }
  INFO_LOG(m_logger) << "Ready for reconnection";
}


// ---------------------------------------------------------------
// Blocks until all SQL-commands were written to DB.
// ---------------------------------------------------------------
void PrtCnvDbThread::waitUntilDbWritten()
{
  m_DoWaitUntilSqlWritten = true;
  emit doStorePermanent();
  while (m_DoWaitUntilSqlWritten)
    QThread::usleep(10000); // 10 ms

  // we have to do this twice, to be sure
  m_DoWaitUntilSqlWritten = true;
  emit doStorePermanent();
  while (m_DoWaitUntilSqlWritten)
    QThread::usleep(10000); // 10 ms
}



// ---------------------------------------------------------------
// adds a member in the 2 maps, sorted by id and ISSI
// returns the new member
// ---------------------------------------------------------------
PrtCnv::PrtCnvMember *PrtCnvDbThread::addMember(const int a_identity, const int a_ISSI)
{
  PrtCnvMember *newMember = new PrtCnvMember(a_identity, a_ISSI);
  {
    QMutexLocker lSql(&m_SqlCmdListMutex);
    QMutexLocker lId(&m_MemberListByIdMutex);
    m_MemberListById.insert(std::make_pair(a_identity, newMember));
    m_MemberListByISSI.insert(std::make_pair(a_ISSI, newMember));
  }

  DEBUG_LOG(m_logger) << "Adding member with eqId " << a_identity
                      << " and issi " << a_ISSI
                      << ", store in db: " << m_DoStorePermanent;
  // add also permanent in DB
  if (m_DoStorePermanent)
    addSqlCommand(QStringLiteral("INSERT INTO %1 (id, issi) VALUES(%2, %3)")
                  .arg(memberTableName()).arg(newMember->m_Id).arg(newMember->m_ISSI));

  return newMember;
}


// ---------------------------------------------------------------
// removes the member in the 2 maps, sorted by id and ISSI
// ---------------------------------------------------------------
void PrtCnvDbThread::removeMember(PrtCnv::PrtCnvMember *a_member)
{
  {
    QMutexLocker lSql(&m_SqlCmdListMutex);
    QMutexLocker lId(&m_MemberListByIdMutex);
    auto iterId = m_MemberListById.find(a_member->m_Id);
    if (iterId != m_MemberListById.end())
      m_MemberListById.erase(iterId);
    else
      ERROR_LOG(m_logger) << "Internal error: did not find the member by ID";
    auto iterIssi = m_MemberListByISSI.find(a_member->m_ISSI);
    if (iterIssi != m_MemberListByISSI.end())
      m_MemberListByISSI.erase(iterIssi);
    else
      ERROR_LOG(m_logger) << "Internal error: did not find the member by ISSI";
  }

  DEBUG_LOG(m_logger) << "Removing member with eqId " << a_member->m_Id
                      << " and issi " << a_member->m_ISSI
                      << ", store in db: " << m_DoStorePermanent;
  // remove also permanent in DB
  if (m_DoStorePermanent)
    addSqlCommand(QStringLiteral("DELETE FROM %1 WHERE id = %2 OR issi = %3")
                  .arg(memberTableName()).arg(a_member->m_Id).arg(a_member->m_ISSI));

  delete a_member;
}


// ---------------------------------------------------------------
// Licenses the member
// ---------------------------------------------------------------
bool PrtCnvDbThread::licenseMember(PrtCnvMember *a_member, const bool a_doLicense)
{
  if (!a_member)
    return false;
  a_member->m_Licensed = a_doLicense;
  if (m_DoStorePermanent)
    addSqlCommand(QStringLiteral("UPDATE %1 SET licensed = %2 WHERE id = %3")
                  .arg(memberTableName()).arg(a_doLicense ? 1 : 0).arg(a_member->m_Id));
  return true;
}

void PrtCnvDbThread::updateExerciseIdForMember(PrtCnvMember *a_member, int newExerciseId)
{
  if (!a_member)
    return;
  a_member->m_loggedInExerciseId = newExerciseId;
  DEBUG_LOG(m_logger) << "Updating exerciseId member with eqId " << a_member->m_Id
                      << " and issi " << a_member->m_ISSI << " to " << newExerciseId
                      << ", store in db: " << m_DoStorePermanent;
  if (m_DoStorePermanent)
    addSqlCommand(QStringLiteral("UPDATE %1 SET exercise_id = %2 WHERE id = %3")
                  .arg(memberTableName()).arg(newExerciseId).arg(a_member->m_Id));
}


// ---------------------------------------------------------------
// returns NULL if member not found
// ---------------------------------------------------------------
PrtCnv::PrtCnvMember *PrtCnvDbThread::getMemberById(const uint16_t a_id)
{
  QMutexLocker l(&m_MemberListByIdMutex);
  auto iter = m_MemberListById.find(a_id);
  if (iter != m_MemberListById.end())
    return iter->second;

  return nullptr; // no member found
}


// ---------------------------------------------------------------
// returns NULL if no member found
// ---------------------------------------------------------------
PrtCnv::PrtCnvMember *PrtCnvDbThread::getMemberByISSI(const uint32_t a_ISSI) const
{
  auto iter = m_MemberListByISSI.find(a_ISSI);
  if (iter != m_MemberListByISSI.end())
    return iter->second;

  return nullptr;
}



// ---------------------------------------------------------------
// Returns the actual reset-counter
// ---------------------------------------------------------------
uint8_t PrtCnvDbThread::getResetCounter() const
{
  return m_ResetCounter;
}


// ---------------------------------------------------------------
// Sets the actual reset-counter
// ---------------------------------------------------------------
void PrtCnvDbThread::setResetCounter(uint8_t newVal)
{
  m_ResetCounter = newVal;
  if (m_DoStorePermanent)
  {
    NSqlQuery q(m_db);
    q.exec(QStringLiteral("UPDATE Status SET reset_counter = %1 WHERE id = 1")
           .arg(int(newVal)));
  }
  INFO_LOG(m_logger) << "Update resetCounter=" << (int)m_ResetCounter << " doStorePermanent=" << m_DoStorePermanent;
}


// ---------------------------------------------------------------
// The actual 'Betriebszustände Gefechtsfeld' which will be
// sent to TNEs periodically
// ---------------------------------------------------------------
uint8_t PrtCnvDbThread::getBattleFieldOperatingState() const
{
  QMutexLocker l(&m_BattleFieldOpStateMutex);

  return m_BattleFieldOperatingState;
}


// ---------------------------------------------------------------
// Sets or unsets pause, depending on a_doSet.
// ---------------------------------------------------------------
void PrtCnvDbThread::setPause(const bool a_doSet)
{
  QMutexLocker l(&m_BattleFieldOpStateMutex);

  if (a_doSet)
    m_BattleFieldOperatingState = m_BattleFieldOperatingState | 0x80; // pause
  else
    m_BattleFieldOperatingState = m_BattleFieldOperatingState & 0x7F; // no pause

  if (m_DoStorePermanent)
    addSqlCommand(QStringLiteral("UPDATE %1 SET ctas_operating_state = %2 WHERE id = 1")
                  .arg(statusTableName()).arg(int(m_BattleFieldOperatingState)));

  INFO_LOG(m_logger) << "Update battleFieldOperatingState=" << (int)m_BattleFieldOperatingState << " doStorePermanent=" << m_DoStorePermanent;
}

// ---------------------------------------------------------------
// Set the inhibit time for position telegrams (1 .. 31 Seconds)
// ---------------------------------------------------------------
void PrtCnvDbThread::setPositionSendTime(unsigned int sendTime)
{
  QMutexLocker l(&m_BattleFieldOpStateMutex);

  if (sendTime > 31)
    sendTime = 31;
  if (sendTime < 1)
    sendTime = 1;

  // mode zurücksetzen (Bits 2 - 6)
  m_BattleFieldOperatingState &= 0x83;
  // und neu setzen
  m_BattleFieldOperatingState |= (sendTime << 2);
}

// ---------------------------------------------------------------
// Set the current air load to be sent with the Umgebungsmeldung
// ---------------------------------------------------------------
void PrtCnvDbThread::setAirLoad(PrtCnvRadioThread::E_TrafficLoad airLoad)
{
  QMutexLocker l(&m_BattleFieldOpStateMutex);

  // mode zurücksetzen
  m_BattleFieldOperatingState &= 0xFC;
  // und neu setzen
  m_BattleFieldOperatingState |= (static_cast<uint8_t>(airLoad) & 0x03);
}

// ---------------------------------------------------------------
// Returns true if the resetCounter itself is different than
// the reset-counter of the environment-telegram
// ---------------------------------------------------------------
bool PrtCnvDbThread::isEnvironmentResetCounterOld() const
{
  QMutexLocker l(&m_RadioListMutex);

  bool isOld = false;
  if (m_EnvironmentTelegram)
    isOld = getResetCounter() != m_EnvironmentTelegram->m_RadioTelegram->getPayloadDataUInt8(7);
  return isOld;
}

// ---------------------------------------------------------------
// Sets the resetcounter of the environment-telegram to the
// actual reset-counter.
// ---------------------------------------------------------------
void PrtCnvDbThread::setResetCounterOnEnvironment()
{
  QMutexLocker l(&m_RadioListMutex);

  if (m_EnvironmentTelegram)
    m_EnvironmentTelegram->m_RadioTelegram->setPayloadDataWithIndex(7, getResetCounter(), 1);
}

// ---------------------------------------------------------------
// Returns the actual Umgebungsmeldung
// ---------------------------------------------------------------
std::shared_ptr<N_CoPrtCnv::CoPrtCnvRadioTelegram> PrtCnvDbThread::getEnvironmentTelegram()
{
  QMutexLocker l(&m_RadioListMutex);
  if (m_EnvironmentTelegram)
    return std::make_shared<N_CoPrtCnv::CoPrtCnvRadioTelegram>(m_EnvironmentTelegram->m_RadioTelegram->data());
  return {};
}

// ---------------------------------------------------------------
// Fills the map with nachforderungsstatistic.
// Returns the number of elements in map.
// ---------------------------------------------------------------
std::map<int32_t, int32_t> PrtCnvDbThread::getClaimStatistics() const
{
  std::map<int32_t, int32_t> ret;
  QMutexLocker l(&m_MemberListByIdMutex);
  for (const auto &p : m_MemberListById)
  {
    if (p.first != 0)
      ret.insert(std::make_pair(p.first, p.second->m_ClaimCount));
  }
  return ret;
}


// ---------------------------------------------------------------
// Increments the counter for nachforderungen of the TNE with
// id a_identity.
// ---------------------------------------------------------------
void PrtCnvDbThread::incClaimCount(int a_identity)
{
  QMutexLocker l(&m_MemberListByIdMutex);
  auto iter = m_MemberListById.find(a_identity);
  if (iter != m_MemberListById.end())
  {
    iter->second->m_ClaimCount++;
    if (m_DoStorePermanent)
      addSqlCommand(QStringLiteral("UPDATE %1 SET claims = claims + 1 WHERE id = %2")
                    .arg(memberTableName()).arg(iter->second->m_Id));
  }
  else
    ERROR_LOG(m_logger) << "Internal error: did not find TNE with id=" << a_identity;
}




// ---------------------------------------------------------------
// Sets the actual machine-state permanent, used to proceed
// cleaning db after a crash.
// ---------------------------------------------------------------
void PrtCnvDbThread::setMachineState(const int a_newMachineState)
{
  NSqlQuery q(m_db);
  q.exec(QStringLiteral("UPDATE %1 SET machine_state = %2 WHERE id = 1")
         .arg(statusTableName()).arg(a_newMachineState));
}



// ---------------------------------------------------------------
// Returns true if protocol-converter was crashed while
// cleanup DB.
// ---------------------------------------------------------------
bool PrtCnvDbThread::mustProceedCleanup() const
{
  return m_DoProceedCleanup;
}



// ---------------------------------------------------------------
// Sends a signal storePermanent if not already such a signal
// is pending
// ---------------------------------------------------------------
void PrtCnvDbThread::sendStorePermanentSignal()
{
  if (m_StorePermanentPending.testAndSetOrdered(0, 1))
    emit doStorePermanent();
}

void PrtCnvDbThread::closeDb()
{
  if (m_db.isOpen())
  {
    m_db.close();
    m_db = QSqlDatabase();
    QSqlDatabase::removeDatabase(QStringLiteral("PrtCnv"));
  }
}

} // namespace PrtCnv