/****************************************************************************
 Copyright (C) 2010-2012 the Office National des Forêts (ONF), France
                         All rights reserved.

 Contact : alexandre.piboule@onf.fr

 Developers : Alexandre PIBOULE (ONF)

 This file is part of PluginONF library.

 PluginONF is free library: you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 PluginONF is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with PluginONF.  If not, see <http://www.gnu.org/licenses/lgpl.html>.
*****************************************************************************/

#include "onf_stepmergescenesbymodality.h"

#include "documentinterface.h"
#include "interfacesforplugin.h"

#include <QtConcurrent/QtConcurrentMap>

#include <QMessageBox>

ONF_StepMergeScenesByModality::ONF_StepMergeScenesByModality() : SuperClass()
{
    _modalitiesString = "Data,Intermediate,Noise";

    setManual(true);
    m_doc = nullptr;

    _dataContainer = new ONF_ActionAggregateItems_dataContainer();
}

ONF_StepMergeScenesByModality::~ONF_StepMergeScenesByModality()
{
    qDeleteAll(_outScene);
    _outScene.resize(0);

    delete _dataContainer;
}

QString ONF_StepMergeScenesByModality::description() const
{
    return tr("Merge scenes interactively");
}

QString ONF_StepMergeScenesByModality::detailledDescription() const
{
    return tr("");
}

QString ONF_StepMergeScenesByModality::inputDescription() const
{
    return SuperClass::inputDescription() + tr("<br><br>");
}

QString ONF_StepMergeScenesByModality::outputDescription() const
{
    return SuperClass::outputDescription() + tr("<br><br>");
}

QString ONF_StepMergeScenesByModality::detailsDescription() const
{
    return tr("");
}

QString ONF_StepMergeScenesByModality::URL() const
{
    //return tr("STEP URL HERE");
    return SuperClass::URL(); //by default URL of the plugin
}

CT_VirtualAbstractStep* ONF_StepMergeScenesByModality::createNewInstance() const
{
    return new ONF_StepMergeScenesByModality();
}

//////////////////// PROTECTED METHODS //////////////////

void ONF_StepMergeScenesByModality::declareInputModels(CT_StepInModelStructureManager& manager)
{
    manager.addResult(_inResult, tr("Scene(s)"), tr(""), true);
    manager.setZeroOrMoreRootGroup(_inResult, _inZeroOrMoreRootGroup);
    manager.addGroup(_inZeroOrMoreRootGroup, _inRootGroup);
    manager.addGroup(_inRootGroup, _inGroup);
    manager.addItem(_inGroup, _inScene, tr("Scene(s)"));
}

void ONF_StepMergeScenesByModality::declareOutputModels(CT_StepOutModelStructureManager& manager)
{
    _dataContainer->_modalities = _modalitiesString.split(",", Qt::SkipEmptyParts);

    manager.addResultCopy(_inResult);

    qDeleteAll(_outScene);
    _outScene.resize(_dataContainer->_modalities.size());

    for (int i = 0 ; i < _dataContainer->_modalities.size() ; i++)
    {
        _outScene[i] = new CT_HandleOutSingularItem<CT_Scene>();
        manager.addItem(_inGroup, *_outScene[i], _dataContainer->_modalities.at(i));
    }
}

void ONF_StepMergeScenesByModality::fillPreInputConfigurationDialog(CT_StepConfigurableDialog* preInputConfigDialog)
{
    preInputConfigDialog->addString(tr("Modalities (comma separated)"), "", _modalitiesString, tr("List all wanted modalities, separated by commas)"));
}

void ONF_StepMergeScenesByModality::compute()
{    

    for (CT_StandardItemGroup* rootGroup : _inRootGroup.iterateOutputs(_inResult))
    {
        _dataContainer->_items.clear();
        _dataContainer->_itemsModalities.clear();

        for (const CT_StandardItemGroup* group : rootGroup->groups(_inGroup))
        {

            for (const CT_AbstractItemDrawableWithPointCloud* sceneIn : group->singularItems(_inScene))
            {

                _dataContainer->_items.append(const_cast<CT_AbstractItemDrawableWithPointCloud*>(sceneIn));
            }
        }

        qDebug() << "aa="<< _dataContainer->_items.size();

        // Début de la partie interactive
        m_doc = nullptr;
        requestManualMode();
        // Fin de la partie interactive

        for (int i = 0 ; i < _dataContainer->_modalities.size() ; i++)
        {
            CT_PointCloudIndexVector *outCloudIndex = new CT_PointCloudIndexVector();
            outCloudIndex->setSortType(CT_PointCloudIndexVector::NotSorted);

            for (int j = 0 ; j < _dataContainer->_items.size() ; j++)
            {
                if (_dataContainer->_itemsModalities.size() > j && _dataContainer->_itemsModalities.at(j) == _dataContainer->_modalities.at(i))
                {
                    CT_AbstractItemDrawableWithPointCloud* sceneIn  = static_cast<CT_AbstractItemDrawableWithPointCloud*>(_dataContainer->_items.at(j));
                    const CT_AbstractPointCloudIndex *pointCloudIndex = sceneIn->pointCloudIndex();

                    CT_PointIterator itP(pointCloudIndex);
                    while(itP.hasNext())
                    {
                        size_t index = itP.next().currentGlobalIndex();
                        outCloudIndex->addIndex(index);
                    }
                }
            }

            if (outCloudIndex->size() > 0)
            {
                outCloudIndex->setSortType(CT_PointCloudIndexVector::SortedInAscendingOrder);
                CT_Scene* scene = new CT_Scene(PS_REPOSITORY->registerPointCloudIndex(outCloudIndex));
                scene->updateBoundingBox();
                rootGroup->addSingularItem(*_outScene[i], scene);
            } else {
                delete outCloudIndex;
            }
        }
    }

    setProgress(100);
    m_doc = nullptr;
}

void ONF_StepMergeScenesByModality::initManualMode()
{

    if(m_doc == nullptr)
    {
        ONF_ActionAggregateItems* action = new ONF_ActionAggregateItems(_dataContainer);

        GuiContextInterface* context = this->guiContext();
        context->actionsManager()->addAction(action);
         m_doc = context->documentManager()->new3DDocument();
         m_doc->setCurrentAction(action);
    } else {
        m_doc->removeAllItemDrawable();
    }

    QMessageBox::information(nullptr, tr("Mode manuel"), tr("Bienvenue dans le mode manuel de cette "
                                                         "étape de filtrage."), QMessageBox::Ok);
}

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