/**
  * MainHandlerSqlite for AereaEffectSimulation
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Hanna E. Rathje, SLSE, 2016-01-13
  */
#pragma once

#include <QJsonObject>
#include <QObject>
#include <QSqlDatabase>
#include <memory>

#include "dds_handler.h"
#include "logger.h"
#include <SituationReplay/srp_db.h>
#include <SituationReplay/situationreplaysqlite_export.h>

namespace DDSConnector
{
class DdsConnector;
}
namespace NGLDB
{
template <typename DB> class DbServiceHandler;
}

namespace FileManagement
{
namespace Database
{
struct FlmFileContent;
}
}

namespace SituationReplay
{
struct TimeSpan
{
  qint64 begin = 0;
  qint64 end = 0;
  static SituationReplay::TimeSpan fromJson(const QJsonObject &obj)
  {
    SituationReplay::TimeSpan ts;
    ts.begin = qRound64(obj[QStringLiteral("start")].toDouble());
    ts.end = qRound64(obj[QStringLiteral("end")].toDouble());
    return ts;
  }
  QJsonObject toJson() const
  {
    return {
      {QStringLiteral("start"), begin},
      {QStringLiteral("end"), end},
    };
  }
};

struct ReplayInformation
{
  int id = 0;
  TimeSpan timeSpan;          // playbackTime        msec since epoche
  TimeSpan relativeTimeSpan;  // timeInPresentation  msec since begin SCRIPT
  QString databaseFilePath;   // path to sqlite db
  QString replayConfigPath;   // sitmap.json
};

struct FilterInformation
{
  int id = 0;
  int overlayId = 0;
  TimeSpan relativeTimeSpan;
  QJsonObject aesFilters;
  QJsonObject symbolSettings;
  QJsonObject buildingComponentSettings;
  QJsonObject mapSettings;
};

class DbReader;
class StaticPublisher;
class HandlerSituationReplaySqlite;
using DbHandler = NGLDB::DbServiceHandler<DatabaseInterface>;

class SITUATIONREPLAYSQLITE_EXPORT MainHandlerSqlite final : public QObject
{
  Q_OBJECT
public:
  MainHandlerSqlite();
  ~MainHandlerSqlite();

  bool initDb(const ReplayInformation &replayInformation,
              const QVector<FilterInformation> &filter,
              const QVector<FilterInformation> &overlays);// first init dds needed!
  bool initDds(const ConnectionParams &output);

  std::shared_ptr<HandlerSituationReplaySqlite> handlerSrp() const { return m_handlerSrp; }
  std::shared_ptr<DDSConnector::DdsConnector> ddsReplay() const;

Q_SIGNALS:
  void initialReplaySpeed(double speed);
  void applyCurentFilter(const SituationReplay::FilterInformation &filter);
  void applyNewOverlay(int overlayId);
  void removeOverlay(int overlayId);
  void fileContentAvailable(const FileManagement::Database::FlmFileContent &data);
private:
  bool initSrpHandler(int partitionIdIn, int partitionIdOut, qint64 beginTime, qint64 endTime);
  bool initStaticPublisher();
  bool loadReplayConfig(const QString &replayConfigPath);
  void maybeApplyNextFilter(qint64 curTime);
  void replayTimeMaybeJumpedFilter(qint64 curTime);
  void maybeAddNewOverlay(qint64 curTime);
  void removeOutdatedOverlays(qint64 curTime);
  void replayTimeMaybeJumpedOverlays(qint64 curTime);
  int findNextIndex(qint64 curTime, int curIdx, const QVector<FilterInformation> &data) const;
private Q_SLOTS:
  void onReplayTimeChanged(qint64 curTime);
  void onReplayTimeMaybeJumped(qint64 curTime);

private:
  QVector<FilterInformation> m_filter;
  QVector<FilterInformation> m_overlays;
  QVector<FilterInformation> m_currentVisibleOverlays;
  ReplayInformation m_replay;
  int m_curFilterArrayIdx;
  int m_curOverlayArrayIdx;
  std::shared_ptr<HandlerSituationReplaySqlite> m_handlerSrp;
  std::unique_ptr<StaticPublisher>        m_staticPublisher;
  std::shared_ptr<DdsHandler>             m_ddsInterface;
  std::shared_ptr<DbHandler>              m_dbHandler;
  std::shared_ptr<DbReader>               m_dbReader;
  QSqlDatabase                            m_dbSqlite;
  NGL::INGLLogger                        &m_logger;

};
} // namespace SituationReplay