#include "onf_stepcreaterastermosaic.h"

ONF_StepCreateRasterMosaic::ONF_StepCreateRasterMosaic() : SuperClass()
{
    _name = tr("Raster");
    _rasterType = "none";
}

ONF_StepCreateRasterMosaic::~ONF_StepCreateRasterMosaic()
{
}

QString ONF_StepCreateRasterMosaic::description() const
{
    return tr("Redallage raster");
}

QString ONF_StepCreateRasterMosaic::detailledDescription() const
{
    return tr("Créer des rasters sur les emprises fournies, à partir des rasters d'entrée. Conserve la résolution des rasters d'entrée. ");
}

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

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

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

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

//////////////////// PROTECTED //////////////////
/// \brief ONF_StepCreateRasterMosaic::fillPreInputConfigurationDialog
/// \param preInputConfigDialog
///
void ONF_StepCreateRasterMosaic::fillPreInputConfigurationDialog(CT_StepConfigurableDialog* preInputConfigDialog)
{
    QStringList types;
    types.append("float");
    types.append("double");
    types.append("quint8");
    types.append("qint32");

    if (_rasterType == "none") {_rasterType = "float";}

    preInputConfigDialog->addStringChoice(tr("Type de raster"), "", types, _rasterType);
}


void ONF_StepCreateRasterMosaic::declareInputModels(CT_StepInModelStructureManager& manager)
{
    manager.addResult(_inResult, tr("Emprises cibles"), "", true);
    manager.setZeroOrMoreRootGroup(_inResult, _inZeroOrMoreRootGroup);
    manager.addGroup(_inZeroOrMoreRootGroup, _inGroup);
    manager.addItem(_inGroup, _inItemArea, tr("Emprise cible"));

    manager.addResult(_inResultRaster, tr("Rasters d'entrée"), "", true);
    manager.setZeroOrMoreRootGroup(_inResultRaster, _inZeroOrMoreRootGroupRaster);
    manager.addGroup(_inZeroOrMoreRootGroupRaster, _inGroupRaster);

    if (_rasterType == "none")
    {
        manager.addItem(_inGroupRaster, _inRasterAbstract, tr("Rasters d'entrée"));
    } else if (_rasterType == "float")
    {
        manager.addItem(_inGroupRaster, _inRasterFloat, tr("Rasters d'entrée"));
    } else if (_rasterType == "double")
    {
        manager.addItem(_inGroupRaster, _inRasterDouble, tr("Rasters d'entrée"));
    } else if (_rasterType == "quint8")
    {
        manager.addItem(_inGroupRaster, _inRasterQuint8, tr("Rasters d'entrée"));
    } else if (_rasterType == "qint32")
    {
        manager.addItem(_inGroupRaster, _inRasterQint32, tr("Rasters d'entrée"));
    }
}


void ONF_StepCreateRasterMosaic::fillPostInputConfigurationDialog(CT_StepConfigurableDialog* postInputConfigDialog)
{
    if (_rasterType == "float" && _inRasterFloat.hasAtLeastOnePossibilitySelected(_inResultRaster))
    {
        _name = tr("%1 (redallé)").arg(_inRasterFloat.outModelSelected(_inResultRaster)->displayableName());
    }
    else if (_rasterType == "double" && _inRasterDouble.hasAtLeastOnePossibilitySelected(_inResultRaster))
    {
        _name = tr("%1 (redallé)").arg(_inRasterDouble.outModelSelected(_inResultRaster)->displayableName());
    }
    else if (_rasterType == "quint8" && _inRasterQuint8.hasAtLeastOnePossibilitySelected(_inResultRaster))
    {
        _name = tr("%1 (redallé)").arg(_inRasterQuint8.outModelSelected(_inResultRaster)->displayableName());
    }
    else if (_rasterType == "qint32" && _inRasterQint32.hasAtLeastOnePossibilitySelected(_inResultRaster))
    {
        _name = tr("%1 (redallé)").arg(_inRasterQint32.outModelSelected(_inResultRaster)->displayableName());
    }

    postInputConfigDialog->addString(tr("Nom à donner au raster"), "", _name, tr("<strong>Attention</strong> : ce paramètre ne peut être pris en compte qu'à l'ajout de l'étape ou au chargement d'un script.<br>Une modification de ce paramètre lors d'une reconfiguration des paramètres se répercutera dans les scripts exportés ultérieurement, <strong>mais pas dans la session en cours</strong>. "));
}


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

    if (_rasterType == "float")
    {
        manager.addItem(_inGroup, _outRasterFloat, _name);

    } else if (_rasterType == "double")
    {
        manager.addItem(_inGroup, _outRasterDouble, _name);

    } else if (_rasterType == "quint8")
    {
        manager.addItem(_inGroup, _outRasterQuint8, _name);

    } else if (_rasterType == "qint32")
    {
        manager.addItem(_inGroup, _outRasterQint32, _name);

    }
}


// Redefine in children steps to complete compute method
void ONF_StepCreateRasterMosaic::compute()
{
    bool rasternullptr = true;
    _min(0) = std::numeric_limits<double>::max();
    _min(1) = std::numeric_limits<double>::max();


    if (_rasterType == "float")
    {
        for (const CT_AbstractImage2D* rasterIn : _inRasterFloat.iterateInputs(_inResultRaster))
        {
            rasternullptr = false;

            Eigen::Vector2d minTmp;
            rasterIn->getMinCoordinates(minTmp);

            if (minTmp(0) < _min(0)) {_min(0) = minTmp(0);}
            if (minTmp(1) < _min(1)) {_min(1) = minTmp(1);}
            _resolution = rasterIn->resolution();
        }
    } else if (_rasterType == "double")
    {
        for (const CT_AbstractImage2D* rasterIn : _inRasterDouble.iterateInputs(_inResultRaster))
        {
            rasternullptr = false;

            Eigen::Vector2d minTmp;
            rasterIn->getMinCoordinates(minTmp);

            if (minTmp(0) < _min(0)) {_min(0) = minTmp(0);}
            if (minTmp(1) < _min(1)) {_min(1) = minTmp(1);}
            _resolution = rasterIn->resolution();
        }
    } else if (_rasterType == "quint8")
    {
        for (const CT_AbstractImage2D* rasterIn : _inRasterQuint8.iterateInputs(_inResultRaster))
        {
            rasternullptr = false;

            Eigen::Vector2d minTmp;
            rasterIn->getMinCoordinates(minTmp);

            if (minTmp(0) < _min(0)) {_min(0) = minTmp(0);}
            if (minTmp(1) < _min(1)) {_min(1) = minTmp(1);}
            _resolution = rasterIn->resolution();
        }
    } else if (_rasterType == "qint32")
    {
        for (const CT_AbstractImage2D* rasterIn : _inRasterQint32.iterateInputs(_inResultRaster))
        {
            rasternullptr = false;

            Eigen::Vector2d minTmp;
            rasterIn->getMinCoordinates(minTmp);

            if (minTmp(0) < _min(0)) {_min(0) = minTmp(0);}
            if (minTmp(1) < _min(1)) {_min(1) = minTmp(1);}
            _resolution = rasterIn->resolution();
        }
    }


    if (rasternullptr) {return;}

    for (CT_StandardItemGroup* group : _inGroup.iterateOutputs(_inResult))
    {
        for (const CT_AbstractSingularItemDrawable* areaIn : group->singularItems(_inItemArea))
        {
            if (isStopped()) {return;}

            Eigen::Vector3d minArea, maxArea;
            double minRasterX, minRasterY, maxRasterX, maxRasterY;

            int dimx = 0;
            int dimy = 0;

            areaIn->boundingBox(minArea, maxArea);

            minRasterX = _min(0);
            minRasterY = _min(1);

            while (minRasterX < minArea(0)) {minRasterX += _resolution;}
            while (minRasterY < minArea(1)) {minRasterY += _resolution;}

            maxRasterX = minRasterX;
            maxRasterY = minRasterY;

            while (maxRasterX < maxArea(0)) {maxRasterX += _resolution;++dimx;}
            while (maxRasterY < maxArea(1)) {maxRasterY += _resolution;++dimy;}

            double refLevel = 0.0;

            if (_rasterType == "float")
            {
                float naVal = -std::numeric_limits<float>::max();
                CT_Image2D<float>* rasterOut = new CT_Image2D<float>(minRasterX, minRasterY, dimx, dimy, _resolution, refLevel, naVal, naVal);

                for (const CT_Image2D<float>* rasterIn : _inRasterFloat.iterateInputs(_inResultRaster))
                {
                    for (int xx = 0 ; xx < dimx ; xx++)
                    {
                        for (int yy = 0 ; yy < dimy ; yy++)
                        {
                            Eigen::Vector3d center = Eigen::Vector3d(0.0, 0.0, 0.0);
                            size_t index;
                            rasterOut->getCellCenterCoordinates(xx, yy, center);

                            if (rasterIn->indexAtCoords(center(0), center(1), index))
                            {
                                float val = rasterIn->valueAtIndex(index);
                                if (val != rasterIn->NA())
                                {
                                    rasterOut->setValue(xx, yy, val);
                                }
                            }
                        }
                    }
                }

                rasterOut->computeMinMax();
                group->addSingularItem(_outRasterFloat, rasterOut);

            } else if (_rasterType == "double")
            {
                double naVal = -std::numeric_limits<double>::max();
                CT_Image2D<double>* rasterOut = new CT_Image2D<double>(minRasterX, minRasterY, dimx, dimy, _resolution, refLevel, naVal, naVal);

                for (const CT_Image2D<double>* rasterIn : _inRasterDouble.iterateInputs(_inResultRaster))
                {
                    for (int xx = 0 ; xx < dimx ; xx++)
                    {
                        for (int yy = 0 ; yy < dimy ; yy++)
                        {
                            Eigen::Vector3d center = Eigen::Vector3d(0.0, 0.0, 0.0);
                            size_t index;
                            rasterOut->getCellCenterCoordinates(xx, yy, center);

                            if (rasterIn->indexAtCoords(center(0), center(1), index))
                            {
                                double val = rasterIn->valueAtIndex(index);
                                if (val != rasterIn->NA())
                                {
                                    rasterOut->setValue(xx, yy, val);
                                }
                            }
                        }
                    }
                }

                rasterOut->computeMinMax();
                group->addSingularItem(_outRasterDouble, rasterOut);

            } else if (_rasterType == "quint8")
            {
                quint8 naVal = std::numeric_limits<quint8>::max();
                CT_Image2D<quint8>* rasterOut = new CT_Image2D<quint8>(minRasterX, minRasterY, dimx, dimy, _resolution, refLevel, naVal, naVal);

                for (const CT_Image2D<quint8>* rasterIn : _inRasterQuint8.iterateInputs(_inResultRaster))
                {
                    for (int xx = 0 ; xx < dimx ; xx++)
                    {
                        for (int yy = 0 ; yy < dimy ; yy++)
                        {
                            Eigen::Vector3d center = Eigen::Vector3d(0.0, 0.0, 0.0);
                            size_t index;
                            rasterOut->getCellCenterCoordinates(xx, yy, center);

                            if (rasterIn->indexAtCoords(center(0), center(1), index))
                            {
                                quint8 val = rasterIn->valueAtIndex(index);
                                if (val != rasterIn->NA())
                                {
                                    rasterOut->setValue(xx, yy, val);
                                }
                            }
                        }
                    }
                }

                rasterOut->computeMinMax();
                group->addSingularItem(_outRasterQuint8, rasterOut);

            } else if (_rasterType == "qint32")
            {
                qint32 naVal = -std::numeric_limits<qint32>::max();
                CT_Image2D<qint32>* rasterOut = new CT_Image2D<qint32>(minRasterX, minRasterY, dimx, dimy, _resolution, refLevel, naVal, naVal);

                for (const CT_Image2D<qint32>* rasterIn : _inRasterQint32.iterateInputs(_inResultRaster))
                {
                    for (int xx = 0 ; xx < dimx ; xx++)
                    {
                        for (int yy = 0 ; yy < dimy ; yy++)
                        {
                            Eigen::Vector3d center = Eigen::Vector3d(0.0, 0.0, 0.0);
                            size_t index;
                            rasterOut->getCellCenterCoordinates(xx, yy, center);

                            if (rasterIn->indexAtCoords(center(0), center(1), index))
                            {
                                qint32 val = rasterIn->valueAtIndex(index);
                                if (val != rasterIn->NA())
                                {
                                    rasterOut->setValue(xx, yy, val);
                                }
                            }
                        }
                    }
                }

                rasterOut->computeMinMax();
                group->addSingularItem(_outRasterQint32, rasterOut);

            }
        }
    }

    setProgress( 100 );
}