// SPDX-License-Identifier: LGPL-2.1-or-later

/***************************************************************************
 *   Copyright (c) 2004 Juergen Riegel <juergen.riegel@web.de>             *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  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 Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/

#include <cmath>

#include <Inventor/nodes/SoGroup.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoShapeHints.h>

#include <App/Document.h>
#include <Base/Parameter.h>

#include "ViewProvider.h"
#include "ViewProviderReference.h"


using namespace PartGui;

PROPERTY_SOURCE(PartGui::ViewProviderPartReference, Gui::ViewProviderGeometryObject)

//**************************************************************************
// Construction/Destruction

ViewProviderPartReference::ViewProviderPartReference()
{
    App::Material mat;
    mat.ambientColor.set(0.2f, 0.2f, 0.2f);
    mat.diffuseColor.set(0.1f, 0.1f, 0.1f);
    mat.specularColor.set(0.0f, 0.0f, 0.0f);
    mat.emissiveColor.set(0.0f, 0.0f, 0.0f);
    mat.shininess = 0.0f;
    mat.transparency = 0.0f;
    // ADD_PROPERTY(LineMaterial,(mat));
    // ADD_PROPERTY(PointMaterial,(mat));
    // ADD_PROPERTY(LineColor,(mat.diffuseColor));
    // ADD_PROPERTY(PointColor,(mat.diffuseColor));
    // ADD_PROPERTY(LineWidth,(2.0f));
    // LineWidth.setConstraints(&floatRange);
    // PointSize.setConstraints(&floatRange);
    // ADD_PROPERTY(PointSize,(2.0f));
    // ADD_PROPERTY(ControlPoints,(false));
    // ADD_PROPERTY(Lighting,(1));
    // Lighting.setEnums(LightingEnums);

    // EdgeRoot = new SoSeparator();
    // EdgeRoot->ref();
    // FaceRoot = new SoSeparator();
    // FaceRoot->ref();
    // VertexRoot = new SoSeparator();
    // VertexRoot->ref();
    // pcLineMaterial = new SoMaterial;
    // pcLineMaterial->ref();
    // LineMaterial.touch();

    // pcPointMaterial = new SoMaterial;
    // pcPointMaterial->ref();
    // PointMaterial.touch();

    // pcLineStyle = new SoDrawStyle();
    // pcLineStyle->ref();
    // pcLineStyle->style = SoDrawStyle::LINES;
    // pcLineStyle->lineWidth = LineWidth.getValue();

    // pcPointStyle = new SoDrawStyle();
    // pcPointStyle->ref();
    // pcPointStyle->style = SoDrawStyle::POINTS;
    // pcPointStyle->pointSize = PointSize.getValue();

    // pShapeHints = new SoShapeHints;
    // pShapeHints->shapeType = SoShapeHints::UNKNOWN_SHAPE_TYPE;
    // pShapeHints->ref();
    // Lighting.touch();

    sPixmap = "Part_3D_object";
    // loadParameter();
}

ViewProviderPartReference::~ViewProviderPartReference()
{
    // EdgeRoot->unref();
    // FaceRoot->unref();
    // VertexRoot->unref();
    // pcLineMaterial->unref();
    // pcPointMaterial->unref();
    // pcLineStyle->unref();
    // pcPointStyle->unref();
    // pShapeHints->unref();
}

void ViewProviderPartReference::onChanged(const App::Property* /*prop*/)
{
    // if (prop == &LineWidth) {
    //     pcLineStyle->lineWidth = LineWidth.getValue();
    // }
    // else if (prop == &PointSize) {
    //     pcPointStyle->pointSize = PointSize.getValue();
    // }
    // else if (prop == &LineColor) {
    //     const Base::Color& c = LineColor.getValue();
    //     pcLineMaterial->diffuseColor.setValue(c.r,c.g,c.b);
    //     if (c != LineMaterial.getValue().diffuseColor)
    //     LineMaterial.setDiffuseColor(c);
    // }
    // else if (prop == &PointColor) {
    //     const Base::Color& c = PointColor.getValue();
    //     pcPointMaterial->diffuseColor.setValue(c.r,c.g,c.b);
    //     if (c != PointMaterial.getValue().diffuseColor)
    //     PointMaterial.setDiffuseColor(c);
    // }
    // else if (prop == &LineMaterial) {
    //     const App::Material& Mat = LineMaterial.getValue();
    //     if (LineColor.getValue() != Mat.diffuseColor)
    //     LineColor.setValue(Mat.diffuseColor);
    //     pcLineMaterial->ambientColor.setValue(Mat.ambientColor.r,Mat.ambientColor.g,Mat.ambientColor.b);
    //     pcLineMaterial->diffuseColor.setValue(Mat.diffuseColor.r,Mat.diffuseColor.g,Mat.diffuseColor.b);
    //     pcLineMaterial->specularColor.setValue(Mat.specularColor.r,Mat.specularColor.g,Mat.specularColor.b);
    //     pcLineMaterial->emissiveColor.setValue(Mat.emissiveColor.r,Mat.emissiveColor.g,Mat.emissiveColor.b);
    //     pcLineMaterial->shininess.setValue(Mat.shininess);
    //     pcLineMaterial->transparency.setValue(Mat.transparency);
    // }
    // else if (prop == &PointMaterial) {
    //     const App::Material& Mat = PointMaterial.getValue();
    //     if (PointColor.getValue() != Mat.diffuseColor)
    //     PointColor.setValue(Mat.diffuseColor);
    //     pcPointMaterial->ambientColor.setValue(Mat.ambientColor.r,Mat.ambientColor.g,Mat.ambientColor.b);
    //     pcPointMaterial->diffuseColor.setValue(Mat.diffuseColor.r,Mat.diffuseColor.g,Mat.diffuseColor.b);
    //     pcPointMaterial->specularColor.setValue(Mat.specularColor.r,Mat.specularColor.g,Mat.specularColor.b);
    //     pcPointMaterial->emissiveColor.setValue(Mat.emissiveColor.r,Mat.emissiveColor.g,Mat.emissiveColor.b);
    //     pcPointMaterial->shininess.setValue(Mat.shininess);
    //     pcPointMaterial->transparency.setValue(Mat.transparency);
    // }
    // else if (prop == &ControlPoints) {
    //     App::DocumentObject* obj = this->pcObject;
    //     App::Property* shape = obj->getPropertyByName("Shape");
    //     showControlPoints(ControlPoints.getValue(), shape);
    // }
    // else if (prop == &Lighting) {
    //     if (Lighting.getValue() == 0)
    //         pShapeHints->vertexOrdering = SoShapeHints::UNKNOWN_ORDERING;
    //     else
    //         pShapeHints->vertexOrdering = SoShapeHints::COUNTERCLOCKWISE;
    // }
    // else {
    //     ViewProviderGeometryObject::onChanged(prop);
    // }
}

void ViewProviderPartReference::attach(App::DocumentObject* pcFeat)
{
    // call parent attach method
    ViewProviderGeometryObject::attach(pcFeat);

    SoGroup* pcNormalRoot = new SoGroup();
    // SoGroup* pcFlatRoot = new SoGroup();
    // SoGroup* pcWireframeRoot = new SoGroup();
    // SoGroup* pcPointsRoot = new SoGroup();

    // enable two-side rendering
    pShapeHints->vertexOrdering = SoShapeHints::COUNTERCLOCKWISE;
    pShapeHints->shapeType = SoShapeHints::UNKNOWN_SHAPE_TYPE;

    // normal viewing with edges and points
    pcNormalRoot->addChild(pShapeHints);
    pcNormalRoot->addChild(FaceRoot);
    pcNormalRoot->addChild(EdgeRoot);
    pcNormalRoot->addChild(VertexRoot);

    // just faces with no edges or points
    // pcFlatRoot->addChild(pShapeHints);
    // pcFlatRoot->addChild(FaceRoot);

    // only edges
    // pcWireframeRoot->addChild(EdgeRoot);
    // pcWireframeRoot->addChild(VertexRoot);

    // normal viewing with edges and points
    // pcPointsRoot->addChild(VertexRoot);

    // putting all together with the switch
    addDisplayMaskMode(pcNormalRoot, "Reference");
}

void ViewProviderPartReference::setDisplayMode(const char* ModeName)
{
    if (strcmp("Reference", ModeName) == 0) {
        setDisplayMaskMode("Reference");
    }

    ViewProviderGeometryObject::setDisplayMode(ModeName);
}

std::vector<std::string> ViewProviderPartReference::getDisplayModes() const
{
    // get the modes of the father
    std::vector<std::string> StrList = ViewProviderGeometryObject::getDisplayModes();

    // add your own modes
    StrList.emplace_back("Flat Lines");
    StrList.emplace_back("Shaded");
    StrList.emplace_back("Wireframe");
    StrList.emplace_back("Points");

    return StrList;
}


void ViewProviderPartReference::updateData(const App::Property*)
{}