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

 Contact : alexandre.piboule@onf.fr

 Developers : Michael Krebbs (Independant)
              Alexandre PIBOULE (ONF)

 This file is part of PluginGenerate library.

 PluginGenerate 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.

 PluginGenerate 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 PluginGenerate.  If not, see <http://www.gnu.org/licenses/lgpl.html>.
*****************************************************************************/

#include "gen_stepgenerateshape2d.h"

#include <time.h>

GEN_StepGenerateShape2D::GEN_StepGenerateShape2D() : SuperClass()
{
    _boxNb = 5;
    _circleNb = 5;
    _pointNb = 5;
    _lineNb = 5;
    _polygonNb = 5;
    _polylineNb = 5;
    _minx = -10;
    _miny = -10;
    _maxx = 10;
    _maxy = 10;
}

QString GEN_StepGenerateShape2D::description() const
{
    return tr("Créer des Formes Géométriques 2D");
}

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

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

void GEN_StepGenerateShape2D::declareInputModels(CT_StepInModelStructureManager& manager)
{
    manager.setNotNeedInputResult();
}

void GEN_StepGenerateShape2D::declareOutputModels(CT_StepOutModelStructureManager& manager)
{
    manager.addResult(m_hOutResult, tr("Generated Items"));
    manager.setRootGroup(m_hOutResult, m_hOutRootGroup);

    manager.addGroup(m_hOutRootGroup, m_hOut_groupBox2D);
    manager.addGroup(m_hOutRootGroup, m_hOut_groupCircle2D);
    manager.addGroup(m_hOutRootGroup, m_hOut_groupPoint2D);
    manager.addGroup(m_hOutRootGroup, m_hOut_groupLine2D);
    manager.addGroup(m_hOutRootGroup, m_hOut_groupPolygon2D);
    manager.addGroup(m_hOutRootGroup, m_hOut_groupPolyline2D);

    manager.addItem(m_hOut_groupBox2D, m_hOut_Box2D, tr("Generated Box 2D"));
    manager.addItem(m_hOut_groupCircle2D, m_hOut_Circle2D, tr("Generated Circle 2D"));
    manager.addItem(m_hOut_groupPoint2D, m_hOut_Point2D, tr("Generated Point 2D"));
    manager.addItem(m_hOut_groupLine2D, m_hOut_Line2D, tr("Generated Line 2D"));
    manager.addItem(m_hOut_groupPolygon2D, m_hOut_Polygon2D, tr("Generated Polygon 2D"));
    manager.addItem(m_hOut_groupPolyline2D, m_hOut_Polyline2D, tr("Generated Polyline 2D"));
}

void GEN_StepGenerateShape2D::fillPostInputConfigurationDialog(CT_StepConfigurableDialog* postInputConfigDialog)
{
    postInputConfigDialog->addInt(tr("Nombre de rectangles 2D"), "", 0, 9999, _boxNb);
    postInputConfigDialog->addInt(tr("Nombre de cercles 2D"), "", 0, 9999, _circleNb);
    postInputConfigDialog->addInt(tr("Nombre de points 2D"), "", 0, 9999, _pointNb);
    postInputConfigDialog->addInt(tr("Nombre de lignes 2D"), "", 0, 9999, _lineNb);
    postInputConfigDialog->addInt(tr("Nombre de polygones 2D"), "", 0, 9999, _polygonNb);
    postInputConfigDialog->addInt(tr("Nombre de polylignes 2D"), "", 0, 9999, _polylineNb);
    postInputConfigDialog->addDouble(tr("Xmin"), "", -std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), 2, _minx);
    postInputConfigDialog->addDouble(tr("Xmax"), "", -std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), 2, _maxx);
    postInputConfigDialog->addDouble(tr("Ymin"), "", -std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), 2, _miny);
    postInputConfigDialog->addDouble(tr("Ymax"), "", -std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), 2, _maxy);
}

void GEN_StepGenerateShape2D::compute()
{
    for(CT_ResultGroup* result : m_hOutResult.iterateOutputs()) {

        CT_StandardItemGroup* rootGroup = m_hOutRootGroup.createInstance();
        result->addRootGroup(m_hOutRootGroup, rootGroup);

        double deltaX = fabs(_maxx - _minx);
        double deltaY = fabs(_maxy - _miny);

        srand(uint(time(nullptr)));

        for (int i = 0 ; (i < _boxNb) && !isStopped() ; i++)
        {
            CT_StandardItemGroup *group = new CT_StandardItemGroup();

            double x = _minx + (double(rand())/RAND_MAX) * deltaX;
            double y = _miny + (double(rand())/RAND_MAX) * deltaY;
            double h = (double(rand())/RAND_MAX) * 10;
            double w = (double(rand())/RAND_MAX) * 10;

            CT_Box2DData *data = new CT_Box2DData(Eigen::Vector2d(x, y), h, w);
            CT_Box2D *item = new CT_Box2D(data);

            rootGroup->addGroup(m_hOut_groupBox2D, group);
            group->addSingularItem(m_hOut_Box2D, item);
        }

        for (int i = 0 ; (i < _circleNb) && !isStopped() ; i++)
        {
            CT_StandardItemGroup *group = new CT_StandardItemGroup();

            double x = _minx + (double(rand())/RAND_MAX) * deltaX;
            double y = _miny + (double(rand())/RAND_MAX) * deltaY;
            double r = (double(rand())/RAND_MAX);

            CT_Circle2DData *data = new CT_Circle2DData(Eigen::Vector2d(x, y), r);
            CT_Circle2D *item = new CT_Circle2D(data);

            rootGroup->addGroup(m_hOut_groupCircle2D, group);
            group->addSingularItem(m_hOut_Circle2D, item);
        }

        for (int i = 0 ; (i < _pointNb) && !isStopped() ; i++)
        {
            CT_StandardItemGroup *group = new CT_StandardItemGroup();

            double x = _minx + (double(rand())/RAND_MAX) * deltaX;
            double y = _miny + (double(rand())/RAND_MAX) * deltaY;

            CT_Point2DData *data = new CT_Point2DData(Eigen::Vector2d(x, y));
            CT_Point2D *item = new CT_Point2D(data);

            rootGroup->addGroup(m_hOut_groupPoint2D, group);
            group->addSingularItem(m_hOut_Point2D, item);
        }

        for (int i = 0 ; (i < _lineNb) && !isStopped() ; i++)
        {
            CT_StandardItemGroup *group = new CT_StandardItemGroup();

            double x1 = _minx + (double(rand())/RAND_MAX) * deltaX;
            double y1 = _miny + (double(rand())/RAND_MAX) * deltaY;
            double x2 = _minx + (double(rand())/RAND_MAX) * deltaX;
            double y2 = _miny + (double(rand())/RAND_MAX) * deltaY;

            CT_Line2DData *data = new CT_Line2DData(Eigen::Vector2d(x1, y1), Eigen::Vector2d(x2, y2));
            CT_Line2D *item = new CT_Line2D(data);

            rootGroup->addGroup(m_hOut_groupLine2D, group);
            group->addSingularItem(m_hOut_Line2D, item);
        }

        for (int i = 0 ; (i < _polygonNb) && !isStopped() ; i++)
        {
            CT_StandardItemGroup *group = new CT_StandardItemGroup();

            int nv = rand() % 15 +1;

            QVector<Eigen::Vector2d> vertices(nv);

            for (int j = 0 ; j < nv ; j++)
            {
                double x = _minx + (double(rand())/RAND_MAX) * deltaX;
                double y = _miny + (double(rand())/RAND_MAX) * deltaY;

                vertices[j] = Eigen::Vector2d(x, y);
            }

            CT_Polygon2DData *data = new CT_Polygon2DData(vertices);
            CT_Polygon2D *item = new CT_Polygon2D(data);

            rootGroup->addGroup(m_hOut_groupPolygon2D, group);
            group->addSingularItem(m_hOut_Polygon2D, item);
        }

        for (int i = 0 ; (i < _polylineNb) && !isStopped() ; i++)
        {
            CT_StandardItemGroup *group = new CT_StandardItemGroup();

            int nv = rand() % 15 +1;

            QVector<Eigen::Vector2d> vertices(nv);

            for (int j = 0 ; j < nv ; j++)
            {
                double x = _minx + (double(rand())/RAND_MAX) * deltaX;
                double y = _miny + (double(rand())/RAND_MAX) * deltaY;

                vertices[j] = Eigen::Vector2d(x, y);
            }

            CT_Polyline2DData *data = new CT_Polyline2DData(vertices);
            CT_Polyline2D *item = new CT_Polyline2D(data);

            rootGroup->addGroup(m_hOut_groupPolyline2D, group);
            group->addSingularItem(m_hOut_Polyline2D, item);
        }
    }

}