#include "onf_stepcomputeglobalextent.h"

#include <Eigen/Core>

ONF_StepComputeGlobalExtent::ONF_StepComputeGlobalExtent() : SuperClass()
{
}

ONF_StepComputeGlobalExtent::~ONF_StepComputeGlobalExtent()
{
}

QString ONF_StepComputeGlobalExtent::description() const
{
    return tr("Calcul de l'emprise globale");
}

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

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

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

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

CT_VirtualAbstractStep* ONF_StepComputeGlobalExtent::createNewInstance() const
{
    // cree une copie de cette etape
    return new ONF_StepComputeGlobalExtent();
}

//////////////////// PROTECTED //////////////////

void ONF_StepComputeGlobalExtent::declareInputModels(CT_StepInModelStructureManager& manager)
{   
    manager.addResult(_inResult, tr("Emprises"), "", true);
    manager.setZeroOrMoreRootGroup(_inResult, _inZeroOrMoreRootGroup);
    manager.addGroup(_inZeroOrMoreRootGroup, _inGroup);
    manager.addItem(_inGroup, _inItem, tr("Emprises d'entrée"));
}

// Redefine in children steps to complete out Models
void ONF_StepComputeGlobalExtent::declareOutputModels(CT_StepOutModelStructureManager& manager)
{
    manager.addResultCopy(_inResult);

    manager.addResult(_outResult, tr("Emprise globale"));
    manager.setRootGroup(_outResult, _outGroup, tr("Groupe"));
    manager.addItem(_outGroup, _outTile, tr("Emprise globale"));
}

// Redefine in children steps to complete compute method
void ONF_StepComputeGlobalExtent::compute()
{
    Eigen::Vector2d min, max;
    min(0) = std::numeric_limits<double>::max();
    max(0) = -std::numeric_limits<double>::max();
    min(1) = std::numeric_limits<double>::max();
    max(1) = -std::numeric_limits<double>::max();

    for (CT_StandardItemGroup* group : _inGroup.iterateOutputs(_inResult))
    {
        if (isStopped()) {return;}

        const CT_AbstractGeometricalItem* item = group->singularItem(_inItem);

        if (item != nullptr)
        {
            Eigen::Vector3d minI, maxI;
            item->boundingBox(minI, maxI);

            if (minI(0) < min(0)) {min(0) = minI(0);}
            if (minI(1) < min(1)) {min(1) = minI(1);}

            if (maxI(0) > max(0)) {max(0) = maxI(0);}
            if (maxI(1) > max(1)) {max(1) = maxI(1);}
        }
    }


    for (CT_ResultGroup* outRes : _outResult.iterateOutputs())
    {

        CT_StandardItemGroup* group = new CT_StandardItemGroup();
        outRes->addRootGroup(_outGroup, group);

        CT_Box2DData* boxData = new CT_Box2DData(min, max);
        CT_Box2D* box2D = new CT_Box2D( boxData);

        group->addSingularItem(_outTile, box2D);
    }

    setProgress( 100 );
}