/**
  * MainHandler for AereaEffectSimulation
  * $Id$
  * $HeadURL$
  * $Author$
  */
#pragma once

#include <QObject>
#include <memory>

#include <TrainingAreaBase/tab_dtc.h>

#include "aes_db.h"
#include "dds_handler.h"
#include "logger.h"

namespace NGLDB
{
template <typename DB> class DbServiceHandler;
}
namespace AreaEffectSimulation
{
using DbHandler = NGLDB::DbServiceHandler<DatabaseInterface>;
class HandlerAirSupportImpact;
class HandlerExplosionSingle;
class HandlerExplosionArea;
class HandlerEffectCluster;
class HandlerExplosionCluster;
class HandlerNContamination;
class HandlerBCContamination;
class HandlerBoobyTrap;
class HandlerOffRouteMine;
class HandlerMineArea;
class HandlerMineCorridor;
class HandlerDangerArea;
class HandlerChargeAdministration;
class HandlerFunctionalArea;
class HandlerTechnicalArea;
class HandlerReconArea;
class MeteoDataProvider;
class SpecialAreaProvider;
class HandlerBorderline;
class HandlerGasPipe;
class HandlerDusSingleMine;
class HandlerChargeEffect;
class HandlerTrajectory;
class HandlerEffector;

class MainHandler : public QObject
{
    Q_OBJECT
public:
    explicit MainHandler(QObject *parent = nullptr);
    ~MainHandler();

    bool init(int domainId, int exerciseId);

    std::shared_ptr<DdsHandler> dds() {
        return m_ddsHandler;
    }
    std::shared_ptr<DatabaseInterface> db();
    std::shared_ptr<DatabaseInterface> dbEx0();
    std::shared_ptr<MeteoDataProvider> meteoData() {
        return m_meteoData;
    }
    std::shared_ptr<SpecialAreaProvider> specialAreaProvider() {
        return m_specialAreaProvider;
    }
    std::shared_ptr<HandlerChargeAdministration>   chargeAdministrationHandler() {
        return m_handlerChargeAdmin;
    }
    std::shared_ptr<HandlerBCContamination>        bcContaminationHandler() {
        return m_handlerBCContamination;
    }
    std::shared_ptr<HandlerBoobyTrap>              boobyTrapHandler() {
        return m_handlerBoobyTrap;
    }
    std::shared_ptr<HandlerMineArea>               mineAreaHandler() {
        return m_handlerMineArea;
    }
    std::shared_ptr<HandlerMineCorridor>           mineCorridorHandler() {
        return m_handlerMineCorridor;
    }
    std::shared_ptr<HandlerExplosionArea>          explosionAreaHandler() {
        return m_handlerExplosionArea;
    }
    std::shared_ptr<HandlerExplosionCluster>       explosionClusterHandler() {
        return m_handlerExplosionCluster;
    }
    std::shared_ptr<HandlerExplosionSingle>        explosionSingleHandler() {
        return m_handlerExplosionSingle;
    }
    std::shared_ptr<HandlerReconArea>              reconAreaHandler() {
        return m_handlerReconArea;
    }
    std::shared_ptr<HandlerDangerArea>             dangerAreaHandler() {
        return m_handlerDangerArea;
    }
    std::shared_ptr<HandlerChargeEffect>           chargeEffectHandler() {
        return m_handlerChargeEffect;
    }
    std::shared_ptr<HandlerTrajectory>             trajectoryHandler() {
        return m_handlerTrajectory;
    }
    std::shared_ptr<HandlerEffector>               effectorHandler() {
        return m_handlerEffector;
    }
    std::shared_ptr<HandlerEffectCluster>           effectClusterHandler() {
        return m_handlerEffectCluster;
    }

    // some helper:
    ProjectDataManagement::GearClass gearClassOfChargeTypeId(int chargeTypeId) const;


private:
    bool initAESHandler();
private:
    std::shared_ptr<HandlerAirSupportImpact>       m_handlerAirSupportImpact;
    std::shared_ptr<HandlerExplosionSingle>        m_handlerExplosionSingle;
    std::shared_ptr<HandlerExplosionArea>          m_handlerExplosionArea;
    std::shared_ptr<HandlerExplosionCluster>       m_handlerExplosionCluster;
    std::shared_ptr<HandlerEffectCluster>          m_handlerEffectCluster;
    std::shared_ptr<HandlerFunctionalArea>         m_handlerFunctionalArea;
    std::shared_ptr<HandlerTechnicalArea>          m_handlerTechnicalArea;
    std::shared_ptr<HandlerNContamination>         m_handlerNContamination;
    std::shared_ptr<HandlerBCContamination>        m_handlerBCContamination;
    std::shared_ptr<HandlerBoobyTrap>              m_handlerBoobyTrap;
    std::shared_ptr<HandlerOffRouteMine>           m_handlerOffRouteMine;
    std::shared_ptr<HandlerMineArea>               m_handlerMineArea;
    std::shared_ptr<HandlerMineCorridor>           m_handlerMineCorridor;
    std::shared_ptr<HandlerDangerArea>             m_handlerDangerArea;
    std::shared_ptr<HandlerChargeAdministration>   m_handlerChargeAdmin;
    std::shared_ptr<HandlerReconArea>              m_handlerReconArea;
    std::shared_ptr<HandlerBorderline>             m_handlerBorderline;
    std::shared_ptr<HandlerGasPipe>                m_handlerGasPipe;
    std::shared_ptr<HandlerDusSingleMine>          m_handlerDusSingleMine;
    std::shared_ptr<HandlerChargeEffect>           m_handlerChargeEffect;
    std::shared_ptr<HandlerTrajectory>             m_handlerTrajectory;
    std::shared_ptr<HandlerEffector>               m_handlerEffector;
    std::shared_ptr<DdsHandler>                    m_ddsHandler;
    std::shared_ptr<DbHandler>                     m_dbHandler;
    std::shared_ptr<DbHandler>                     m_dbHandlerEx0;
    std::shared_ptr<MeteoDataProvider>             m_meteoData;
    std::shared_ptr<SpecialAreaProvider>           m_specialAreaProvider;

    LOGGER_T m_logger;
};
} // namespace AreaEffectSimulation