/***************************************************************************
 *   Copyright (c) 2009 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 "PreCompiled.h"

#ifndef _PreComp_
# include <QRegExp>
# include <QString>
#endif


#include "TaskAssemblyConstraints.h"

#include <Constraint.h>
#include <ItemPart.h>

#include <Base/Tools.h>
#include <Base/Console.h>
#include <Gui/Application.h>
#include <Gui/Document.h>
#include <Gui/BitmapFactory.h>
#include <Gui/ViewProvider.h>
#include <Gui/MainWindow.h>
#include <Gui/BitmapFactory.h>
#include <boost/bind.hpp>

using namespace AssemblyGui;
using namespace Gui::TaskView;

extern Assembly::Item* ActiveAsmObject;

TaskAssemblyConstraints::TaskAssemblyConstraints(ViewProviderConstraint* vp)
    : TaskBox(Gui::BitmapFactory().pixmap("document-new"),tr("Constraints"),true, 0), view(vp)
{
    // we need a separate container widget to add all controls to
    proxy = new QWidget(this);
    ui = new Ui::TaskAssemblyConstraints();
    ui->setupUi(proxy);
    this->groupLayout()->addWidget(proxy);

    //initialy hide the value and orientation field
    ui->value_widget->hide();
    ui->orientation_widget->hide();

    //set all basic values
    Assembly::ItemAssembly* ass = NULL;
    Assembly::Constraint* obj =  dynamic_cast<Assembly::Constraint*>(vp->getObject());
    if(obj->First.getValue()) {
        QString str;
        str = QString::fromAscii(obj->First.getValue()->getNameInDocument()) + QString::fromAscii(".") + QString::fromStdString(obj->First.getSubValues().front());
        ui->first_geom->setText(str);
        ass = dynamic_cast<Assembly::ItemPart*>(obj->First.getValue())->getParentAssembly();
    };
    if(obj->Second.getValue()) {
        QString str;
        str = QString::fromAscii(obj->Second.getValue()->getNameInDocument()) + QString::fromAscii(".") + QString::fromStdString(obj->Second.getSubValues().front());
        ui->second_geom->setText(str);
        if(!ass)
            ass = dynamic_cast<Assembly::ItemPart*>(obj->Second.getValue())->getParentAssembly();
    };

    if(ass)
        ass->execute();

    //get the individual constraint settings
    ui->value->setValue(obj->Value.getValue());
    setOrientation(dcm::Direction(obj->Orientation.getValue()));
    setSolutionSpace(dcm::SolutionSpace(obj->SolutionSpace.getValue()));

    int v = obj->Type.getValue();
    if(v==0)
        ui->fix->setChecked(true);

    if(v==1)
        ui->distance->setChecked(true);

    if(v==2)
        ui->orientation->setChecked(true);

    if(v==3)
        ui->angle->setChecked(true);

    if(v==4)
        ui->align->setChecked(true);

    if(v==5)
        ui->coincident->setChecked(true);


    setPossibleConstraints();
    setPossibleOptions();

    //setup all signals for event processing
    QObject::connect(
        ui->fix, SIGNAL(toggled(bool)),
        this, SLOT(on_constraint_selection(bool)));
    QObject::connect(
        ui->distance, SIGNAL(toggled(bool)),
        this, SLOT(on_constraint_selection(bool)));
    QObject::connect(
        ui->orientation, SIGNAL(toggled(bool)),
        this, SLOT(on_constraint_selection(bool)));
    QObject::connect(
        ui->angle, SIGNAL(toggled(bool)),
        this, SLOT(on_constraint_selection(bool)));
    QObject::connect(
        ui->align, SIGNAL(toggled(bool)),
        this, SLOT(on_constraint_selection(bool)));
    QObject::connect(
        ui->coincident, SIGNAL(toggled(bool)),
        this, SLOT(on_constraint_selection(bool)));
    QObject::connect(
        ui->parallel, SIGNAL(toggled(bool)),
        this, SLOT(on_orientation_selection(bool)));
    QObject::connect(
        ui->equal, SIGNAL(toggled(bool)),
        this, SLOT(on_orientation_selection(bool)));
    QObject::connect(
        ui->opposite, SIGNAL(toggled(bool)),
        this, SLOT(on_orientation_selection(bool)));
    QObject::connect(
        ui->perpendicular, SIGNAL(toggled(bool)),
        this, SLOT(on_orientation_selection(bool)));
    QObject::connect(
        ui->bidirectional, SIGNAL(toggled(bool)),
        this, SLOT(on_solutionspace_selection(bool)));
    QObject::connect(
        ui->pos_direction, SIGNAL(toggled(bool)),
        this, SLOT(on_solutionspace_selection(bool)));
    QObject::connect(
        ui->neg_direction, SIGNAL(toggled(bool)),
        this, SLOT(on_solutionspace_selection(bool)));
    QObject::connect(
        ui->perpendicular, SIGNAL(toggled(bool)),
        this, SLOT(on_orientation_selection(bool)));
    QObject::connect(
        ui->value, SIGNAL(valueChanged(double)),
        this, SLOT(on_value_change(double)));
    QObject::connect(
        ui->clear_first, SIGNAL(pressed()),
        this, SLOT(on_clear_first()));
    QObject::connect(
        ui->clear_second, SIGNAL(pressed()),
        this, SLOT(on_clear_second()));

}

dcm::Direction TaskAssemblyConstraints::getOrientation()
{
    if(ui->parallel->isChecked())
        return dcm::parallel;
    if(ui->equal->isChecked())
        return dcm::equal;
    if(ui->opposite->isChecked())
        return dcm::opposite;

    return dcm::perpendicular;
}

void TaskAssemblyConstraints::setOrientation(dcm::Direction d)
{
    switch(d) {
    case dcm::perpendicular:
        ui->perpendicular->setChecked(true);
        break;
    case dcm::equal:
        ui->equal->setChecked(true);
        break;
    case dcm::opposite:
        ui->opposite->setChecked(true);
        break;
    default
            :
        ui->parallel->setChecked(true);
    }
}

dcm::SolutionSpace TaskAssemblyConstraints::getSolutionSpace()
{
    if(ui->bidirectional->isChecked())
        return dcm::bidirectional;
    if(ui->pos_direction->isChecked())
        return dcm::positiv_directional;

    return dcm::negative_directional;
}

void TaskAssemblyConstraints::setSolutionSpace(dcm::SolutionSpace d)
{
    switch(d) {
    case dcm::bidirectional:
        ui->bidirectional->setChecked(true);
        break;
    case dcm::positiv_directional:
        ui->pos_direction->setChecked(true);
        break;
    default
            :
        ui->neg_direction->setChecked(true);
    }
}


TaskAssemblyConstraints::~TaskAssemblyConstraints()
{
    delete ui;
}

void TaskAssemblyConstraints::onSelectionChanged(const Gui::SelectionChanges& msg)
{
    if(msg.Type == Gui::SelectionChanges::AddSelection) {

        //add it as the first geometry?
        if(ui->first_geom->text().isEmpty()) {
            std::vector<Gui::SelectionObject> objs = Gui::Selection().getSelectionEx();
            Assembly::Constraint* con =  dynamic_cast<Assembly::Constraint*>(view->getObject());

            if(!ActiveAsmObject || !ActiveAsmObject->getTypeId().isDerivedFrom(Assembly::ItemAssembly::getClassTypeId())) {
                QMessageBox::warning(Gui::getMainWindow(), QObject::tr("No active Assembly"),
                                     QObject::tr("You need a active (blue) Assembly to insert a Constraint. Please create a new one or make one active (double click)."));
                return;
            }

            std::pair<Assembly::ItemPart*, Assembly::ItemAssembly*> part1 = static_cast<Assembly::ItemAssembly*>(ActiveAsmObject)->getContainingPart(objs.back().getObject());
            con->First.setValue(part1.first, objs.back().getSubNames());
            QString str;
            str = QString::fromAscii(part1.first->getNameInDocument()) + QString::fromAscii(".") + QString::fromStdString(con->First.getSubValues().front());
            ui->first_geom->setText(str);

            App::GetApplication().getActiveDocument()->recompute();
            setPossibleConstraints();
            setPossibleOptions();
            view->draw();
            return;
        }

        if(ui->second_geom->text().isEmpty()) {
            std::vector<Gui::SelectionObject> objs = Gui::Selection().getSelectionEx();
            Assembly::Constraint* con =  dynamic_cast<Assembly::Constraint*>(view->getObject());

            if(!ActiveAsmObject || !ActiveAsmObject->getTypeId().isDerivedFrom(Assembly::ItemAssembly::getClassTypeId())) {
                QMessageBox::warning(Gui::getMainWindow(), QObject::tr("No active Assembly"),
                                     QObject::tr("You need a active (blue) Assembly to insert a Constraint. Please create a new one or make one active (double click)."));
                return;
            }

            std::pair<Assembly::ItemPart*, Assembly::ItemAssembly*> part2 = static_cast<Assembly::ItemAssembly*>(ActiveAsmObject)->getContainingPart(objs.back().getObject());
            con->Second.setValue(part2.first, objs.back().getSubNames());
            QString str;
            str = QString::fromAscii(part2.first->getNameInDocument()) + QString::fromAscii(".") + QString::fromStdString(con->Second.getSubValues().front());
            ui->second_geom->setText(str);

            App::GetApplication().getActiveDocument()->recompute();
            setPossibleConstraints();
            setPossibleOptions();
            view->draw();
            return;
        }
    };
}

void TaskAssemblyConstraints::on_constraint_selection(bool clicked)
{
    if(clicked) {
        Assembly::Constraint* obj =  dynamic_cast<Assembly::Constraint*>(view->getObject());

        if(ui->fix->isChecked())
            obj->Type.setValue("Fix");

        if(ui->distance->isChecked())
            obj->Type.setValue("Distance");

        if(ui->orientation->isChecked())
            obj->Type.setValue("Orientation");

        if(ui->angle->isChecked())
            obj->Type.setValue("Angle");

        if(ui->align->isChecked())
            obj->Type.setValue("Align");

        if(ui->coincident->isChecked())
            obj->Type.setValue("Coincident");

        App::GetApplication().getActiveDocument()->recompute();
        view->draw();
    }
    setPossibleOptions();

}

void TaskAssemblyConstraints::on_orientation_selection(bool clicked)
{
    if(clicked) {
        Assembly::Constraint* obj =  dynamic_cast<Assembly::Constraint*>(view->getObject());
        obj->Orientation.setValue(getOrientation());

        App::GetApplication().getActiveDocument()->recompute();
        view->draw();
    }
}

void TaskAssemblyConstraints::on_solutionspace_selection(bool clicked)
{
    if(clicked) {
        Assembly::Constraint* obj =  dynamic_cast<Assembly::Constraint*>(view->getObject());
        obj->SolutionSpace.setValue(getSolutionSpace());

        App::GetApplication().getActiveDocument()->recompute();
        view->draw();
    }
}

void TaskAssemblyConstraints::on_value_change(double val)
{

    Assembly::Constraint* obj =  dynamic_cast<Assembly::Constraint*>(view->getObject());
    obj->Value.setValue(ui->value->value());

    App::GetApplication().getActiveDocument()->recompute();
    view->draw();
}

void TaskAssemblyConstraints::on_clear_first()
{
    Assembly::Constraint* obj =  dynamic_cast<Assembly::Constraint*>(view->getObject());
    obj->First.setValue(NULL);
    ui->first_geom->clear();
    setPossibleConstraints();
    setPossibleOptions();
    view->draw();
}

void TaskAssemblyConstraints::on_clear_second()
{

    Assembly::Constraint* obj =  dynamic_cast<Assembly::Constraint*>(view->getObject());
    obj->Second.setValue(NULL);
    ui->second_geom->clear();
    setPossibleConstraints();
    setPossibleOptions();
    view->draw();
}

void TaskAssemblyConstraints::setPossibleOptions() {

    //disable all orientations for later easy disabling
    ui->parallel->setEnabled(false);
    ui->equal->setEnabled(false);
    ui->opposite->setEnabled(false);
    ui->perpendicular->setEnabled(false);

    //disable solution spaces for later easy enabling
    ui->bidirectional->setEnabled(false);
    ui->pos_direction->setEnabled(false);
    ui->neg_direction->setEnabled(false);

    //this only works if both objects are set
    Assembly::Constraint* obj =  dynamic_cast<Assembly::Constraint*>(view->getObject());
    if(obj->First.getValue()) {

        Assembly::ItemPart* p1 = dynamic_cast<Assembly::ItemPart*>(obj->First.getValue());
        if(!p1)
            return;

        Assembly::ItemAssembly* ass = p1->getParentAssembly();

        //extract the geometries to use for comparison
        boost::shared_ptr<Geometry3D> g1 = ass->m_solver->getGeometry3D(obj->First.getSubValues()[0].c_str());
        if(obj->Second.getValue()) {

            Assembly::ItemPart* p2 = dynamic_cast<Assembly::ItemPart*>(obj->Second.getValue());
            if(!p2)
                return;
            boost::shared_ptr<Geometry3D> g2 = ass->m_solver->getGeometry3D(obj->Second.getSubValues()[0].c_str());

            //distance
            if(obj->Type.getValue() == 1) {

                if(isCombination(g1,g2, dcm::geometry::point, dcm::geometry::plane) ||
                        isCombination(g1,g2, dcm::geometry::point, dcm::geometry::cylinder)) {
                    ui->bidirectional->setEnabled(true);
                    ui->pos_direction->setEnabled(true);
                    ui->neg_direction->setEnabled(true);
                };
            };
            //align & coincident
            if(obj->Type.getValue() == 4 || obj->Type.getValue() == 5) {

                if(isCombination(g1,g2, dcm::geometry::point, dcm::geometry::plane) ||
                        isCombination(g1,g2, dcm::geometry::point, dcm::geometry::cylinder) ||
                        isCombination(g1,g2, dcm::geometry::line, dcm::geometry::plane) ||
                        isCombination(g1,g2, dcm::geometry::line, dcm::geometry::cylinder)  ||
                        isCombination(g1,g2, dcm::geometry::plane, dcm::geometry::plane) ||
                        isCombination(g1,g2, dcm::geometry::plane, dcm::geometry::cylinder)) {
                    ui->bidirectional->setEnabled(true);
                    ui->pos_direction->setEnabled(true);
                    ui->neg_direction->setEnabled(true);
                };

                if(isCombination(g1,g2, dcm::geometry::line, dcm::geometry::cylinder)  ||
                        isCombination(g1,g2, dcm::geometry::plane, dcm::geometry::plane) ||
                        isCombination(g1,g2, dcm::geometry::line, dcm::geometry::cylinder) ||
                        isCombination(g1,g2, dcm::geometry::cylinder, dcm::geometry::cylinder)) {
                    ui->parallel->setEnabled(true);
                    ui->equal->setEnabled(true);
                    ui->opposite->setEnabled(true);

                    //ensure that perpendicular is not checked
                    if(ui->perpendicular->isChecked()) {
                        ui->parallel->setChecked(true);
                        obj->Orientation.setValue((long)0);
                    }
                };

                if(isCombination(g1,g2, dcm::geometry::line, dcm::geometry::plane)  ||
                        isCombination(g1,g2, dcm::geometry::plane, dcm::geometry::cylinder)) {
                    ui->perpendicular->setEnabled(true);

                    //ensure that perpendicular is checked
                    if(!ui->perpendicular->isChecked()) {
                        ui->perpendicular->setChecked(true);
                        obj->Orientation.setValue((long)3);
                    }
                };
            };

            //orientation
            if(obj->Type.getValue() == 2) {
                ui->parallel->setEnabled(true);
                ui->equal->setEnabled(true);
                ui->opposite->setEnabled(true);
                ui->perpendicular->setEnabled(true);
            }

        }
    }
};

void TaskAssemblyConstraints::setPossibleConstraints()
{
    //diasble all constraints for easyer enabling
    ui->fix->setEnabled(false);
    ui->distance->setEnabled(false);
    ui->orientation->setEnabled(false);
    ui->angle->setEnabled(false);
    ui->align->setEnabled(false);
    ui->coincident->setEnabled(false);

    Assembly::Constraint* obj =  dynamic_cast<Assembly::Constraint*>(view->getObject());
    if(obj->First.getValue()) {

        Assembly::ItemPart* p1 = dynamic_cast<Assembly::ItemPart*>(obj->First.getValue());

        if(!p1)
            return;

        Assembly::ItemAssembly* ass = p1->getParentAssembly();

        //extract the geometries to use for comparison
        boost::shared_ptr<Geometry3D> g1 = ass->m_solver->getGeometry3D(obj->First.getSubValues()[0].c_str());
        if(obj->Second.getValue()) {
            Assembly::ItemPart* p2 = dynamic_cast<Assembly::ItemPart*>(obj->Second.getValue());
            if(!p2)
                return;

            boost::shared_ptr<Geometry3D> g2 = ass->m_solver->getGeometry3D(obj->Second.getSubValues()[0].c_str());

            //check all valid combinaions
            if(isCombination(g1,g2, dcm::geometry::point, dcm::geometry::point)) {
                ui->distance->setEnabled(true);
                ui->coincident->setEnabled(true);
            };
            if(isCombination(g1,g2, dcm::geometry::point, dcm::geometry::line)) {
                ui->distance->setEnabled(true);
                ui->coincident->setEnabled(true);
            };
            if(isCombination(g1,g2, dcm::geometry::point, dcm::geometry::plane)) {
                ui->distance->setEnabled(true);
                ui->coincident->setEnabled(true);
            };
            if(isCombination(g1,g2, dcm::geometry::point, dcm::geometry::cylinder)) {
                ui->distance->setEnabled(true);
                ui->coincident->setEnabled(true);
            };
            if(isCombination(g1,g2, dcm::geometry::line, dcm::geometry::line)) {
                ui->distance->setEnabled(true);
                ui->orientation->setEnabled(true);
                ui->angle->setEnabled(true);
                ui->coincident->setEnabled(true);
                ui->align->setEnabled(true);
            };
            if(isCombination(g1,g2, dcm::geometry::line, dcm::geometry::plane)) {
                ui->orientation->setEnabled(true);
                ui->angle->setEnabled(true);
                ui->coincident->setEnabled(true);
                ui->align->setEnabled(true);
            };
            if(isCombination(g1,g2, dcm::geometry::line, dcm::geometry::cylinder)) {
                ui->distance->setEnabled(true);
                ui->orientation->setEnabled(true);
                ui->angle->setEnabled(true);
                ui->coincident->setEnabled(true);
                ui->align->setEnabled(true);
            };
            if(isCombination(g1,g2, dcm::geometry::plane, dcm::geometry::plane)) {
                ui->orientation->setEnabled(true);
                ui->angle->setEnabled(true);
                ui->coincident->setEnabled(true);
                ui->align->setEnabled(true);
            };
            if(isCombination(g1,g2, dcm::geometry::plane, dcm::geometry::cylinder)) {
                ui->orientation->setEnabled(true);
                ui->angle->setEnabled(true);
                ui->align->setEnabled(true);
            };
            if(isCombination(g1,g2, dcm::geometry::cylinder, dcm::geometry::cylinder)) {
                ui->coincident->setEnabled(true);
                ui->orientation->setEnabled(true);
                ui->angle->setEnabled(true);
            };
        }
        else {
            //only fix works
            ui->fix->setEnabled(true);
        };
    }
}

bool TaskAssemblyConstraints::isCombination(boost::shared_ptr<Geometry3D> g1, boost::shared_ptr<Geometry3D> g2, dcm::geometry::types t1, dcm::geometry::types t2)
{
    if(g1->getGeometryType() == t1 && g2->getGeometryType() == t2)
        return true;

    if(g1->getGeometryType() == t2 && g2->getGeometryType() == t1)
        return true;

    return false;
}




#include "moc_TaskAssemblyConstraints.cpp"