/* --------------------------------------------------------------------
// $HeadURL$
// --------------------------------------------------------------------
//!
// --------------------------------------------------------------------
// COPYRIGHT (C) 1999: STN ATLAS ELEKTRONIK GMBH, D-28305 BREMEN
// --------------------------------------------------------------------
//
// HIER/ITEM : CSU: RP 5182 P 005 SRC 01104
// BRIEF DESC: Funktionalitaet Mineninterpreter
// AUTHOR    : Ingo Kannetzky
// RELEASE   :
// MODIF/STAT: 22.02.00
// ORIGIN REF:
//
// Revision INFO:
// --------------
//   $Revision$
//   $Date$
//   $Id$
//
// LANGUAGE: C++ (Compiler: XXX Version: XXX)
//
// PURPOSE:
// --------
// Funktionalitaet Mineninterpreter
//
// ERROR HANDLING:
// ---------------
// (keine / Beschreibung)
//
// IMPLEMENTATION DETAILS:
// -----------------------
// (keine / Beschreibung)
//
//!
*/

//------------------ revision id-code ----------------------

//------------------ includes ------------------------------

#include <stdio.h>
#include <math.h>
#include <time.h>

#include <iostream>

#include "zssi_wi_Minenfeld_Interpreter.h"
#include "zssi_wi_Minenfeld_Generator.h"
#include "logger.h"

//------------------ externals (procs + vars) --------------

//------------------ constants/ defines --------------------
const int T_allein_Luecke_max = 120; // in Sekunden
const int S_allein_Luecke_max = 30;  // in Metern
const int T_allein_max = 180;        // in Sekunden, groesser als t_allein_Luecke_max!
const int S_allein_max = 100;        // in Metern, groesser als s_allein_Luecke_max!
const int W_allein_max = 40;         // in Grad 0..89
const int T_zusammen_max = 240;      // in Sekunden
const int S_zusammen_max = 100;      // in Metern
const int W_zusammen_max = 20;       // in Grad 0..89

//------------------ types ---------------------------------

//------------------ globals -------------------------------

extern
GFS_Map_Container<VERLEGEDATEN_KEY, VERLEGEDATEN_INTERN>
interne_datenbasis_Verlegedaten;

extern
GFS_Map_Container<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>
interne_datenbasis_Fahrspur;

static NGL::INGLLogger &loggerMI()
{
  return GuezMinelayerProcessing::getLogger("zssi_wi_Minenfeld_Interpreter");
}

struct PositionMitZeit
{
  gps_position_rt pos;
  time_t zeit = 0;
};

//------------------ function prototypes -------------------

//f+-----------------------------------------------------------------------

// copied from zssi_wi_Minen_math.cpp
//f+-----------------------------------------------------------------------
int Winkel_zwischen_Fahrspuren_eines_Fz(const VERLEGEDATEN_KEY &intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//  Der Richtungssinn der Fahrspuren wird berueksichtigt so, dass
//  mit engegengesetztem Richtungssinn angelegte, parallele Fahrspuren den
//  Winkel 0 einschliessen, dagegen schliessen parallele Fahrspuren, welche
//  mit dem selben Richtungssinn verlegt wurden, einen Winkel von 180 Grad
//  ein.
//  Sollten die zur Berechnung des Winkels erforderlichen Werte nicht
//  gefunden werden, so gibt diese Funktion -1 zurueck
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  double F1x2 = -1;
  double F1y2 = -1;
  double F2x1 = -1;
  double F2y1 = -1;
  double F2x2 = -1;
  double F2y2 = -1;
  double delta_w;

  //Als Fahrspur 1(F1xx) wird die aeltere Fahrspur angesehen
  interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
  const ausstattungs_id_t fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
      daten.header.identitaet;

  //Es wird davon ausgegangen, dass der Iterator nun auf dem
  //Verlegeende-Eintrag der Fahrspur 1 steht


  double F1x1 = interne_datenbasis_Fahrspur.getData()->
                daten.gps_position.utm_ostwert;
  double F1y1 = interne_datenbasis_Fahrspur.getData()->
                daten.gps_position.utm_nordwert;

  //Nun wird der Iterator auf den zugehoerigen Verlegeanfang gesetzt
  while ((interne_datenbasis_Fahrspur.iter_modify(-1))
         && (F1x2 == -1))
  {
    if (interne_datenbasis_Fahrspur.getData()->intstat == 3)
    {
      F1x2 = interne_datenbasis_Fahrspur.getData()->
             daten.gps_position.utm_ostwert;
      F1y2 = interne_datenbasis_Fahrspur.getData()->
             daten.gps_position.utm_nordwert;
    }

  }

  //Iterator wieder auf den aktuellen Endeeintrag setzen
  interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);

  //Der naechste Eintrag sollte der Verlegeanfang der naechsten Fahrspur
  //sein
  if (interne_datenbasis_Fahrspur.iter_modify(+1))
  {
    if ((interne_datenbasis_Fahrspur.getData()->
         daten.header.identitaet == fahrzeug_identitaet)
        && (interne_datenbasis_Fahrspur.getData()->intstat == 3))
    {
      F2x1 = interne_datenbasis_Fahrspur.getData()->
             daten.gps_position.utm_ostwert;
      F2y1 = interne_datenbasis_Fahrspur.getData()->
             daten.gps_position.utm_nordwert;

      //Nun wird nach dem aktuellsten Eintrag fuer die Fahrspur 2 gesucht
      while ((interne_datenbasis_Fahrspur.iter_modify(+1))
             && (interne_datenbasis_Fahrspur.getData()->intstat == 2))
      {
        if (interne_datenbasis_Fahrspur.getData()->
            daten.header.identitaet == fahrzeug_identitaet)
        {
          F2x2 = interne_datenbasis_Fahrspur.getData()->
                 daten.gps_position.utm_ostwert;
          F2y2 = interne_datenbasis_Fahrspur.getData()->
                 daten.gps_position.utm_nordwert;
        }
      }
    }
  }

  //Iterator wieder auf den aktuellen Endeeintrag setzen
  interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);

  if (((F1x1 == -1) || (F1x2 == -1)) || ((F2x1 == -1) || (F2x2 == -1)))
    delta_w = -1;
  else
  {
    double m1, m2;
    if (F1x2 - F1x1 != 0)
      m1 = (F1y2 - F1y1) / (F1x2 - F1x1);
    else
      m1 = 100000; //um eine Fallunterscheidung zu vermeiden

    if (F2x2 - F2x1 != 0)
      m2 = (F2y2 - F2y1) / (F2x2 - F2x1);
    else
      m2 = 100000; //um eine Fallunterscheidung zu vermeiden

    if (m1 * m2 != -1)
      delta_w = atanf((m2 - m1) / (1 + (m1 * m2)));
    else
      delta_w = M_PI / 2;

    // rad -> grad
    delta_w *= 180 / M_PI;

    //Der Anfangspunkt der Fahrspur 2 muss am weitesten vom Beginn der
    //Fahrspur entfernt sein

    if (Punktabstand(F1x2, F1y2, F2x1, F2y1) <
        Punktabstand(F1x2, F1y2, F2x2, F2y2))
      delta_w = 180 - delta_w;
  }

  return lrint(delta_w);
}//end Winkel_zwischen_Fahrspuren_eines_Fz
//-------------------------------------------------------------------------

// copied from zssi_wi_Minen_math.cpp
//f+-----------------------------------------------------------------------
int Winkel_zwischen_Fahrspuren_mehrerer_Fz(
  const VERLEGEDATEN_KEY &F1_ende_key, const VERLEGEDATEN_KEY &F2_anfang_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//  Der Richtungssinn der Fahrspuren wird berueksichtigt so, dass
//  mit gleichem Richtungssinn angelegte, parallele Fahrspuren den
//  Winkel 0 einschliessen, dagegen schliessen parallele Fahrspuren, welche
//  mit entgegengesetzten Richtungssinn verlegt wurden, einen Winkel von 180
//  Grad ein.
//  Sollten die zur Berechnung des Winkels erforderlichen Werte nicht
//  gefunden werden, so gibt diese Funktion -1 zurueck
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  double F1x2 = -1;
  double F1y2 = -1;
  double F2x2 = -1;
  double F2y2 = -1;
  double delta_w;

  //Iterator auf den aktuellen Endpunkt setzen
  interne_datenbasis_Fahrspur.finden_eintrag_container(F1_ende_key);
  //F1_fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
  //  daten.header.identitaet;

  double F1x1 = interne_datenbasis_Fahrspur.getData()->daten.gps_position.utm_ostwert;
  double F1y1 = interne_datenbasis_Fahrspur.getData()->daten.gps_position.utm_nordwert;

  //Nun wird der Iterator auf den zugehoerigen Verlegeanfang gesetzt
  while ((interne_datenbasis_Fahrspur.iter_modify(-1))
         && (F1x2 == -1))
  {
    if (interne_datenbasis_Fahrspur.getData()->intstat == 3)
    {
      F1x2 = interne_datenbasis_Fahrspur.getData()->
             daten.gps_position.utm_ostwert;
      F1y2 = interne_datenbasis_Fahrspur.getData()->
             daten.gps_position.utm_nordwert;
    }
  }

  //Iterator auf den Anfangspunkt der zweiten Fahrspur setzen
  interne_datenbasis_Fahrspur.finden_eintrag_container(F2_anfang_key);
  const ausstattungs_id_t F2_fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
      daten.header.identitaet;

  double F2x1 = interne_datenbasis_Fahrspur.getData()->daten.gps_position.utm_ostwert;
  double F2y1 = interne_datenbasis_Fahrspur.getData()->daten.gps_position.utm_nordwert;

  //Nun wird nach dem aktuellsten Eintrag fuer die Fahrspur 2 gesucht
  while ((interne_datenbasis_Fahrspur.iter_modify(+1))
         && (interne_datenbasis_Fahrspur.getData()->intstat == 2))
  {
    if (interne_datenbasis_Fahrspur.getData()->
        daten.header.identitaet == F2_fahrzeug_identitaet)
    {
      F2x2 = interne_datenbasis_Fahrspur.getData()->
             daten.gps_position.utm_ostwert;
      F2y2 = interne_datenbasis_Fahrspur.getData()->
             daten.gps_position.utm_nordwert;
    }
  }

  if (((F1x1 == -1) || (F1x2 == -1)) || ((F2x1 == -1) || (F2x2 == -1)))
    delta_w = -1;
  else
  {
    double m1, m2;
    if (F1x2 - F1x1 != 0)
      m1 = (F1y2 - F1y1) / (F1x2 - F1x1);
    else
      m1 = 100000; //um eine Fallunterscheidung zu vermeiden

    if (F2x2 - F2x1 != 0)
      m2 = (F2y2 - F2y1) / (F2x2 - F2x1);
    else
      m2 = 100000; //um eine Fallunterscheidung zu vermeiden

    if (m1 * m2 != -1)
      delta_w = atanf((m2 - m1) / (1 + (m1 * m2)));
    else
      delta_w = M_PI / 2;

    // rad -> deg
    delta_w *= 180 / M_PI;

    //Der Anfangspunkt der Fahrspur 2 muss am weitesten vom Ende der
    //Fahrspur 1 entfernt sein

    if (Punktabstand(F1x1, F1y1, F2x2, F2y2) >
        Punktabstand(F1x1, F1y1, F2x1, F2y1))
      delta_w = 180 - delta_w;
  }
  //Iterator auf den aktuellen Anfangseintrag setzen!!!!!!!!
  interne_datenbasis_Fahrspur.finden_eintrag_container(F2_anfang_key);
  return lrint(delta_w);
}//end Winkel_zwischen_Fahrspuren_mehrerer_Fz
//-------------------------------------------------------------------------


void GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::ZSSI_WI_Erstelle_einzel_minensperre(const VERLEGEDATEN_KEY &key,
                                                                                                 const VERLEGEDATEN_INTERN &daten)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion ermittelt den Interpretationsstatus des Eintrages
//    im Map-Container interne_datenbasis_Fahrspur, der unmittelbar vor dem
//    Verlegebeginn der aktuellen Fahrspur liegt. Ist kein solcher Eintrag
//    vorhanden liefert sie -1 zurueck.
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  const ausstattungs_id_t fahrzeug_identitaet = key.fz_id;
  const short             Fz_art              = 2;

  NGL::INGLLogger &m_logger(loggerMI());

  wirkfeld_minensperre_rt     telegramm;
  bes_wirkfeld_minensperre_rt &sperrenmodell = telegramm.beschreibung;
// Minensperre = Quadrat 25x25m, 5 Minen => verlegedichte = 0.2, 1 Segment
  sperrenmodell.wirkbeginn.gps_zeit   = daten.daten.verlegedaten.wirkbeginn.gps_zeit;
  sperrenmodell.wirkdauer             = daten.daten.verlegedaten.wirkzeit;
  sperrenmodell.minentyp              = daten.daten.verlegedaten.minentyp;
  sperrenmodell.eckpunkt.utm_nordwert = daten.daten.gps_position.utm_nordwert - 12;
  sperrenmodell.eckpunkt.utm_ostwert  = daten.daten.gps_position.utm_ostwert - 12;
  sperrenmodell.wirkfeldbreite        = 25;
  sperrenmodell.wirkfeldtiefe         = 25;
  sperrenmodell.verlegetiefe          = 25;
//  sperrenmodell.verlegedichte         = 2;
  sperrenmodell.verlegedichte         = lrint(0.2 * FAKTOR_VERLEGEDICHTE);
  sperrenmodell.minenanzahl           = 5;

  sperrenmodell.segmente.resize(1);

  sperrenmodell.segmente[0].startpunkt.utm_nordwert = daten.daten.gps_position.utm_nordwert;
  sperrenmodell.segmente[0].startpunkt.utm_ostwert  = daten.daten.gps_position.utm_ostwert - 12;
  sperrenmodell.segmente[0].anzahl                  = 5;
  sperrenmodell.segmente[0].drehwinkel              = 0;

  //Kontrollausgabe
  INFO_LOG(m_logger) << QStringLiteral("Einspuriges Minensperrenmodell wurde erstellt. Wirkbeginn: %1 Wirkdauer:%2 Verlegetiefe:%3 Verlegedichte:%4 Minentyp:%5 Minenanzahl:%6 Segmentanzahl:%7").arg(sperrenmodell.wirkbeginn.gps_zeit).arg(sperrenmodell.wirkdauer).arg(sperrenmodell.verlegetiefe).arg(sperrenmodell.verlegedichte).arg(sperrenmodell.minentyp).arg(sperrenmodell.minenanzahl).arg(sperrenmodell.segmente.size());
  for (unsigned s = 0; s < sperrenmodell.segmente.size(); s++)
    INFO_LOG(m_logger) << QStringLiteral("Segment[%1] Startpunkt: %2 %3 Drehwinkel:%4 Anzahl:%5").arg(s)
                          .arg(sperrenmodell.segmente.at(s).startpunkt.utm_ostwert)
                          .arg(sperrenmodell.segmente.at(s).startpunkt.utm_nordwert)
                          .arg(sperrenmodell.segmente.at(s).drehwinkel)
                          .arg(sperrenmodell.segmente.at(s).anzahl);

  telegramm.beschreibung.kennung = daten.daten.verlegedaten.sperren_id;
  telegramm.header.identitaet = fahrzeug_identitaet;
  emit sendeWirkfeld(telegramm, Fz_art);

} // end ZSSI_WI_Erstelle_einzel_minensperre
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
void GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::ZSSI_WI_modifiziere_Verlegedaten(const VERLEGEDATEN_KEY &key,
                                                                                              const VERLEGEDATEN_INTERN &daten)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion ermittelt den Interpretationsstatus des Eintrages
//    im Map-Container interne_datenbasis_Fahrspur, der unmittelbar vor dem
//    Verlegebeginn der aktuellen Fahrspur liegt. Ist kein solcher Eintrag
//    vorhanden liefert sie -1 zurueck.
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  int verlegedaten_size = interne_datenbasis_Verlegedaten.size();
  bool gefunden = false;
  VERLEGEDATEN_INTERN *hilfs_daten = nullptr;
  NGL::INGLLogger &m_logger(loggerMI());

  if (verlegedaten_size == 0)
  {
    ZSSI_WI_Erstelle_einzel_minensperre(key, daten);
    return;
  }
  interne_datenbasis_Verlegedaten.iter_reset();
  interne_datenbasis_Verlegedaten.iter_modify(verlegedaten_size);

  while (verlegedaten_size > 0)
  {
    const VERLEGEDATEN_KEY &hilfs_key = interne_datenbasis_Verlegedaten.getKey();
    if ((key.fz_id == hilfs_key.fz_id) &&
        std::abs((int)(key.zeitpunkt.gps_zeit - hilfs_key.zeitpunkt.gps_zeit)) <= T_zusammen_max)
    {
      hilfs_daten = interne_datenbasis_Verlegedaten.getData();
      if (hilfs_daten->daten.verlegedaten.anzahl_verlegter_minen != 0)
      {
        gefunden = true;
        break;
      }
    }
    interne_datenbasis_Verlegedaten.iter_modify(-1);
    verlegedaten_size--;
  }

  if (gefunden)
  {
    hilfs_daten->daten.verlegedaten.anzahl_verlegter_minen += daten.daten.verlegedaten.anzahl_verlegter_minen;
    INFO_LOG(m_logger) << QStringLiteral("Verlegeende gefunden! Anz_Minen = %1").arg(hilfs_daten->daten.verlegedaten.anzahl_verlegter_minen);
  }
  else
    ZSSI_WI_Erstelle_einzel_minensperre(key, daten);
} // end ZSSI_WI_modifiziere_Verlegedaten
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
int Eintrag_vor_zugehoerigem_Verlegebeginn(const VERLEGEDATEN_KEY &intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion ermittelt den Interpretationsstatus des Eintrages
//    im Map-Container interne_datenbasis_Fahrspur, der unmittelbar vor dem
//    Verlegebeginn der aktuellen Fahrspur liegt. Ist kein solcher Eintrag
//    vorhanden liefert sie -1 zurueck.
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  VERLEGEDATEN_KEY anfangspunkt_key = intern_key;

  // Map-Container auf aktuellen Eintrag setzen
  interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
  const ausstattungs_id_t fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
      daten.header.identitaet;

  //Suchen des vorhergehenden Eintrages des Fz mit is == 3 (Anfangspunkt)
  while (((interne_datenbasis_Fahrspur.iter_modify(-1))
          &&
          (interne_datenbasis_Fahrspur.getData()->
           daten.header.identitaet == fahrzeug_identitaet))
         &&
         (intern_key == anfangspunkt_key)
        )
  {
    if (interne_datenbasis_Fahrspur.getData()->intstat == 3)
      anfangspunkt_key = interne_datenbasis_Fahrspur.getKey();
  }

  //Iterator auf den gefundenen Anfangspunkt positionieren
  interne_datenbasis_Fahrspur.finden_eintrag_container(anfangspunkt_key);

  //Interpretationsstatus vom Vorgaenger lesen
  int is = 1;
  if ((interne_datenbasis_Fahrspur.iter_modify(-1)) &&
      (intern_key != anfangspunkt_key))
    is = interne_datenbasis_Fahrspur.getData()->intstat;

  return (is);
} // end Eintrag_vor_zugehoerigem_Verlegebeginn
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
int Eintrag_nach_dieser_MVP(VERLEGEDATEN_KEY intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion ermittelt den Interpretationsstatus des Eintrages
//    im Map-Container interne_datenbasis_Fahrspur, der unmittelbar nach
//    dem aktuellen Eitrag fuer dieses Fz vorliegt. Ist kein solcher
//    Eintrag vorhanden, liefert sie -1 zurueck.
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  // Map-Container auf aktuellen Eintrag setzen
  interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
  const ausstattungs_id_t fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
      daten.header.identitaet;

  //Auslesen des nachfolgenden Eintrags fuer dieses Fz falls dieser
  //vorhanden ist
  int is = -1;
  if ((interne_datenbasis_Fahrspur.iter_modify(+1))
      && (interne_datenbasis_Fahrspur.getData()->
          daten.header.identitaet == fahrzeug_identitaet)
     )
    is = interne_datenbasis_Fahrspur.getData()->intstat;

  return (is);
} // end Eintrag_nach_dieser_MVP
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
VERLEGEDATEN_KEY Key_des_zugehoerigen_Verlegebeginns(const VERLEGEDATEN_KEY &intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion ermittelt den Eintrag im Map-Container
//    interne_datenbasis_Fahrspur, der zu der uebergebenen Verlegeende-MVP
//    den zugehoerigen Verlegebeginn bildet und liefert den Key zurueck.
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  VERLEGEDATEN_KEY anfangspunkt_key = intern_key;

  auto it = interne_datenbasis_Fahrspur.c().find(intern_key);
  if (it == interne_datenbasis_Fahrspur.c().end())
    return anfangspunkt_key;
  const ausstattungs_id_t fahrzeug_identitaet = it->second.daten.header.identitaet;

  do
  {
    --it;
    //Suchen des vorhergehenden Eintrages des Fz mit is == 3 (Anfangspunkt)
    if (it->second.daten.header.identitaet != fahrzeug_identitaet)
      break;
    if (it->second.intstat == 3)
    {
      anfangspunkt_key = it->first;
      break;
    }
  }
  while (it != interne_datenbasis_Fahrspur.c().begin());

  return anfangspunkt_key;
} // end of Key_des_zugehoerigen_Verlegebeginns
//-------------------------------------------------------------------------


//f+-----------------------------------------------------------------------
VERLEGEDATEN_KEY Key_des_zugehoerigen_Verlegeendes(const VERLEGEDATEN_KEY &intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion ermittelt den Eintrag im Map-Container
//    interne_datenbasis_Fahrspur, der zu der uebergebenen Verlegeende-MVP
//    das zugehoerige Verlegeende bildet und liefert den Key zurueck.
//    Wird kein entsprechender Eintrag gefunden, wird der uebergebene Key
//    zurueckgeliefert.
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  VERLEGEDATEN_KEY endpunkt_key = intern_key;

  auto it = interne_datenbasis_Fahrspur.c().find(intern_key);
  if (it == interne_datenbasis_Fahrspur.c().end())
    return endpunkt_key;
  const ausstattungs_id_t fahrzeug_identitaet = it->second.daten.header.identitaet;

  ++it;
  while (it != interne_datenbasis_Fahrspur.c().end())
  {
    if (it->second.daten.header.identitaet != fahrzeug_identitaet)
      break;
    if (it->second.intstat > 3)
    {
      endpunkt_key = it->first;
      break;
    }
    ++it;
  }
  return (endpunkt_key);

} // end of Key_des_zugehoerigen_Verlegeendes
//-------------------------------------------------------------------------




//f+-----------------------------------------------------------------------
static int IS_des_zugehoerigen_Verlegeendes(const VERLEGEDATEN_KEY &intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion ermittelt den Interpretationsstatus des Eintrags im
//    Map-Container interne_datenbasis_Fahrspur, der zu der uebergebenen
//    Verlegeanfangs-MVP das zugehoerige Verlegeende bildet und liefert
//    ihn zurueck.
//    Falls das Verlegeende noch nicht vorhanden ist, wird -1
//    zurueckgegeben.
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  //Suchen des nachfolgenden Eintrages des Fz mit is >3
  for (auto it = interne_datenbasis_Fahrspur.c().find(intern_key) ; it != interne_datenbasis_Fahrspur.c().end(); ++it)
  {
    const FAHRSPUR_INTERN &fs = it->second;
    if (fs.daten.header.identitaet != intern_key.fz_id)
      break;
    if (fs.intstat <= 3)
      continue;
    return fs.intstat;
  }
  return -1;
} // end of IS_des_zugehoerigen_Verlegeendes
//-------------------------------------------------------------------------


//f+-----------------------------------------------------------------------
VERLEGEDATEN_KEY Key_eines_Verlegebeginns_im_Zeitfenster(const VERLEGEDATEN_KEY &intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Es wird sich im folgenden auf den zugehoerigen Verlegebeginn zur
//    uebergebenen Verlegeende-MVP bezogen.
//    Diese Funktion ermittelt einen Verlegebeginn-Eintrag aus dem
//    Map-Container interne_datenbasis_Fahrspur, der zu der (uebergebenen)
//    Verlegeanfangs-MVP im Zeitbereich +/- T_zusammen_max liegt und die
//    S_zusammen_max einhaelt sowie von einem anderen Fz stammt.
//    Vom gefundenen Eintrag wird der Key zurueckgeliefert, bzw. der
//    uebergebnene Key, wenn kein solcher Eintrag gefunden wird.
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  VERLEGEDATEN_KEY anfangspunkt_key = intern_key;

  //Der Eintrag darf nicht vom selben Fz stammen wie der Endeeintrag
  interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
  const ausstattungs_id_t fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
      daten.header.identitaet;

  // Map-Container auf den zum uebergebenen Endeeintrag passenden Anfang
  // setzen
  interne_datenbasis_Fahrspur.finden_eintrag_container(
    Key_des_zugehoerigen_Verlegebeginns(intern_key));
  const unsigned int zeitpunkt_verlegebeginn =
    interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
  const gps_position_rt ort_verlegebeginn =
    interne_datenbasis_Fahrspur.getData()->daten.gps_position;

  // Map-Container auf den Anfang setzen
  interne_datenbasis_Fahrspur.iter_reset();
  bool map_test = interne_datenbasis_Fahrspur.size() > 0;

  //Suchen des naechsten Eintrages eines anderen Fz mit is == 3
  while ((map_test) && (anfangspunkt_key == intern_key))
  {
    if (interne_datenbasis_Fahrspur.getData()->intstat == 3)
    {
      if((interne_datenbasis_Fahrspur.getData()->daten.header.identitaet != fahrzeug_identitaet) &&
         (interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit <= T_zusammen_max + zeitpunkt_verlegebeginn) &&
         (interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit > zeitpunkt_verlegebeginn - T_zusammen_max) &&
         (Punktabstand(interne_datenbasis_Fahrspur.getData()->daten.gps_position, ort_verlegebeginn) < S_zusammen_max) &&
         (IS_des_zugehoerigen_Verlegeendes(interne_datenbasis_Fahrspur.getKey()) != 6) &&
         (IS_des_zugehoerigen_Verlegeendes(interne_datenbasis_Fahrspur.getKey()) != 7))
      {

        if((Winkel_zwischen_Fahrspuren_mehrerer_Fz(intern_key,interne_datenbasis_Fahrspur.getKey()) <= W_zusammen_max) &&
           (Winkel_zwischen_Fahrspuren_mehrerer_Fz(intern_key,interne_datenbasis_Fahrspur.getKey()) != -1))
          anfangspunkt_key = interne_datenbasis_Fahrspur.getKey();

      }
    }
    map_test = interne_datenbasis_Fahrspur.iter_modify(+1);
  }

  return (anfangspunkt_key);
} // end of Key_eines_Verlegebeginns_im_Zeitfenster
//-------------------------------------------------------------------------


//f+-----------------------------------------------------------------------
static VERLEGEDATEN_KEY Eine_Nachbarspur_ist_unvollstaendig(
  const VERLEGEDATEN_KEY &intern_key, int IS1, int IS2)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Es wird sich im folgenden auf den zugehoerigen Verlegebeginn zur
//    uebergebenen Verlegeende-MVP bezogen.
//    Diese Funktion ermittelt einen Verlegebeginn-Eintrag aus dem
//    Map-Container interne_datenbasis_Fahrspur, der zu der (uebergebenen)
//    Verlegeanfangs-MVP im Zeitbereich +/- T_zusammen_max liegt und die
//    S_zusammen_max einhaelt sowie von einem anderen Fz stammt
//    UND keinen zugehoerigen Verlegeendeeintrag aufweist der
//    Interpretationsstatus 8 oder 10 hat.
//    Vom gefundenen Eintrag wird der Key zurueckgeliefert, bzw. der
//    uebergebnene Key, wenn kein solcher Eintrag gefunden wird.
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  VERLEGEDATEN_KEY langsamerer_partner_key = intern_key;


  //Der Eintrag darf nicht vom selben Fz stammen wie der Endeeintrag
  interne_datenbasis_Fahrspur.finden_eintrag_container(intern_key);
  const ausstattungs_id_t fahrzeug_identitaet = interne_datenbasis_Fahrspur.getData()->
      daten.header.identitaet;

  // Map-Container auf den zum uebergebenen Endeeintrag passenden Anfang
  // setzen
  interne_datenbasis_Fahrspur.finden_eintrag_container(
    Key_des_zugehoerigen_Verlegebeginns(intern_key));
  const unsigned int zeitpunkt_verlegebeginn =
    interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
  const gps_position_rt ort_verlegebeginn =
    interne_datenbasis_Fahrspur.getData()->daten.gps_position;

  // Map-Container auf den Anfang setzen
  interne_datenbasis_Fahrspur.iter_reset();
  bool map_test = interne_datenbasis_Fahrspur.size() > 0;

  //Suchen des naechsten Eintrages eines anderen Fz mit is == 3
  while ((map_test) && (langsamerer_partner_key == intern_key))
  {
    if (interne_datenbasis_Fahrspur.getData()->intstat == 3)
    {
      if
      (
        (interne_datenbasis_Fahrspur.getData()->
         daten.header.identitaet != fahrzeug_identitaet)
        &&
        (interne_datenbasis_Fahrspur.getData()->
         daten.gps_zeit.gps_zeit <=
         T_zusammen_max + zeitpunkt_verlegebeginn)
        &&
        (interne_datenbasis_Fahrspur.getData()->
         daten.gps_zeit.gps_zeit >
         zeitpunkt_verlegebeginn - T_zusammen_max)

        &&
        (Punktabstand(interne_datenbasis_Fahrspur.getData()->
                      daten.gps_position,
                      ort_verlegebeginn)
         < S_zusammen_max)
        &&
        (IS_des_zugehoerigen_Verlegeendes(interne_datenbasis_Fahrspur.getKey()) != IS1)
        &&
        (IS_des_zugehoerigen_Verlegeendes(interne_datenbasis_Fahrspur.getKey()) != IS2)
      )
      {

        if
        ((Winkel_zwischen_Fahrspuren_mehrerer_Fz(
              intern_key, interne_datenbasis_Fahrspur.getKey())
            <= W_zusammen_max)
            &&
            (Winkel_zwischen_Fahrspuren_mehrerer_Fz(
               intern_key, interne_datenbasis_Fahrspur.getKey()) != -1)
        )
          langsamerer_partner_key = interne_datenbasis_Fahrspur.getKey();

      }
    }
    map_test = interne_datenbasis_Fahrspur.iter_modify(+1);
  }

  return (langsamerer_partner_key);
} // end of Eine_Nachbarspur_ist_unvollstaendig
//-------------------------------------------------------------------------


//f+-----------------------------------------------------------------------
static void Gib_den_Partnern_IS11(VERLEGEDATEN_KEY intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion ermittelt alle Verlegebeginn-Eintraege aus dem
//    Map-Container interne_datenbasis_Fahrspur, die zur selben Minensperre //    gehoeren, wie die eine MVP mit IS 11 und versieht diese ebenfalls mit //    IS 11.
//
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  DEBUG_LOG(loggerMI()) << "Gib_den_Partnern_IS11: " << intern_key.fz_id << "," << intern_key.zeitpunkt.gps_zeit;
  VERLEGEDATEN_KEY  endpunkt_key_eines_partners = intern_key;

  for (int i = 0; i < 2; i++)
  {
    intern_key = endpunkt_key_eines_partners;
    // Map-Container auf den zum uebergebenen Endeeintrag passenden Anfang
    // setzen
    interne_datenbasis_Fahrspur.finden_eintrag_container(
      Key_des_zugehoerigen_Verlegebeginns(endpunkt_key_eines_partners));
    const unsigned int zeitpunkt_verlegebeginn =
      interne_datenbasis_Fahrspur.getData()->daten.gps_zeit.gps_zeit;
    const gps_position_rt ort_verlegebeginn =
      interne_datenbasis_Fahrspur.getData()->daten.gps_position;
    // Map-Container auf den Anfang setzen
    interne_datenbasis_Fahrspur.iter_reset();
    bool map_test = interne_datenbasis_Fahrspur.size() > 0;

    //Suchen des naechsten Eintrages eines anderen Fz mit is == 3
    while (map_test)
    {
      if ((interne_datenbasis_Fahrspur.getData()->intstat == 3)
          && (IS_des_zugehoerigen_Verlegeendes(interne_datenbasis_Fahrspur.getKey()) == 10))
      {
        if
        (
          (interne_datenbasis_Fahrspur.getData()->
           daten.gps_zeit.gps_zeit <=
           T_zusammen_max + zeitpunkt_verlegebeginn)
          &&
          (interne_datenbasis_Fahrspur.getData()->
           daten.gps_zeit.gps_zeit >
           zeitpunkt_verlegebeginn - T_zusammen_max)
          &&
          (Punktabstand(interne_datenbasis_Fahrspur.getData()->
                        daten.gps_position,
                        ort_verlegebeginn)
           < S_zusammen_max)
          &&
          (Winkel_zwischen_Fahrspuren_mehrerer_Fz(
             intern_key,interne_datenbasis_Fahrspur.getKey())
           <= W_zusammen_max)
          &&
          (Winkel_zwischen_Fahrspuren_mehrerer_Fz(
             intern_key,interne_datenbasis_Fahrspur.getKey()) != -1)
        )
        {
          //Der zugehoerige Verlegeende-Eintrag wird mit
          //Interpretationsstatus 11 versehen

          //Suchen des nachfolgenden Eintrages des Fz mit is ==10
          while ((interne_datenbasis_Fahrspur.iter_modify(+1))
                 && (interne_datenbasis_Fahrspur.getData()->intstat != 10))
            ;

          endpunkt_key_eines_partners =
            interne_datenbasis_Fahrspur.getKey();

          interne_datenbasis_Fahrspur.getData()->intstat = 11;
          interne_datenbasis_Fahrspur.iter_reset();
        }
      }
      map_test = interne_datenbasis_Fahrspur.iter_modify(+1);
    }
  }
} // end of Gib_den_Partnern_IS11
//-------------------------------------------------------------------------


static inline PositionMitZeit getPrev(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator it,
                                      ausstattungs_id_t identitaet)
{
  PositionMitZeit ret;
  if (it == interne_datenbasis_Fahrspur.c().begin())
    return ret;
  --it;
  if (it->second.daten.header.identitaet != identitaet)
    return ret;
  ret.pos = it->second.daten.gps_position;
  ret.zeit = it->second.daten.gps_zeit.gps_zeit;
  return ret;
}

static inline PositionMitZeit getCurr(const std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator &it)
{
  PositionMitZeit ret;
  ret.pos = it->second.daten.gps_position;
  ret.zeit = it->second.daten.gps_zeit.gps_zeit;
  return ret;
}

static inline PositionMitZeit getNext(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator it,
                                      ausstattungs_id_t identitaet)
{
  PositionMitZeit ret;
  if (it == interne_datenbasis_Fahrspur.c().end())
    return ret;
  ++it;
  if (it == interne_datenbasis_Fahrspur.c().end() || it->second.daten.header.identitaet != identitaet)
    return ret;
  ret.pos = it->second.daten.gps_position;
  ret.zeit = it->second.daten.gps_zeit.gps_zeit;
  return ret;
}

//f+-----------------------------------------------------------------------
static bool B1(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag eine
//    Minenverlegeposition(MVP) ist, die keiner Verlegespur zugeordnet
//    werden kann.
//    Diese Funktion gibt true zurueck, wenn
//    (Das Fz innerhalb von T_allein_Luecke_max keine nachfolgende MVP
//    gesendet hat ODER die nachfolgende MVP gegen S_allein_Luecke_max
//    verstoesst)
//    UND
//    (Die Vorgaengler-MVP gegen T_allein_Luecke_max verstoesst bzw. diese
//    nicht vorhanden ist ODER die Vorgaenger-MVP gegen S_allein_Luecke_max
//    verstoesst)
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  // Map-Container auf aktuellen Eintrag setzen
  const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;

  const PositionMitZeit p1 = getPrev(itFs, fahrzeug_identitaet);
  const PositionMitZeit p2 = getCurr(itFs);
  const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);

/*
  if( ( (
          ((time(0) > zeit2 + T_allein_Luecke_max) && (zeit3 == 0)) ||
          ((zeit3 - zeit2 > T_allein_Luecke_max) && (zeit3 != 0))
        ) ||
        (Punktabstand(ort2, ort3) > S_allein_Luecke_max)
      )
      &&
      (
        ((zeit1 != 0) && (zeit2 - zeit1 > T_allein_Luecke_max))
        ||
        ((Punktabstand(ort2, ort1) > S_allein_Luecke_max) || (zeit1 == 0))
      )
    )
    return (true);*/
  // Keine MVP-Zuordnung wenn:
  // Vorgaenger: nicht vorhanden oder raeumlicher oder zeiticher Abstand zu groß
  //   falls zutreffend Nachfolger: nicht vorhanden oder raeumlicher oder zeiticher Abstand zu groß
  //     falls zutreffend Alter der pruefen

  // Pruefung auf Vorgaenger
  if ((p1.zeit == 0) || (Punktabstand(p2.pos, p1.pos) > S_allein_Luecke_max) || (p2.zeit - p1.zeit > T_allein_Luecke_max))
    //Pruefung auf Nachfolger
    if ((p3.zeit == 0) || (Punktabstand(p2.pos, p3.pos) > S_allein_Luecke_max) || (p3.zeit - p2.zeit > T_allein_Luecke_max))
      // Pruefung auf zu alt
      if (time(nullptr) > (p2.zeit + T_allein_Luecke_max))
        return (true);

  return (false);
} // end of B1
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
static bool B2(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag einer
//    Verlegespur zugerechnet werden kann.
//    Diese Funktion gibt true zurueck, wenn
//    (Das Fz eine Vorgaenger-MVP gesendet hat, die T_allein_Luecke_max
//    UND S_allein_Luecke_max einhaelt)
//    ODER
//    (Das Fz eine Nachfolge-MVP gesendet hat, die T_allein_Luecke_max
//    UND S_allein_Luecke_max einhaelt)
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;

  const PositionMitZeit p1 = getPrev(itFs, fahrzeug_identitaet);
  const PositionMitZeit p2 = getCurr(itFs);
  const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);

  if (
    (
      ((p1.zeit != 0) && (p2.zeit - p1.zeit <= T_allein_Luecke_max))
      &&
      (Punktabstand(p2.pos, p1.pos) <= S_allein_Luecke_max)
    )
    ||
    (
      ((p3.zeit != 0) && (p3.zeit - p2.zeit <= T_allein_Luecke_max))
      &&
      (Punktabstand(p2.pos, p3.pos) <= S_allein_Luecke_max)
    )
  )
    return (true);
  return (false);
} // end of B2
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
static bool B3(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
//    Anfangspunkt einer Verlegespur ist.
//    Diese Funktion gibt true zurueck, wenn
//    (Das Fz keine Vorgaenger-MVP gesendet hat ODER eine Vorgaenger-MVP
//    gesendet hat, die gegen T_allein_Luecke_max ODER S_allein_Luecke max
//    verstoesst)
//    UND
//    (Das Fz eine Nachfolge-MVP gesendet hat, die T_allein_Luecke_max
//    UND S_allein_Luecke_max einhaelt)
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;

  const PositionMitZeit p1 = getPrev(itFs, fahrzeug_identitaet);
  const PositionMitZeit p2 = getCurr(itFs);
  const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);

  if (
    (
      ((p1.zeit == 0) || (p2.zeit - p1.zeit > T_allein_Luecke_max))
      ||
      (Punktabstand(p2.pos, p1.pos) > S_allein_Luecke_max)
    )
    &&
    (
      ((p3.zeit != 0) && (p3.zeit - p2.zeit <= T_allein_Luecke_max))
      &&
      (Punktabstand(p2.pos, p3.pos) <= S_allein_Luecke_max)
    )
  )
    return (true);
  return (false);
} // end of B3
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
static bool B4(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
//    Endpunkt einer Verlegespur ist.
//    Diese Funktion gibt true zurueck, wenn
//    (Das Fz innerhalb von T_allein_Luecke_max keine Nachfolger-MVP
//    gesendet hat ODER eine Nachfolger-MVP
//    gesendet hat, die gegen T_allein_Luecke_max ODER S_allein_Luecke max
//    verstoesst)
//    UND
//    (Das Fz eine Vorgaenger-MVP gesendet hat, die T_allein_Luecke_max
//    UND S_allein_Luecke_max einhaelt)
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;

  const PositionMitZeit p1 = getPrev(itFs, fahrzeug_identitaet);
  const PositionMitZeit p2 = getCurr(itFs);
  const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);

  if (
    (
      (p1.zeit != 0)
      && (p2.zeit - p1.zeit <= T_allein_Luecke_max)
      && (Punktabstand(p2.pos, p1.pos) <= S_allein_Luecke_max)
    )
    &&
    (
      (((p3.zeit == 0) && (time(nullptr) > p2.zeit + T_allein_Luecke_max))
       || ((p3.zeit != 0) && (p3.zeit - p2.zeit > T_allein_Luecke_max))
      )
      ||
      ((p3.zeit != 0) && (Punktabstand(p2.pos, p3.pos) > S_allein_Luecke_max))
    )
  )
    return (true);
  return (false);
} // end of B4
//-------------------------------------------------------------------------


//f+-----------------------------------------------------------------------
static bool B5(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
//    Endpunkt einer Verlegespur ist, die nicht durch das selbe Fahrzeug zu
//    einer mehrspurigen Minensperre ausgebaut wird.
//    Diese Funktion gibt true zurueck, wenn
//    [(Das Fz innerhalb von T_allein_max keine Nachfolger-MVP gesendet hat
//    ODER eine Nachfolger-MVP gesendet hat, die gegen T_allein_max
//    ODER S_allein_max verstoesst)
//    ODER
//    (Die Nachfolger-MVP den Interpretationsstatus 3 hat UND W_allein_max
//     nicht eingehalten wird)]
//     UND
//    [(unmittelbar vor dem zugehoerigen Verlegeanfang keine MVP fuer
//     dieses Fz mit Interpretationsstatus 6 im Map-Container vorliegt)]
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;

  const PositionMitZeit p2 = getCurr(itFs);
  const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);

  if (
    ((Eintrag_vor_zugehoerigem_Verlegebeginn(itFs->first) != 6)
     && (Eintrag_vor_zugehoerigem_Verlegebeginn(itFs->first) != 4))
    &&
    (
      ((p3.zeit == 0) && (time(nullptr) > p2.zeit + T_allein_max))
      ||
      ((p3.zeit != 0) && (p3.zeit - p2.zeit > T_allein_max))
      ||
      ((p3.zeit != 0) && (Punktabstand(p2.pos, p3.pos) > S_allein_max))
      ||
      ((Eintrag_nach_dieser_MVP(itFs->first) == 3)
       &&
       (Winkel_zwischen_Fahrspuren_eines_Fz(itFs->first)
        > W_allein_max)
      )
    )
  )

    return (true);
  return (false);
} // end of B5
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
static bool B6(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
//    Endpunkt einer Verlegespur ist, die durch das selbe Fahrzeug zu
//    einer mehrspurigen Minensperre ausgebaut wird.
//    Diese Funktion gibt true zurueck, wenn
//    (Das Fz eine Nachfolger-MVP gesendet hat, die den
//    Interpretationsstatus 3 hat UND T_allein_max UND
//    S_allein_max einhaelt)
//    UND
//    (W_allein_max zwischen den Fahrspuren eingehalten wird)
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;

  const PositionMitZeit p2 = getCurr(itFs);
  const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);

  if (
    (Winkel_zwischen_Fahrspuren_eines_Fz(itFs->first)
     <= W_allein_max)
    &&
    (Winkel_zwischen_Fahrspuren_eines_Fz(itFs->first) != -1)
    &&
    (Eintrag_nach_dieser_MVP(itFs->first) == 3)
    &&
    (p3.zeit - p2.zeit <= T_allein_max)
    &&
    (Punktabstand(p2.pos, p3.pos) <= S_allein_max)
  )
    return (true);
  return (false);
} // end of B6
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
static bool B7(std::map<VERLEGEDATEN_KEY, FAHRSPUR_INTERN>::const_iterator itFs)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
//    Endpunkt einer durch das selbe Fahrzeug mehrspurig fertig ausgebauten
//    Minensperre ist.
//    Diese Funktion gibt true zurueck, wenn
//    (Das Fz innerhalb von T_allein_max keine Nachfolger-MVP gesendet hat
//    ODER eine Nachfolger-MVP gesendet hat, die gegen T_allein_max
//    ODER S_allein_max verstoesst)
//    UND
//    (unmittelbar vor dem zugehoerigen Verlegeanfang eine MVP fuer dieses
//    Fz mit Interpretationsstatus 6 im Map-Container vorliegt)
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  const ausstattungs_id_t fahrzeug_identitaet = itFs->second.daten.header.identitaet;

  const PositionMitZeit p2 = getCurr(itFs);
  const PositionMitZeit p3 = getNext(itFs, fahrzeug_identitaet);

  if (
    (Eintrag_vor_zugehoerigem_Verlegebeginn(itFs->first) == 6)
    &&
    ((
       ((p3.zeit == 0) && (time(nullptr) > p2.zeit + T_allein_max))
       ||
       ((p3.zeit != 0) && (p3.zeit - p2.zeit > T_allein_max))
       ||
       ((p3.zeit != 0) && (Punktabstand(p2.pos, p3.pos) > S_allein_max))
     )
     ||
     ((Winkel_zwischen_Fahrspuren_eines_Fz(itFs->first)
       > W_allein_max)
      &&
      (Eintrag_nach_dieser_MVP(itFs->first) == 3))
    )
  )
    return (true);
  return (false);
} // end of B7
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
static bool B8(const VERLEGEDATEN_KEY &intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
//    Endpunkt einer Verlegespur ist, die zu einer Minensperre gehoert,
//    die durch mehrere Fahrzeuge ausgebaut wird.
//    Diese Funktion gibt true zurueck, wenn
//    (Der zu dieser Fahrspur gehoerende Verlegeanfang mindestens
//     T_zusammen_max zurueckliegt)
//    UND
//    [(Bezueglich des Verlegebeginns der aktuellen Fahrspur, ein anderes
//     Fz im Zeitraum +/- T_zusammen_max eine MVP mit Interpretationsstatus
//     3 aufweist UND diese S_zusammen_max einhaelt)
//    UND
//    (W_zusammen_max zwischen beiden Fahrspuren eingehalten wird)
//    Der gesamte Map-Container wird durchsucht, bis ein solcher Eintrag
//    gefunden ist.]
//    Die Funktionalitaet in [] wird in der Funktion
//    Key_eines_Verlegebeginns_im_Zeitfenster_realisiert.
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  bool bRet = false;

  const auto itBegin = interne_datenbasis_Fahrspur.c().find(Key_des_zugehoerigen_Verlegebeginns(intern_key));
  if (itBegin == interne_datenbasis_Fahrspur.c().end())
    return bRet;

  if ((time(nullptr) > itBegin->second.daten.gps_zeit.gps_zeit + T_zusammen_max)  &&
      (Key_eines_Verlegebeginns_im_Zeitfenster(intern_key) != intern_key))
    bRet = true;

  TRACE_LOG(loggerMI()) << "B8 check for " << intern_key.fz_id << "," << intern_key.zeitpunkt.gps_zeit << ": " << bRet;
  return (bRet);
} // end of B8
//-------------------------------------------------------------------------


//f+-----------------------------------------------------------------------
static bool B9(const VERLEGEDATEN_KEY &intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
//    Endpunkt einer Verlegespur ist, welche eine einspurige Minensperre
//    bildet.
//    Diese Funktion gibt true zurueck, wenn
//    (Der zu dieser Fahrspur gehoerende Verlegeanfang mindestens
//     T_zusammen_max zurueckliegt)
//    UND
//    (B8 nicht erfuellt wird)
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  bool bRet = false;

  const auto itBegin = interne_datenbasis_Fahrspur.c().find(Key_des_zugehoerigen_Verlegebeginns(intern_key));
  if (itBegin == interne_datenbasis_Fahrspur.c().end())
    return bRet;

  if ((time(nullptr) > itBegin->second.daten.gps_zeit.gps_zeit + T_zusammen_max)  &&
      (Key_eines_Verlegebeginns_im_Zeitfenster(intern_key) == intern_key))
    bRet = true;

  TRACE_LOG(loggerMI()) << "B9 check for " << intern_key.fz_id << "," << intern_key.zeitpunkt.gps_zeit << ": " << bRet;
  return (bRet);
} // end of B9
//-------------------------------------------------------------------------


//f+-----------------------------------------------------------------------
static bool B10(const VERLEGEDATEN_KEY &intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
//    Endpunkt einer durch mehrere Fahrzeuge angelegten Minensperre ist,
//    von der schon mindestens zwei Fahrspuren fertig verlegt sind.
//    Der Interpretationsstatus 10 wurde eingefuert, um sicherzustellen,
//    dass alle Verlegespuren einer Minensperre erfasst werden, und nicht
//    der Fall eintritt, dass eine ev. 3.Verlegespur unbeachtet bleibt.
//    Diese Funktion gibt true zurueck, wenn
//    (Alle Eintraege, die fuer das Erfuellen von B8 bezueglich des
//    aktuellen Endpunktes in Frage kommen, bereits einen zugehoerigen
//     Endeeintrag mit Interpretationsstatus 8 oder 10 haben.
//
//
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  bool bRet = false;

  if (Eine_Nachbarspur_ist_unvollstaendig(intern_key, 8, 10) == intern_key)
    bRet = true;

  TRACE_LOG(loggerMI()) << "B10 check for " << intern_key.fz_id << "," << intern_key.zeitpunkt.gps_zeit << ": " << bRet;
  return (bRet);
} // end of B10
//-------------------------------------------------------------------------


//f+-----------------------------------------------------------------------
static bool B11(const VERLEGEDATEN_KEY &intern_key)
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion prueft den aktuellen Eintrag des Map-Containers
//    interne_datenbasis_Fahrspur daraufhin, ob dieser Eintrag ein
//    Endpunkt einer durch mehrere Fahrzeuge angelegten Minensperre ist,
//    von der schon mindestens zwei Fahrspuren fertig verlegt sind.
//    Der Interpretationsstatus 10 wurde eingefuert, um sicherzustellen,
//    dass alle Verlegespuren einer Minensperre erfasst werden, und nicht
//    der Fall eintritt, dass eine ev. 3.Verlegespur unbeachtet bleibt.
//    Diese Funktion gibt true zurueck, wenn
//    (Alle Eintraege, die fuer das Erfuellen von B8 bezueglich des
//    aktuellen Endpunktes in Frage kommen, bereits einen zugehoerigen
//     Endeeintrag mit Interpretationsstatus 10 oder 11 haben.
//
//
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  bool bRet = false;

  if (Eine_Nachbarspur_ist_unvollstaendig(intern_key, 10, 11) == intern_key)
    bRet = true;

  TRACE_LOG(loggerMI()) << "B11 check for " << intern_key.fz_id << "," << intern_key.zeitpunkt.gps_zeit << ": " << bRet;
  return (bRet);
} // end of B11
//-------------------------------------------------------------------------

//f+-----------------------------------------------------------------------
void GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::processData()
//-------------------------------------------------------------------------
//    PURPOSE:
//    Diese Funktion wird in tcl_zssiwi_control zyklisch eingeplant.
//    Die Eintraege im internen Map-Container interne_datenbasis_Fahrspur
//    werden mit dem aktuellen Interpretationsstatus versehen.
//    Der Interpretationsstatus hat folgende Bedeutung:
//    0: Diese Minenverlegeposition(MVP) wurde empfangen.
//    1: Diese MVP gehoert keiner Verlegespur an und wird geloescht.
//    2: Diese MVP wird einer Verlegespur zugeordnet.
//    3: Diese MVP ist ein Anfangspunkt einer Verlegespur.
//    4: Diese MVP ist ein Endpunkt einer Verlgegspur.
//    5: Diese MVP ist ein Endpunkt einer Verlegespur, die nicht durch das
//       selbe Fz zu einer mehrspurigen Minensperre weiter ausgebaut wird.
//    6: Die Minensperre wird ab diesem Verlegeendpunkt durch
//       das selbe Fz mehrspurig ausgebaut.
//    7: Die MVP ist der Endpunkt einer durch ein Fz mehrspurig ausgebauten
//       Minensperre
//    8: Die Minensperre zu der dieser Verlege-Endpunkt gehoert, wird durch
//       mehrere Fz ausgebaut.
//    9: Diese MVP ist ein Endpunkt einer einspurigen Minensperre
//   10: Diese MVP ist einer der Endpunkte einer durch meherer Fz  verlegten
//       Minensperre, von der bereits zwei Fahrspuren komplett verlegt sind.
//   11: Diese MVP ist einer der Endpunkte einer durch mehrere Fz fertig
//       verlegten Minensperre
//
//
//    FORMAL PARAMETERS:
//    (Beschreibung der Formalparameter)
//
//    RETURN:
//    (Beschreibung des Returnwertes)
//
//f------------------------------------------------------------------------
{
  //Kontrollausgabe
  //  lout << setprio(LM_INFO)
  //   << "Funktion 'ZSSI_WI_Minen_Interpreter' aufgerufen" << endl;


  //Es werden alle Eintraege geloescht die nicht den
  //Betriebszustand VERLEGEN aufweisen

  auto &cont = interne_datenbasis_Fahrspur.c();
  auto it = cont.begin();
  while (it != cont.end())
  {
    const FAHRSPUR_INTERN &val = it->second;
    if (val.daten.ss_betriebszustand != MV_VERLEGEN &&
        val.daten.ss_betriebszustand != WMV_VERLEGEN)
      it = cont.erase(it);
    else
      ++it;
  }

  //Es wird entschieden, ob die die MVP keiner Verlegespur
  //zugeordnet werden kann.
  it = cont.begin();
  while (it != cont.end())
  {
    const FAHRSPUR_INTERN &val = it->second;
    if (val.intstat == 0 && B1(it))
    {
      //Diese Eintraege muessen geloescht werden!!
      //sie wuerden intstat= 1 erhalten;
      it = cont.erase(it);
    }
    else
      ++it;
  }

  //Es wird entschieden, ob die MVP einer Verlegespur zugeordnet werden
  //kann.
  for (auto it = cont.begin(); it != cont.end(); ++it)
  {
    FAHRSPUR_INTERN &val = it->second;
    if (val.intstat == 0 && B2(it))
      val.intstat = 2;
  }

  //Es wird entschieden, ob die zu einer Verlegespur gehoerige MVP einen
  //Anfangs- oder Endpunkt einer Verlegespur bildet
  for (auto it = cont.begin(); it != cont.end(); ++it)
  {
    FAHRSPUR_INTERN &val = it->second;
    if (val.intstat == 2)
    {
      if (B3(it))
        val.intstat = 3;
      else if (B4(it))
        val.intstat = 4;
    }
  }

  //Es wird entschieden, ob die MVP die einen Endpunkt einer Verlegespur
  //darstellt, zu einer Minensperre gehoert, die durch das selbe Fahrzeug
  //ausgebaut wird oder wurde.
  for (auto it = cont.begin(); it != cont.end(); ++it)
  {
    FAHRSPUR_INTERN &val = it->second;
    if (val.intstat == 4)
    {
      if (B5(it))
        val.intstat = 5;
      else if (B6(it))
        val.intstat = 6;
      else if (B7(it))
        val.intstat = 7;
    }
  }


  //Es wird entschieden, ob die MVP die einen Endpunkt einer Verlegespur
  //darstellt, zu einer Minensperre gehoert, die durch mehrere Fahrzeuge
  //ausgebaut wird oder wurde.
  for (auto &c : cont)
  {
    FAHRSPUR_INTERN &val = c.second;
    if (val.intstat == 5)
    {
      const auto key = keyFromFahrspur(val);
      if (B8(key))
        val.intstat = 8;
      else if (B9(key))
        val.intstat = 9;
    }
  }

  //Es wird entschieden, ob die MVP einen Endpunkt einer durch mehrere
  //Fahrzeuge angelegten Minensperre darstellt, von der bereits zwei
  //Verlegespuen fertig verlegt sind.
  for (auto &c : cont)
  {
    FAHRSPUR_INTERN &val = c.second;
    if (val.intstat == 8 && B10(keyFromFahrspur(val)))
      val.intstat = 10;
  }

  //Es wird entschieden, ob die MVP einen Endpunkt einer durch mehrere
  //Fahrzeuge fertig angelegten Minensperre darstellt.
  for (auto &c : cont)
  {
    FAHRSPUR_INTERN &val = c.second;
    if (val.intstat == 10)
    {
      const auto key = keyFromFahrspur(val);
      if (B11(key))
      {
        val.intstat = 11;
        //Der gesamte map-Container wird nun nach zugehoerigen
        //Verlegeendepositionen durchsucht. Das sind die, bei denen das
        //Erfuellen von B8 durch den aktuellen Eintrag erfolgte.
        //Um alle zusammengehoerigen Verlegespuren mit IS 11 versehen zu
        //koennen, muss der Map-Container mehrfach durchsucht werden.
        //Bei einem Start des Minenfeld_Generators, wird somit dafuer
        //gesorgt, dass maximal eine durch mehrere Fz verlegte Minensperre
        //(die Endpunkte tragen den Interpretationsstatus 11) im Map-Container
        //vorhanden ist.
        Gib_den_Partnern_IS11(key);
        break;    // warum auch immer, aber noetig (vorher: goto ... )
      }
    }
  }

  DEBUG_LOG(loggerMI()) << "------------------------------------------------";
  for (const auto &c : interne_datenbasis_Fahrspur.c())
  {
    const VERLEGEDATEN_KEY &key = c.first;
    const FAHRSPUR_INTERN &val = c.second;
    DEBUG_LOG(loggerMI()) << "key: " << key.fz_id << "," << key.zeitpunkt.gps_zeit
                        << ", val: " << val.intstat << ", " << val.daten.header.identitaet
                        << ", " << val.daten.gps_position.utm_ostwert << "/" << val.daten.gps_position.utm_nordwert;
  }

  m_minenfeldGenerator->processData();

}  // end of ZSSI_WI_Minen_Interpreter
//-------------------------------------------------------------------------

GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::ZSSI_WI_Minenfeld_Interpreter(QObject *parent)
  : QObject(parent)
  , m_minenfeldGenerator(new ZSSI_WI_Minenfeld_Generator(this))
{
  connect(m_minenfeldGenerator, &ZSSI_WI_Minenfeld_Generator::sendeWirkfeld, this, &ZSSI_WI_Minenfeld_Interpreter::sendeWirkfeld);
}

GuezMinelayerProcessing::ZSSI_WI_Minenfeld_Interpreter::~ZSSI_WI_Minenfeld_Interpreter()
{
  delete m_minenfeldGenerator;
}