// Inclusion du fichier d'entête
#include "tufr_steptutorial04.h"

// Inclure ensuite les éventuelles classes de définitions nécessaires à votre étape

// Inclusion pour la gestion des actions en cours d'étape
#include "interfacesforplugin.h"
#include <QMessageBox>

// Pour afficher des messages à la console
#include <QDebug>

// Pour inclure certaines fonctions mathématiques
#include <math.h>

// Constructeur : appel du constructeur de la classe mère
// et initialisation des paramètres (valeurs par défaut)
TUFR_StepTutorial04::TUFR_StepTutorial04() : SuperClass()
{
    _dataContainer = new TUFR_ActionStepTutorial04::TUFR_ActionStepTutorial04_dataContainer();
    _dataContainer->_limitBuffer = 0.0;
    _dataContainer->_sceneList = new QList<CT_PointCluster*>();

    _manual = false;
    _m_doc = nullptr;
}

// Destructeur
TUFR_StepTutorial04::~TUFR_StepTutorial04()
{
    _dataContainer->_sceneList->clear();
    delete _dataContainer;
}

// Description de l'étape (tooltip du menu contextuel)
QString TUFR_StepTutorial04::description() const
{
    return QString(tr("Générer des ReferencePoints"));
}

// Description détaillée de l'étape (dans le menu de description)
QString TUFR_StepTutorial04::detailledDescription() const
{
    return QString(tr("Générer des ReferencePoints à partir des barycentres de PointClusters"));
}

// Méthode de recopie de l'étape
CT_VirtualAbstractStep* TUFR_StepTutorial04::createNewInstance() const
{
    // cree une copie de cette étape
    return new TUFR_StepTutorial04();
}

// Création et affiliation des modèles IN
void TUFR_StepTutorial04::declareInputModels(CT_StepInModelStructureManager& manager)
{
    // On se base sur les résultats entrants
    manager.addResult(_inResult, tr("Scène(s)"));
    // Déclaration et création du modèle de groupe de référence
    manager.setZeroOrMoreRootGroup(_inResult, _inZeroOrMoreRootGroup);
    // Déclaration et création du modèle de groupe
    manager.addGroup(_inZeroOrMoreRootGroup, _inGroup);
    // On ajoute le modèle d'item au modèle du groupe racine (le type d'item sera automatiquement déduit)
    manager.addItem(_inGroup, _inScene, tr("Scène source"));
}

// Création et affiliation des modèles OUT
void TUFR_StepTutorial04::declareOutputModels(CT_StepOutModelStructureManager& manager)
{
    // On se base sur les résultats entrants (copie)
    manager.addResultCopy(_inResult);
    // Déclaration et création du modèle de groupe
    manager.addGroup(_inGroup, _outGroup);
    // On ajoute le modèle d'item au modèle du groupe racine (le type d'item sera automatiquement déduit)
    manager.addItem(_outGroup, _outPoint, tr("Barycentre"));
}

// Création semi-automatique de la boite de dialogue de paramétrage de l'étape
void TUFR_StepTutorial04::fillPostInputConfigurationDialog(CT_StepConfigurableDialog* postInputConfigDialog)
{
	// Ajout de contrôles unitaires de paramètrages à la boite (un par paramètre en général)
    postInputConfigDialog->addBool("","",tr("Choix interactif des paramètres"), _manual);
}

// Etape de calcul, créant les données des résultats de sortie
void TUFR_StepTutorial04::compute()
{
    // On prépare le mode manuel pour l'action
    setManual(_manual);

    // Ici on peut faire quelques initialisations et/ou calculs préliminaires
	
	// On Recopie ici le(s) cluster(s) de point dans la vue d'action, afin d'éventuellement
	// intéragir avec (sélection, visualisation d'effet de paramètre, ...)
    for (CT_PointCluster* inScene : _inScene.iterateOutputs(_inResult))
    {
        _dataContainer->_sceneList->append(inScene);
    }

    // On fat appel a l'action
    requestManualMode();

    // On peut maintenant utiliser les variables mises à jour avec l'action dans la suite du calcul, puis on continue le calcul

    // Récupération de la liste des groupes d'entrée et leurs items
    // L'ordre dans cette liste est celui des ajouts successifs
    for (CT_StandardItemGroup* group : _inGroup.iterateOutputs(_inResult))
    {
        for (const CT_PointCluster* inScene : group->singularItems(_inScene))
        {
            if (isStopped())
                return;

            // Ici on peut faire d'autre calculs préliminaires pour l'item en cours

            // On récupère le barycentre auto-calculé du groupe de points
            const CT_PointClusterBarycenter barycentre = inScene->getBarycenter();

            // Coordonnées du barycentre
            float xref = barycentre.x();
            float yref = barycentre.y();
            float zref = barycentre.z();

            // Calcul du bufferXY : maximum de la distance point/refPoint(barycentre) pour chaque segment
            float buffer = 0.0;

            if (_dataContainer->_limitBuffer != 0.0)
            {
                buffer = _dataContainer->_limitBuffer;
            }
            else
            {
                const CT_AbstractPointCloudIndex *pointCloudIndex = inScene->pointCloudIndex();
                CT_PointIterator itP(pointCloudIndex);

                size_t nbPoints = pointCloudIndex->size();
                size_t i = 0;

                while(itP.hasNext())
                {
                    if (isStopped())
                        return;

                    const CT_Point &point = itP.next().currentPoint();

                    float distance = pow(xref-point.x(), 2) + pow(yref-point.y(), 2);

                    if (distance > buffer)
                        buffer = distance;

                    // On fait avancer le % de progression (ici par rapport au nombre de points traités sur le total)
                    setProgress(float(100.0*i++ /nbPoints));
                }

                if (buffer > 0) {buffer = sqrt(buffer);}
            }

            // On fait avancer le % de progression : calcul terminé
            setProgress(float(100.0));
			
			// Création du barycentre du cluster en cours
			CT_ReferencePoint *refPoint = new CT_ReferencePoint(xref, yref, zref, buffer);

            // Création du groupe contenant le(s) item(s)
			CT_StandardItemGroup* outGroup = new CT_StandardItemGroup();
			
            // Ajout du groupe au résultat (AVANT d'ajouter l'item !)
			group->addGroup(_outGroup, outGroup);

            // Ajout de l'item au groupe
            outGroup->addSingularItem(_outPoint, refPoint);
        }
    }

    if (_manual)
    {
        _m_doc = nullptr;
    }
}

void TUFR_StepTutorial04::initManualMode()
{
    if(_m_doc == nullptr)
    {
        // Création d'une nouvelle action
        TUFR_ActionStepTutorial04* action = new TUFR_ActionStepTutorial04(_dataContainer);

        GuiContextInterface* context = this->guiContext();
        context->actionsManager()->addAction(action);

        _m_doc = context->documentManager()->new3DDocument();
        _m_doc->setCurrentAction(action);
    }

    QMessageBox::information(nullptr,
                             tr("Mode manuel"),
                             tr("Bienvenue dans le mode manuel de cette étape.\n"
                                "Veuillez sélectionner les paramètres pour réaliser les tranches."),
                             QMessageBox::Ok);
}

void TUFR_StepTutorial04::useManualMode(bool quit)
{
    Q_UNUSED(quit);
}