WimaPlaner.h

#pragma once

#include <QObject>
#include "QGCMapPolygon.h"
#include "QmlObjectListModel.h"

#include "Geometry/WimaArea.h"
#include "Geometry/WimaAreaData.h"
#include "Geometry/WimaServiceArea.h"
#include "Geometry/WimaServiceAreaData.h"
#include "Geometry/WimaMeasurementArea.h"
#include "Geometry/WimaMeasurementAreaData.h"
#include "Geometry/WimaCorridor.h"
#include "Geometry/WimaCorridorData.h"
#include "Geometry/WimaJoinedArea.h"
#include "Geometry/WimaJoinedAreaData.h"
#include "WimaPlanData.h"
#include "WimaBridge.h"

#include "PlanMasterController.h"
#include "MissionController.h"
#include "SurveyComplexItem.h"
#include "SimpleMissionItem.h"
#include "MissionSettingsItem.h"
#include "JsonHelper.h"
#include "QGCApplication.h"

#include "OptimisationTools.h"
#include "Geometry/PlanimetryCalculus.h"
#include "Geometry/GeoUtilities.h"

#include "QSignalBlocker"

#define TEST_FUN 0

#if TEST_FUN
    #include "TestPolygonCalculus.h"
    #include "testplanimetrycalculus.h"
#endif

class WimaPlaner : public QObject
{
    Q_OBJECT

    enum FileType {WimaFile, PlanFile};

public:
    WimaPlaner(QObject *parent = nullptr);
    template<class T>
    WimaPlaner(T t, QObject *parent = nullptr) = delete;
    template<class T>
    WimaPlaner(T t) = delete;

    Q_PROPERTY(PlanMasterController*    masterController    READ masterController       WRITE setMasterController       NOTIFY masterControllerChanged)
    Q_PROPERTY(MissionController*       missionController   READ missionController      WRITE setMissionController      NOTIFY missionControllerChanged)
    Q_PROPERTY(QmlObjectListModel*      visualItems         READ visualItems                                            NOTIFY visualItemsChanged)
    Q_PROPERTY(int                      currentPolygonIndex READ currentPolygonIndex    WRITE setCurrentPolygonIndex    NOTIFY currentPolygonIndexChanged)
    Q_PROPERTY(QString                  currentFile         READ currentFile                                            NOTIFY currentFileChanged)
    Q_PROPERTY(QStringList              loadNameFilters     READ loadNameFilters                                        CONSTANT)
    Q_PROPERTY(QStringList              saveNameFilters     READ saveNameFilters                                        CONSTANT)
    Q_PROPERTY(QString                  fileExtension       READ fileExtension                                          CONSTANT)
    Q_PROPERTY(QGeoCoordinate           joinedAreaCenter    READ joinedAreaCenter                                       CONSTANT)
    Q_PROPERTY(WimaBridge*              wimaBridge          READ wimaBridge              WRITE setWimaBridge            NOTIFY wimaBridgeChanged)
    Q_PROPERTY(bool                     syncronized         READ syncronizedWithController                              NOTIFY syncronizedWithControllerChanged)
    Q_PROPERTY(bool                     readyForSync        READ readyForSync                                           NOTIFY readyForSyncChanged)

    // Property accessors
    PlanMasterController*       masterController       (void)          { return _masterController; }
    MissionController*          missionController      (void)          { return _missionController; }
    QmlObjectListModel*         visualItems            (void) ;
    int                         currentPolygonIndex    (void) const    { return _currentAreaIndex; }
    QString                     currentFile            (void) const    { return _currentFile; }
    QStringList                 loadNameFilters        (void) const;
    QStringList                 saveNameFilters        (void) const;
    QString                     fileExtension          (void) const    { return wimaFileExtension; }
    QGeoCoordinate              joinedAreaCenter       (void) const;
    WimaBridge*                 wimaBridge             (void)          { return _wimaBridge;}

    // Property setters
    void setMasterController        (PlanMasterController* masterController);
    void setMissionController       (MissionController* missionController);
    /// Sets the integer index pointing to the current polygon. Current polygon is set interactive.
    void setCurrentPolygonIndex     (int index);
    void setWimaBridge           (WimaBridge* bridge);

    // Property acessors
    bool syncronizedWithController  ();
    bool readyForSync               ();

    // Member Methodes
    Q_INVOKABLE WimaPlaner *thisPointer();
    Q_INVOKABLE bool addMeasurementArea();
    /// Removes an area from _visualItems
    /// @param index Index of the area to be removed
    Q_INVOKABLE void removeArea(int index);
    Q_INVOKABLE bool addServiceArea();
    Q_INVOKABLE bool addCorridor();
    /// Remove all areas from WimaPlaner and all mission items from MissionController
    Q_INVOKABLE void removeAll();
    /// Recalculates vehicle corridor, flight path, etc.
    Q_INVOKABLE bool updateMission();
    /// Pushes the generated mission data to the wimaController.
    Q_INVOKABLE void pushToWimaController();

    Q_INVOKABLE void saveToCurrent();
    Q_INVOKABLE void saveToFile(const QString& filename);
    Q_INVOKABLE bool loadFromCurrent();
    Q_INVOKABLE bool loadFromFile(const QString& filename);

    Q_INVOKABLE void resetAllInteractive(void);
    Q_INVOKABLE void setInteractive(void);

    QJsonDocument saveToJson(FileType fileType);

    bool calcShortestPath(const QGeoCoordinate &start, const QGeoCoordinate &destination, QVector<QGeoCoordinate> &path);

    // static Members
    static const char* wimaFileExtension;
    static const char* areaItemsName;
    static const char* missionItemsName;

signals:
    void masterControllerChanged            (void);
    void missionControllerChanged           (void);
    void visualItemsChanged                 (void);
    void currentPolygonIndexChanged         (int index);
    void currentFileChanged                 ();
    void wimaBridgeChanged               ();
    void syncronizedWithControllerChanged   (void);
    void readyForSyncChanged                (void);

private slots:
    void recalcPolygonInteractivity         (int index);
    bool calcArrivalAndReturnPath           (void);
    bool recalcJoinedArea                   ();
    // called by _updateTimer::timeout signal, updates different mission parts, if parameters (e.g. survey or areas) have changed
    void updateTimerSlot                    ();
    void setSyncronizedWithControllerFalse  (void);
#ifndef NDEBUG
    void autoLoadMission                    (void);
#endif
    void startCalcArrivalAndReturnTimer     (void);
private:
signals:
    void joinedAreaValidChanged();
private:
    // Member Functions
    WimaPlanData toPlanData();
    void         setSyncronizedWithController   (bool sync);
    void         setReadyForSync                (bool ready);
    void         setJoinedAreaValid             (bool valid);

    // Member Variables
    PlanMasterController   *_masterController;
    MissionController      *_missionController;
    int                     _currentAreaIndex;
    QString                 _currentFile; // file for saveing
    WimaBridge             *_wimaBridge; // container for data exchange with WimaController
    QmlObjectListModel      _visualItems; // contains all visible areas
    WimaJoinedArea          _joinedArea; // joined area fromed by _measurementArea, _serviceArea, _corridor
    bool                    _joinedAreaValid;
    WimaMeasurementArea     _measurementArea; // measurement area
    WimaServiceArea         _serviceArea; // area for supplying
    WimaCorridor            _corridor; // corridor connecting _measurementArea and _serviceArea
    int                     _arrivalPathLength; // the number waypoints the arrival path consists of (path from takeoff to first measurement point)
    int                     _returnPathLength; // the number waypoints the return path consists of (path from last measurement point to land)

    CircularSurveyComplexItem* _circularSurvey; // pointer to the CircularSurvey item in _missionController.visualItems()

    // auto update
    QTimer                  _updateTimer; // on this timers timeout different mission parts will be updated, if parameters (e.g. survey or areas) have changed
    QGeoCoordinate          _lastSurveyRefPoint; // stores the SurveyRefPoint of the previous timer call
    bool                    _surveyRefChanging; // true if SurveyRefPoint is changing
    QVariantList            _lastMeasurementAreaPath; // stores the path of _measurementArea, at the time instance of the previous timer call
    bool                    _measurementAreaChanging; // true if the path of the _measurementArea is changing
    QVariantList            _lastCorridorPath; // stores the path of _corridor, at the time instance of the previous timer call
    bool                    _corridorChanging; // true if the path of the _corridor is changing
    QVariantList            _lastServiceAreaPath; // stores the path of _serviceArea, at the time instance of the previous timer call
    bool                    _serviceAreaChanging; // true if the path of the _serviceArea is changing

    // sync stuff
    bool                    _syncronizedWithController; // true if planData is syncronized with wimaController
    bool                    _readyForSync; // gets set by updateMission and calcArrivalAndReturnPath

#ifndef NDEBUG
    QTimer                  _autoLoadTimer; // timer to auto load mission after some time, prevents seg. faults
#endif
    QTimer                  _calcArrivalAndReturnPathTimer;
};