#pragma once

#include "logger.h"
#include "ltselevation_export.h"

#include <LtsUtils/LtsUtilsCore/qpoint3d.h>
#include <QCoreApplication>
#include <QMap>
#include <QObject>
#include <QPointer>
#include <QStringList>
#include <iosfwd>
#include <memory>

namespace LtsSession
{
class LtsSessionDataDds;
}

namespace ExerciseManagement
{
namespace Interface
{
class Dtc;
}
} // namespace ExerciseManagement

#ifdef BUILD_RTI
namespace AssetManagement
{
namespace Interface
{
class Dtc;
}
} // namespace AssetManagement
#endif

namespace LtsElevation
{

enum class LineOfSight { LOS_UNDEFINED, LOS_ERROR, LOS_VISIBLE, LOS_INVISIBLE };

class LtsElevationManager;
using LTS_ELEVATION_MANAGER_TYPE = QPointer<LtsElevationManager>;

class LTSELEVATION_EXPORT LtsElevationManager : public QObject
{
  public:
    static LTS_ELEVATION_MANAGER_TYPE
    createInstance(int exerciseId, const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc = {},
#ifdef BUILD_RTI
                   const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc = {}
#else
                   const std::shared_ptr<void>& asmDtc = {}
#endif
    );

    static LTS_ELEVATION_MANAGER_TYPE getInstance(int exerciseId);

#ifdef BUILD_RTI
    static LTS_ELEVATION_MANAGER_TYPE
    createInstanceForTrainingAreaId(int trainingAreaId,
                                    const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc = nullptr);
#endif

    static void cleanupAll();
    virtual ~LtsElevationManager();

    bool waitForInitialization();
    bool isValid() const;

    double elevation(double lon_rad, double lat_rad, double defaultValue = std::numeric_limits<double>::min(),
                     bool* bIsCovered = nullptr) const;

    LineOfSight lineOfSightCalculation(const LtsUtils::QPoint3D& startPointGeo_absZ,
                                       const LtsUtils::QPoint3D& endPointGeo_absZ);

    LineOfSight lineOfSightCalculation(const QPointF& startPointGeo, double startHat, const QPointF& endPointGeo,
                                       double endHat);

  protected:
    explicit LtsElevationManager();

    void initDDS(const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc,
#ifdef BUILD_RTI
                 const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc
#else
                 const std::shared_ptr<void>& asmDtc
#endif
    );
    bool init(const QStringList& filePaths_rough_to_fine);
    static int exerciseIdToTrainingAreaId(int exerciseId,
                                          const std::shared_ptr<ExerciseManagement::Interface::Dtc>& exmDtc);

    QStringList getFilenamesForExercise(int exerciseId);
    QStringList getFilenamesForTrainingArea(int trainingAreaId);

    static LTS_ELEVATION_MANAGER_TYPE createInstanceUnitTest(int id, const QStringList& filePaths_rough_to_fine);

  private:
    class Private;

    Private* d;
    LOGGER_T m_logger;
};

LTSELEVATION_EXPORT const QString toString(const LtsElevation::LineOfSight& value);

LTSELEVATION_EXPORT std::ostream& operator<<(std::ostream& stream, const LtsElevation::LineOfSight value);

} // namespace LtsElevation