/****************************************************************************
 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_stepgenerateshape3d.h"

#include <time.h>

GEN_StepGenerateShape3D::GEN_StepGenerateShape3D() : SuperClass()
{
    _nbCircle = 5;
    _nbCylinder = 5;
    _nbEllipse = 5;
    _nbLine = 5;
    _nbSphere = 5;

    _minx = -10;
    _miny = -10;
    _minz = -10;

    _maxx = 10;
    _maxy = 10;
    _maxz = 10;
}

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

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

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

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

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

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

    manager.addGroup(m_hOutRootGroup, m_hOut_groupCircle);
    manager.addGroup(m_hOutRootGroup, m_hOut_groupCylinder);
    manager.addGroup(m_hOutRootGroup, m_hOut_groupEllipse);
    manager.addGroup(m_hOutRootGroup, m_hOut_groupLine);
    manager.addGroup(m_hOutRootGroup, m_hOut_groupSphere);

    manager.addItem(m_hOut_groupCircle, m_hOut_Circle, tr("Generated Circle 3D"));
    manager.addItem(m_hOut_groupCylinder, m_hOut_Cylinder, tr("Generated Cylinder"));
    manager.addItem(m_hOut_groupEllipse, m_hOut_Ellipse, tr("Generated Ellipse 3D"));
    manager.addItem(m_hOut_groupLine, m_hOut_Line, tr("Generated Line 3D"));
    manager.addItem(m_hOut_groupSphere, m_hOut_Sphere, tr("Generated Sphere"));
}

void GEN_StepGenerateShape3D::fillPostInputConfigurationDialog(CT_StepConfigurableDialog* postInputConfigDialog)
{
    postInputConfigDialog->addInt(tr("Nombre de cercles 3D"), "", 0, 9999, _nbCircle);
    postInputConfigDialog->addInt(tr("Nombre de cylindres"), "", 0, 9999, _nbCylinder);
    postInputConfigDialog->addInt(tr("Nombre d'ellipses 3D"), "", 0, 9999, _nbEllipse);
    postInputConfigDialog->addInt(tr("Nombre de lignes 3D"), "", 0, 9999, _nbLine);
    postInputConfigDialog->addInt(tr("Nombre de sphères"), "", 0, 9999, _nbSphere);
    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);
    postInputConfigDialog->addDouble(tr("Zmin"), "", -std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), 2, _minz);
    postInputConfigDialog->addDouble(tr("Zmax"), "", -std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), 2, _maxz);
}

void GEN_StepGenerateShape3D::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);
        double deltaZ = fabs(_maxz - _minz);

        srand(uint(time(nullptr)));

        for (int i = 0 ; (i < _nbCircle) && !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 z = _minz + (double(rand())/RAND_MAX) * deltaZ;
            double r = (double(rand())/RAND_MAX);

            double dx = rand();
            double dy = rand();
            double dz = rand();

            CT_CircleData *data = new CT_CircleData(Eigen::Vector3d(x, y, z), Eigen::Vector3d(dx, dy, dz), r);
            CT_Circle *item = new CT_Circle(data);

            rootGroup->addGroup(m_hOut_groupCircle, group);
            group->addSingularItem(m_hOut_Circle, item);
        }

        for (int i = 0 ; (i < _nbCylinder) && !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 z = _minz + (double(rand())/RAND_MAX) * deltaZ;
            double r = (double(rand())/RAND_MAX);
            double h = (double(rand())/RAND_MAX);

            CT_CylinderData *data = new CT_CylinderData(Eigen::Vector3d(x, y, z), Eigen::Vector3d(0, 0, 1), r, h);
            CT_Cylinder *item = new CT_Cylinder(data);

            rootGroup->addGroup(m_hOut_groupCylinder, group);
            group->addSingularItem(m_hOut_Cylinder, item);
        }

        for (int i = 0 ; (i < _nbEllipse) && !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 z = _minz + (double(rand())/RAND_MAX) * deltaZ;
            double r1 = (double(rand())/RAND_MAX);
            double r2 = (double(rand())/RAND_MAX);

            CT_LineData axisA(Eigen::Vector3d(x-r1, y, z), Eigen::Vector3d(x+r1, y, z));
            CT_LineData axisB(Eigen::Vector3d(x, y-r2, z), Eigen::Vector3d(x, y+r2, z));

            CT_EllipseData *data = new CT_EllipseData(Eigen::Vector3d(x, y, z), axisA, axisB);
            CT_Ellipse *item = new CT_Ellipse(data);

            rootGroup->addGroup(m_hOut_groupEllipse, group);
            group->addSingularItem(m_hOut_Ellipse, item);
        }

        for (int i = 0 ; (i < _nbLine) && !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 z1 = _minz + (double(rand())/RAND_MAX) * deltaY;
            double x2 = _minx + (double(rand())/RAND_MAX) * deltaX;
            double y2 = _miny + (double(rand())/RAND_MAX) * deltaY;
            double z2 = _minz + (double(rand())/RAND_MAX) * deltaY;

            CT_LineData *data = new CT_LineData(Eigen::Vector3d(x1, y1, z1), Eigen::Vector3d(x2, y2, z2));
            CT_Line *item = new CT_Line(data);

            rootGroup->addGroup(m_hOut_groupLine, group);
            group->addSingularItem(m_hOut_Line, item);
        }

        for (int i = 0 ; (i < _nbSphere) && !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 z = _minz + (double(rand())/RAND_MAX) * deltaZ;
            double r = (double(rand())/RAND_MAX);

            CT_SphereData *data = new CT_SphereData(Eigen::Vector3d(x, y, z), r);
            CT_Sphere *item = new CT_Sphere(data);

            rootGroup->addGroup(m_hOut_groupSphere, group);
            group->addSingularItem(m_hOut_Sphere, item);
        }
    }
}