/***************************************************************************
 *   Copyright (c) 2010 Werner Mayer <wmayer[at]users.sourceforge.net>     *
 *                                                                         *
 *   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 "PreCompiled.h"
#ifndef _PreComp_
# include <QMessageBox>
#endif

#include <Base/Console.h>
#include <Base/Exception.h>
#include <Base/Stream.h>
#include <Base/Tools.h>
#include <App/Application.h>
#include <App/Document.h>
#include <Gui/Application.h>
#include <Gui/BitmapFactory.h>
#include <Gui/Command.h>
#include <Gui/Control.h>
#include <Gui/Document.h>
#include <Gui/Selection.h>
#include <Gui/WaitCursor.h>
#include <Mod/Mesh/App/MeshFeature.h>
#include <Mod/Part/App/BodyBase.h>
#include <Mod/Mesh/Gui/ViewProvider.h>
#include <Mod/Part/Gui/ViewProvider.h>

#include "Tessellation.h"
#include "ui_Tessellation.h"


using namespace MeshPartGui;

/* TRANSLATOR MeshPartGui::Tessellation */

Tessellation::Tessellation(QWidget* parent)
  : QWidget(parent), ui(new Ui_Tessellation)
{
    ui->setupUi(this);
    gmsh = new Mesh2ShapeGmsh(this);
    connect(gmsh, SIGNAL(processed()), this, SLOT(gmshProcessed()));

    ui->stackedWidget->addTab(gmsh, tr("Gmsh"));

    ParameterGrp::handle handle = App::GetApplication().GetParameterGroupByPath
        ("User parameter:BaseApp/Preferences/Mod/Mesh/Meshing/Standard");
    double value = ui->spinSurfaceDeviation->value().getValue();
    value = handle->GetFloat("LinearDeflection", value);
    double angle = ui->spinAngularDeviation->value().getValue();
    angle = handle->GetFloat("AngularDeflection", angle);
    bool relative = ui->relativeDeviation->isChecked();
    relative = handle->GetBool("RelativeLinearDeflection", relative);
    ui->relativeDeviation->setChecked(relative);

    ui->spinSurfaceDeviation->setMaximum(INT_MAX);
    ui->spinSurfaceDeviation->setValue(value);
    ui->spinAngularDeviation->setValue(angle);

    ui->spinMaximumEdgeLength->setRange(0, INT_MAX);

    ui->comboFineness->setCurrentIndex(2);
    on_comboFineness_currentIndexChanged(2);

#if !defined (HAVE_MEFISTO)
    ui->stackedWidget->setTabEnabled(Mefisto, false);
#endif
#if !defined (HAVE_NETGEN)
    ui->stackedWidget->setTabEnabled(Netgen, false);
#endif

    Gui::Command::doCommand(Gui::Command::Doc, "import Mesh, Part, PartGui");
    try {
        Gui::Command::doCommand(Gui::Command::Doc, "import MeshPart");
    }
    catch (...) {
        ui->stackedWidget->setTabEnabled(Mefisto, false);
        ui->stackedWidget->setTabEnabled(Netgen, false);
    }
}

Tessellation::~Tessellation()
{
}

void Tessellation::meshingMethod(int id)
{
    ui->stackedWidget->setCurrentIndex(id);
}

void Tessellation::on_comboFineness_currentIndexChanged(int index)
{
    if (index == 5) {
        ui->doubleGrading->setEnabled(true);
        ui->spinEdgeElements->setEnabled(true);
        ui->spinCurvatureElements->setEnabled(true);
    }
    else {
        ui->doubleGrading->setEnabled(false);
        ui->spinEdgeElements->setEnabled(false);
        ui->spinCurvatureElements->setEnabled(false);
    }

    switch (index) {
    case 0: // Very coarse
        ui->doubleGrading->setValue(0.7);
        ui->spinEdgeElements->setValue(0.3);
        ui->spinCurvatureElements->setValue(1.0);
        break;
    case 1: // Coarse
        ui->doubleGrading->setValue(0.5);
        ui->spinEdgeElements->setValue(0.5);
        ui->spinCurvatureElements->setValue(1.5);
        break;
    case 2: // Moderate
        ui->doubleGrading->setValue(0.3);
        ui->spinEdgeElements->setValue(1.0);
        ui->spinCurvatureElements->setValue(2.0);
        break;
    case 3: // Fine
        ui->doubleGrading->setValue(0.2);
        ui->spinEdgeElements->setValue(2.0);
        ui->spinCurvatureElements->setValue(3.0);
        break;
    case 4: // Very fine
        ui->doubleGrading->setValue(0.1);
        ui->spinEdgeElements->setValue(3.0);
        ui->spinCurvatureElements->setValue(5.0);
        break;
    default:
        break;
    }
}

void Tessellation::on_checkSecondOrder_toggled(bool on)
{
    if (on)
        ui->checkQuadDominated->setChecked(false);
}

void Tessellation::on_checkQuadDominated_toggled(bool on)
{
    if (on)
        ui->checkSecondOrder->setChecked(false);
}

void Tessellation::gmshProcessed()
{
    bool doClose = !ui->checkBoxDontQuit->isChecked();
    if (doClose)
        Gui::Control().reject();
}

void Tessellation::changeEvent(QEvent *e)
{
    if (e->type() == QEvent::LanguageChange) {
        int index = ui->comboFineness->currentIndex();
        ui->retranslateUi(this);
        ui->comboFineness->setCurrentIndex(index);
    }
    QWidget::changeEvent(e);
}

void Tessellation::on_estimateMaximumEdgeLength_clicked()
{
    App::Document* activeDoc = App::GetApplication().getActiveDocument();
    if (!activeDoc) {
        return;
    }

    Gui::Document* activeGui = Gui::Application::Instance->getDocument(activeDoc);
    if (!activeGui) {
        return;
    }

    double edgeLen = 0;
    for (auto &sel : Gui::Selection().getSelection("*", Gui::ResolveMode::NoResolve)) {
        auto shape = Part::Feature::getTopoShape(sel.pObject,sel.SubName);
        if (shape.hasSubShape(TopAbs_FACE)) {
            Base::BoundBox3d bbox = shape.getBoundBox();
            edgeLen = std::max<double>(edgeLen, bbox.LengthX());
            edgeLen = std::max<double>(edgeLen, bbox.LengthY());
            edgeLen = std::max<double>(edgeLen, bbox.LengthZ());
        }
    }

    ui->spinMaximumEdgeLength->setValue(edgeLen/10);
}

bool Tessellation::accept()
{
    std::list<App::SubObjectT> shapeObjects;
    App::Document* activeDoc = App::GetApplication().getActiveDocument();
    if (!activeDoc) {
        QMessageBox::critical(this, windowTitle(), tr("No active document"));
        return false;
    }

    Gui::Document* activeGui = Gui::Application::Instance->getDocument(activeDoc);
    if (!activeGui) {
        QMessageBox::critical(this, windowTitle(), tr("No active document"));
        return false;
    }

    this->document = QString::fromLatin1(activeDoc->getName());

    bool bodyWithNoTip = false;
    bool partWithNoFace = false;
    for (auto &sel : Gui::Selection().getSelection("*", Gui::ResolveMode::NoResolve)) {
        auto shape = Part::Feature::getTopoShape(sel.pObject,sel.SubName);
        if (shape.hasSubShape(TopAbs_FACE)) {
            shapeObjects.emplace_back(sel.pObject, sel.SubName);
        }
        else if (sel.pObject) {
            if (sel.pObject->isDerivedFrom(Part::Feature::getClassTypeId())) {
                partWithNoFace = true;
            }
            if (sel.pObject->isDerivedFrom(Part::BodyBase::getClassTypeId())) {
                Part::BodyBase* body = static_cast<Part::BodyBase*>(sel.pObject);
                if (!body->Tip.getValue()) {
                    bodyWithNoTip = true;
                }
            }
        }
    }

    if (shapeObjects.empty()) {
        if (bodyWithNoTip) {
            QMessageBox::critical(this, windowTitle(), tr("You have selected a body without tip.\n"
                                                          "Either set the tip of the body or select a different shape, please."));
        }
        else if (partWithNoFace) {
            QMessageBox::critical(this, windowTitle(), tr("You have selected a shape without faces.\n"
                                                          "Select a different shape, please."));
        }
        else {
            QMessageBox::critical(this, windowTitle(), tr("Select a shape for meshing, first."));
        }
        return false;
    }

    bool doClose = !ui->checkBoxDontQuit->isChecked();
    int method = ui->stackedWidget->currentIndex();

    // For Gmsh the workflow is very different because it uses an executable
    // and therefore things are asynchronous
    if (method == Gmsh) {
        gmsh->process(activeDoc, shapeObjects);
        return false;
    }
    else {
        process(method, activeDoc, shapeObjects);
        return doClose;
    }
}

void Tessellation::process(int method, App::Document* doc, const std::list<App::SubObjectT>& shapeObjects)
{
    try {
        Gui::WaitCursor wc;

        saveParameters(method);

        doc->openTransaction("Meshing");
        for (auto &info : shapeObjects) {
            QString subname = QString::fromLatin1(info.getSubName().c_str());
            QString objname = QString::fromLatin1(info.getObjectName().c_str());

            auto obj = info.getObject();
            if (!obj)
                continue;
            auto sobj = obj->getSubObject(info.getSubName().c_str());
            if (!sobj)
                continue;
            sobj = sobj->getLinkedObject(true);
            if (!sobj)
                continue;

            QString label = QString::fromUtf8(sobj->Label.getValue());

            QString param = getMeshingParameters(method, sobj);

            QString cmd = QString::fromLatin1(
                "__doc__=FreeCAD.getDocument(\"%1\")\n"
                "__mesh__=__doc__.addObject(\"Mesh::Feature\",\"Mesh\")\n"
                "__part__=__doc__.getObject(\"%2\")\n"
                "__shape__=Part.getShape(__part__,\"%3\")\n"
                "__mesh__.Mesh=MeshPart.meshFromShape(%4)\n"
                "__mesh__.Label=\"%5 (Meshed)\"\n"
                "del __doc__, __mesh__, __part__, __shape__\n")
                .arg(this->document,
                     objname,
                     subname,
                     param,
                     label);

            Gui::Command::runCommand(Gui::Command::Doc, cmd.toUtf8());

            setFaceColors(method, doc, sobj);
        }
        doc->commitTransaction();
    }
    catch (const Base::Exception& e) {
        doc->abortTransaction();
        Base::Console().Error(e.what());
    }
}

void Tessellation::saveParameters(int method)
{
    if (method == Standard) {
        ParameterGrp::handle handle = App::GetApplication().GetParameterGroupByPath
            ("User parameter:BaseApp/Preferences/Mod/Mesh/Meshing/Standard");
        double value = ui->spinSurfaceDeviation->value().getValue();
        handle->SetFloat("LinearDeflection", value);
        double angle = ui->spinAngularDeviation->value().getValue();
        handle->SetFloat("AngularDeflection", angle);
        bool relative = ui->relativeDeviation->isChecked();
        handle->SetBool("RelativeLinearDeflection", relative);
    }
}

void Tessellation::setFaceColors(int method, App::Document* doc, App::DocumentObject* obj)
{
    // if Standard mesher is used and face colors should be applied
    if (method == Standard) {
        if (ui->meshShapeColors->isChecked()) {
            Gui::ViewProvider* vpm = Gui::Application::Instance->getViewProvider
                    (doc->getActiveObject());
            MeshGui::ViewProviderMesh* vpmesh = dynamic_cast<MeshGui::ViewProviderMesh*>(vpm);

            auto svp = Base::freecad_dynamic_cast<PartGui::ViewProviderPartExt>(
                    Gui::Application::Instance->getViewProvider(obj));
            if (vpmesh && svp) {
                std::vector<App::Color> diff_col = svp->DiffuseColor.getValues();
                if (ui->groupsFaceColors->isChecked()) {
                    diff_col = getUniqueColors(diff_col);
                }
                vpmesh->highlightSegments(diff_col);
            }
        }
    }
}

std::vector<App::Color> Tessellation::getUniqueColors(const std::vector<App::Color>& colors) const
{
    // unique colors
    std::set<uint32_t> col_set;
    for (const auto& it : colors)
        col_set.insert(it.getPackedValue());

    std::vector<App::Color> unique;
    for (const auto& it : col_set)
        unique.emplace_back(it);
    return unique;
}

QString Tessellation::getMeshingParameters(int method, App::DocumentObject* obj) const
{
    QString param;
    if (method == Standard) {
        param = getStandardParameters(obj);
    }
    else if (method == Mefisto) {
        param = getMefistoParameters();
    }
    else if (method == Netgen) {
        param = getNetgenParameters();
    }

    return param;
}

QString Tessellation::getStandardParameters(App::DocumentObject* obj) const
{
    double devFace = ui->spinSurfaceDeviation->value().getValue();
    double devAngle = ui->spinAngularDeviation->value().getValue();
    devAngle = Base::toRadians<double>(devAngle);
    bool relative = ui->relativeDeviation->isChecked();

    QString param;
    param = QString::fromLatin1("Shape=__shape__, "
                                "LinearDeflection=%1, "
                                "AngularDeflection=%2, "
                                "Relative=%3")
        .arg(devFace)
        .arg(devAngle)
        .arg(relative ? QString::fromLatin1("True") : QString::fromLatin1("False"));
    if (ui->meshShapeColors->isChecked())
        param += QString::fromLatin1(",Segments=True");

    auto svp = Base::freecad_dynamic_cast<PartGui::ViewProviderPartExt>(
            Gui::Application::Instance->getViewProvider(obj));
    if (ui->groupsFaceColors->isChecked() && svp) {
        // TODO: currently, we can only retrieve part feature
        // color. The problem is that if the feature is linked,
        // there are potentially many places where the color can
        // get overridden.
        //
        // With topo naming feature merged, it will be possible to
        // infer more accurate colors from just the shape names,
        // with static function,
        //
        // PartGui::ViewProviderPartExt::getShapeColors().
        //
        param += QString::fromLatin1(",GroupColors=Gui.getDocument('%1').getObject('%2').DiffuseColor")
                .arg(QString::fromLatin1(obj->getDocument()->getName()),
                     QString::fromLatin1(obj->getNameInDocument()));
    }

    return param;
}

QString Tessellation::getMefistoParameters() const
{
    double maxEdge = ui->spinMaximumEdgeLength->value().getValue();
    if (!ui->spinMaximumEdgeLength->isEnabled())
        maxEdge = 0;
    return QString::fromLatin1("Shape=__shape__,MaxLength=%1").arg(maxEdge);
}

QString Tessellation::getNetgenParameters() const
{
    QString param;
    int fineness = ui->comboFineness->currentIndex();
    double growthRate = ui->doubleGrading->value();
    double nbSegPerEdge = ui->spinEdgeElements->value();
    double nbSegPerRadius = ui->spinCurvatureElements->value();
    bool secondOrder = ui->checkSecondOrder->isChecked();
    bool optimize = ui->checkOptimizeSurface->isChecked();
    bool allowquad = ui->checkQuadDominated->isChecked();
    if (fineness < 5) {
        param = QString::fromLatin1("Shape=__shape__,"
            "Fineness=%1,SecondOrder=%2,Optimize=%3,AllowQuad=%4")
            .arg(fineness)
            .arg(secondOrder ? 1 : 0)
            .arg(optimize ? 1 : 0)
            .arg(allowquad ? 1 : 0);
    }
    else {
        param = QString::fromLatin1("Shape=__shape__,"
            "GrowthRate=%1,SegPerEdge=%2,SegPerRadius=%3,SecondOrder=%4,Optimize=%5,AllowQuad=%6")
            .arg(growthRate)
            .arg(nbSegPerEdge)
            .arg(nbSegPerRadius)
            .arg(secondOrder ? 1 : 0)
            .arg(optimize ? 1 : 0)
            .arg(allowquad ? 1 : 0);
    }

    return param;
}

// ---------------------------------------

class Mesh2ShapeGmsh::Private {
public:
    std::string label;
    std::list<App::SubObjectT> shapes;
    App::DocumentT doc;
    std::string cadFile;
    std::string stlFile;
    std::string geoFile;
};

Mesh2ShapeGmsh::Mesh2ShapeGmsh(QWidget* parent, Qt::WindowFlags fl)
  : GmshWidget(parent, fl)
  , d(new Private())
{
    d->cadFile = App::Application::getTempFileName() + "mesh.brep";
    d->stlFile = App::Application::getTempFileName() + "mesh.stl";
    d->geoFile = App::Application::getTempFileName() + "mesh.geo";
}

Mesh2ShapeGmsh::~Mesh2ShapeGmsh()
{
}

void Mesh2ShapeGmsh::process(App::Document* doc, const std::list<App::SubObjectT>& objs)
{
    d->doc = doc;
    d->shapes = objs;

    doc->openTransaction("Meshing");
    accept();
}

bool Mesh2ShapeGmsh::writeProject(QString& inpFile, QString& outFile)
{
    if (!d->shapes.empty()) {
        App::SubObjectT sub = d->shapes.front();
        d->shapes.pop_front();

        App::DocumentObject* part = sub.getObject();
        if (part) {
            Part::TopoShape shape = Part::Feature::getTopoShape(part, sub.getSubName().c_str());
            shape.exportBrep(d->cadFile.c_str());
            d->label = part->Label.getStrValue() + " (Meshed)";

            // Parameters
            int algorithm = meshingAlgorithm();
            double maxSize = getMaxSize();
            if (maxSize == 0.0)
                maxSize = 1.0e22;
            double minSize = getMinSize();

            // Gmsh geo file
            Base::FileInfo geo(d->geoFile);
            Base::ofstream geoOut(geo, std::ios::out);
            geoOut << "// geo file for meshing with Gmsh meshing software created by FreeCAD\n"
                << "// open brep geometry\n"
                << "Merge \"" << d->cadFile << "\";\n\n"
                << "// Characteristic Length\n"
                << "// no boundary layer settings for this mesh\n"
                << "// min, max Characteristic Length\n"
                << "Mesh.CharacteristicLengthMax = " << maxSize << ";\n"
                << "Mesh.CharacteristicLengthMin = " << minSize << ";\n\n"
                << "// optimize the mesh\n"
                << "Mesh.Optimize = 1;\n"
                << "Mesh.OptimizeNetgen = 0;\n"
                << "// High-order meshes optimization (0=none, 1=optimization, 2=elastic+optimization, 3=elastic, 4=fast curving)\n"
                << "Mesh.HighOrderOptimize = 0;\n\n"
                << "// mesh order\n"
                << "Mesh.ElementOrder = 2;\n"
                << "// Second order nodes are created by linear interpolation instead by curvilinear\n"
                << "Mesh.SecondOrderLinear = 1;\n\n"
                << "// mesh algorithm, only a few algorithms are usable with 3D boundary layer generation\n"
                << "// 2D mesh algorithm (1=MeshAdapt, 2=Automatic, 5=Delaunay, 6=Frontal, 7=BAMG, 8=DelQuad, 9=Packing of Parallelograms)\n"
                << "Mesh.Algorithm = " << algorithm << ";\n"
                << "// 3D mesh algorithm (1=Delaunay, 2=New Delaunay, 4=Frontal, 7=MMG3D, 9=R-tree, 10=HTX)\n"
                << "Mesh.Algorithm3D = 1;\n\n"
                << "// meshing\n"
                << "// set geometrical tolerance (also used for merging nodes)\n"
                << "Geometry.Tolerance = 1e-06;\n"
                << "Mesh  2;\n"
                << "Coherence Mesh; // Remove duplicate vertices\n";
            geoOut.close();

            inpFile = QString::fromUtf8(d->geoFile.c_str());
            outFile = QString::fromUtf8(d->stlFile.c_str());

            return true;
        }
    }
    else {
        App::Document* doc = d->doc.getDocument();
        if (doc)
            doc->commitTransaction();

        Q_EMIT processed();
    }

    return false;
}

bool Mesh2ShapeGmsh::loadOutput()
{
    App::Document* doc = d->doc.getDocument();
    if (!doc)
        return false;

    // Now read-in the mesh
    Base::FileInfo stl(d->stlFile);
    Base::FileInfo geo(d->geoFile);

    Mesh::MeshObject kernel;
    MeshCore::MeshInput input(kernel.getKernel());
    Base::ifstream stlIn(stl, std::ios::in | std::ios::binary);
    input.LoadBinarySTL(stlIn);
    stlIn.close();
    kernel.harmonizeNormals();

    Mesh::Feature* fea = static_cast<Mesh::Feature*>(doc->addObject("Mesh::Feature", "Mesh"));
    fea->Label.setValue(d->label);
    fea->Mesh.setValue(kernel.getKernel());
    stl.deleteFile();
    geo.deleteFile();

    // process next object
    accept();

    return true;
}

// ---------------------------------------

TaskTessellation::TaskTessellation()
{
    widget = new Tessellation();
    Gui::TaskView::TaskBox* taskbox = new Gui::TaskView::TaskBox(
        QPixmap()/*Gui::BitmapFactory().pixmap("MeshPart_Mesher")*/,
        widget->windowTitle(), true, nullptr);
    taskbox->groupLayout()->addWidget(widget);
    Content.push_back(taskbox);
}

TaskTessellation::~TaskTessellation()
{
    // automatically deleted in the sub-class
}

void TaskTessellation::open()
{
}

void TaskTessellation::clicked(int)
{
}

bool TaskTessellation::accept()
{
    return widget->accept();
}

bool TaskTessellation::reject()
{
    return true;
}

#include "moc_Tessellation.cpp"