/***************************************************************************
 *   Copyright (c) 2014 Joe Dowsett <dowsettjoe[at]yahoo[dot]co[dot]uk>    *
 *   Copyright (c) 2014 Luke Parry <l.parry@warwick.ac.uk>                 *
 *                                                                         *
 *   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>
# include <QGroupBox>
# include <QLabel>
# include <QScreen>
#endif // #ifndef _PreComp_

#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QPushButton>
#include <QDialog>

#include <App/Document.h>
#include <Base/Console.h>
#include <Base/Tools.h>
#include <Gui/Application.h>
#include <Gui/BitmapFactory.h>
#include <Gui/Command.h>
#include <Gui/Document.h>
#include <Gui/WaitCursor.h>
#include <Gui/QuantitySpinBox.h>

#include <Mod/TechDraw/App/DrawPage.h>
#include <Mod/TechDraw/App/DrawView.h>
#include <Mod/TechDraw/App/DrawViewPart.h>
#include <Mod/TechDraw/App/DrawProjGroup.h>
#include <Mod/TechDraw/App/DrawProjGroupItem.h>
#include <Mod/TechDraw/App/DrawUtil.h>
#include <Mod/TechDraw/App/Preferences.h>

#include "DrawGuiUtil.h"
#include "TaskProjGroup.h"
#include "ui_TaskProjGroup.h"
#include "MDIViewPage.h"
#include "ViewProviderPage.h"
#include "ViewProviderDrawingView.h"
#include "ViewProviderProjGroupItem.h"


using namespace Gui;
using namespace TechDraw;
using namespace TechDrawGui;

TaskProjGroup::TaskProjGroup(TechDraw::DrawView* featView, bool mode) :
    ui(new Ui_TaskProjGroup),
    view(featView),
    multiView(dynamic_cast<TechDraw::DrawProjGroup*>(view)),
    m_createMode(mode),
    blockCheckboxes(false)
{
    ui->setupUi(this);

    m_page = view->findParentPage();
    Gui::Document* activeGui = Gui::Application::Instance->getDocument(m_page->getDocument());
    Gui::ViewProvider* vp = activeGui->getViewProvider(m_page);
    auto* dvp = static_cast<ViewProviderPage*>(vp);
    m_mdi = dvp->getMDIViewPage();

    connectWidgets();
    initializeUi();
    setUiPrimary();
    updateUi();

    saveGroupState();

    blockUpdate = false;
}

void TaskProjGroup::connectWidgets()
{
    // Rotation buttons
    connect(ui->butTopRotate,   &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
    connect(ui->butCWRotate,    &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
    connect(ui->butRightRotate, &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
    connect(ui->butDownRotate,  &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
    connect(ui->butLeftRotate,  &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
    connect(ui->butCCWRotate,   &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
    connect(ui->butFront,       &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
    connect(ui->butCam,         &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);

    connect(ui->lePrimary,   &QPushButton::clicked, this, &TaskProjGroup::customDirectionClicked);

    // Slot for Scale Type
    connect(ui->cmbScaleType, qOverload<int>(&QComboBox::currentIndexChanged), this, &TaskProjGroup::scaleTypeChanged);
    connect(ui->sbScaleNum,   qOverload<int>(&QSpinBox::valueChanged), this, &TaskProjGroup::scaleManuallyChanged);
    connect(ui->sbScaleDen,   qOverload<int>(&QSpinBox::valueChanged), this, &TaskProjGroup::scaleManuallyChanged);

    // Slot for Projection Type (layout)
#if QT_VERSION < QT_VERSION_CHECK(5,15,0)
    connect(ui->projection, qOverload<const QString&>(&QComboBox::currentIndexChanged), this, &TaskProjGroup::projectionTypeChanged);
#else
    connect(ui->projection, qOverload<int>(&QComboBox::currentIndexChanged), this, [this](int index) {
        projectionTypeChanged(ui->projection->itemText(index));
    });
#endif

    // Spacing
    connect(ui->cbAutoDistribute, &QPushButton::clicked, this, &TaskProjGroup::AutoDistributeClicked);
    connect(ui->sbXSpacing, qOverload<double>(&QuantitySpinBox::valueChanged), this, &TaskProjGroup::spacingChanged);
    connect(ui->sbYSpacing, qOverload<double>(&QuantitySpinBox::valueChanged), this, &TaskProjGroup::spacingChanged);
}

void TaskProjGroup::initializeUi()
{
    if (!view) {
        return;
    }

    if (multiView) {
        // we have a projection group as input
        ui->projection->setCurrentIndex(multiView->ProjectionType.getValue());
        ui->cbAutoDistribute->setChecked(multiView->AutoDistribute.getValue());
        // disable if no AutoDistribute
        ui->sbXSpacing->setEnabled(multiView->AutoDistribute.getValue());
        ui->sbYSpacing->setEnabled(multiView->AutoDistribute.getValue());
        ui->sbXSpacing->setValue(multiView->spacingX.getValue());
        ui->sbYSpacing->setValue(multiView->spacingY.getValue());
    } else {
        ui->projection->setCurrentIndex(Preferences::projectionAngle());
        ui->cbAutoDistribute->setChecked(Preferences::groupAutoDistribute());
        ui->sbXSpacing->setValue(Preferences::groupSpaceX());
        ui->sbYSpacing->setValue(Preferences::groupSpaceY());
    }

    setFractionalScale(view->getScale());
    ui->cmbScaleType->setCurrentIndex(view->ScaleType.getValue());

    //Allow or prevent scale changing initially
    if (view->ScaleType.isValue("Custom"))	{
        ui->sbScaleNum->setEnabled(true);
        ui->sbScaleDen->setEnabled(true);
    }
    else {
        ui->sbScaleNum->setEnabled(false);
        ui->sbScaleDen->setEnabled(false);
    }

    // Initially toggle view checkboxes if needed
    setupViewCheckboxes(true);

    ui->sbXSpacing->setUnit(Base::Unit::Length);
    ui->sbYSpacing->setUnit(Base::Unit::Length);

    if (Preferences::useCameraDirection()) {
        ui->butCam->setChecked(true);
    } else {
        ui->butFront->setChecked(true);
    }

}


//! enable/disable the appropriate widgets
void TaskProjGroup::updateUi()
{
    if (multiView) {
        setWindowTitle(QObject::tr("Projection Group"));
        ui->projection->show();
        ui->cbAutoDistribute->show();
        ui->sbXSpacing->show();
        ui->sbYSpacing->show();
        ui->label_7->show();
        ui->label_10->show();
        ui->label_11->show();
    }
    else {
        setWindowTitle(QObject::tr("Part View"));
        ui->projection->hide();
        ui->cbAutoDistribute->hide();
        ui->sbXSpacing->hide();
        ui->sbYSpacing->hide();
        ui->label_7->hide();
        ui->label_10->hide();
        ui->label_11->hide();

        // if the view is not a proj group item, then we disable secondary projs.
        auto* dpgi = dynamic_cast<TechDraw::DrawProjGroupItem*>(view);
        if (!dpgi) {
            ui->secondaryProjGroupbox->hide();
        }
    }
}

void TaskProjGroup::saveGroupState()
{
    if (!view) {
        return;
    }

    m_saveScaleType = view->ScaleType.getValueAsString();
    m_saveScale = view->Scale.getValue();

    if (multiView) {
        m_saveSource = multiView->Source.getValues();
        m_saveProjType = multiView->ProjectionType.getValueAsString();
        m_saveAutoDistribute = multiView->AutoDistribute.getValue();
        m_saveSpacingX = multiView->spacingX.getValue();
        m_saveSpacingY = multiView->spacingY.getValue();
        DrawProjGroupItem* anchor = multiView->getAnchor();
        m_saveDirection = anchor->Direction.getValue();

        for( const auto it : multiView->Views.getValues() ) {
            auto view( dynamic_cast<DrawProjGroupItem *>(it) );
            if (view) {
                m_saveViewNames.emplace_back(view->Type.getValueAsString());
            }
        }
    }
}

//never used?
void TaskProjGroup::restoreGroupState()
{
    if (!view) {
        return;
    }

    view->ScaleType.setValue(m_saveScaleType.c_str());
    view->Scale.setValue(m_saveScale);

    if (multiView) {
        multiView->ProjectionType.setValue(m_saveProjType.c_str());
        multiView->AutoDistribute.setValue(m_saveAutoDistribute);
        multiView->spacingX.setValue(m_saveSpacingX);
        multiView->spacingY.setValue(m_saveSpacingY);
        multiView->purgeProjections();
        for(auto & sv : m_saveViewNames) {
            if (sv != "Front") {
                multiView->addProjection(sv.c_str());
            }
        }
    }
}

void TaskProjGroup::viewToggled(bool toggle)
{
    Gui::WaitCursor wc;
    bool changed = false;
    // Obtain name of checkbox
    int index = sender()->objectName().mid(7).toInt();
    const char *viewNameCStr = viewChkIndexToCStr(index);

    if (!blockCheckboxes) {
        if (multiView) {
            // Check if only front is left. If so switch to normal view.
            if (multiView->Views.getValues().size() == 2 && !toggle) {
                turnProjGroupToView();
                wc.restoreCursor();
                return;
            }
        }
        else {
            // If toggle then we remove the view object and create a proj group instead.
            turnViewToProjGroup();
        }
    }

    if (toggle && !multiView->hasProjection(viewNameCStr)) {
        Gui::Command::doCommand(Gui::Command::Doc,
                                "App.activeDocument().%s.addProjection('%s')",
                                multiView->getNameInDocument(), viewNameCStr);
        changed = true;
    }
    else if (!toggle && multiView->hasProjection(viewNameCStr)) {
        if (multiView->canDelete(viewNameCStr)) {
            multiView->removeProjection( viewNameCStr );
            changed = true;
        }
    }

    if (changed) {
        if (view->ScaleType.isValue("Automatic")) {
            double scale = view->getScale();
            setFractionalScale(scale);
        }
        view->recomputeFeature();
    }
    wc.restoreCursor();
}


void TaskProjGroup::turnViewToProjGroup()
{
    App::Document* doc = view->getDocument();

    std::string multiViewName = doc->getUniqueObjectName("ProjGroup");
    Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().addObject('TechDraw::DrawProjGroup', '%s')", multiViewName.c_str());
    Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().%s.addView(App.activeDocument().%s)", view->findParentPage()->getNameInDocument(), multiViewName.c_str());

    auto* viewPart = static_cast<TechDraw::DrawViewPart*>(view);
    m_page->removeView(viewPart);

    multiView = static_cast<TechDraw::DrawProjGroup*>(doc->getObject(multiViewName.c_str()));
    multiView->Source.setValues(viewPart->Source.getValues());
    multiView->XSource.setValues(viewPart->XSource.getValues());
    multiView->X.setValue(viewPart->X.getValue());
    multiView->Y.setValue(viewPart->Y.getValue());
    multiView->Scale.setValue(viewPart->Scale.getValue());
    multiView->ScaleType.setValue(viewPart->ScaleType.getValue());
    multiView->ProjectionType.setValue(Preferences::projectionAngle());
    viewPart->X.setValue(0.0);
    viewPart->Y.setValue(0.0);
    viewPart->ScaleType.setValue("Custom");
    viewPart->ScaleType.setStatus(App::Property::Hidden, true);
    viewPart->Scale.setStatus(App::Property::Hidden, true);
    viewPart->Label.setValue("Front");

    multiView->addView(viewPart);
    multiView->Anchor.setValue(view);
    multiView->Anchor.purgeTouched();

    viewPart->LockPosition.setValue(true);
    viewPart->LockPosition.setStatus(App::Property::ReadOnly, true); //Front should stay locked.
    viewPart->LockPosition.purgeTouched();

    m_page->requestPaint();
    view = multiView;

    updateUi();
}

void TaskProjGroup::turnProjGroupToView()
{
    TechDraw::DrawViewPart* viewPart = multiView->getAnchor();
    viewPart->Scale.setValue(multiView->Scale.getValue());
    viewPart->ScaleType.setValue(multiView->ScaleType.getValue());
    viewPart->Scale.setStatus(App::Property::Hidden, false);
    viewPart->ScaleType.setStatus(App::Property::Hidden, false);
    viewPart->Label.setValue("View");
    viewPart->LockPosition.setValue(false);
    viewPart->LockPosition.setStatus(App::Property::ReadOnly, false);
    viewPart->X.setValue(multiView->X.getValue());
    viewPart->Y.setValue(multiView->Y.getValue());
    m_page->addView(viewPart);

    // remove viewPart from views before deleting the group.
    multiView->removeView(viewPart);

    Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().removeObject('%s')", multiView->getNameInDocument());

    Gui::Document* activeGui = Gui::Application::Instance->getDocument(m_page->getDocument());
    auto* vp = static_cast<ViewProviderProjGroupItem*>(activeGui->getViewProvider(viewPart));
    if (vp) {
        vp->updateIcon();
    }
    viewPart->recomputeFeature();

    view = viewPart;
    multiView = nullptr;

    updateUi();
}

void TaskProjGroup::customDirectionClicked()
{
    auto* dirEditDlg = new DirectionEditDialog();

    if (multiView) {
        dirEditDlg->setDirection(multiView->getAnchor()->Direction.getValue());
        dirEditDlg->setAngle(0.0);
    }
    else {
        auto* viewPart = static_cast<TechDraw::DrawViewPart*>(view);
        dirEditDlg->setDirection(viewPart->Direction.getValue());
        dirEditDlg->setAngle(0.0);
    }

    if (dirEditDlg->exec() == QDialog::Accepted) {
        if (multiView) {
            multiView->getAnchor()->Direction.setValue(dirEditDlg->getDirection());
            multiView->spin(Base::toRadians(dirEditDlg->getAngle()));
        }
        else {
            auto* viewPart = static_cast<TechDraw::DrawViewPart*>(view);
            viewPart->Direction.setValue(dirEditDlg->getDirection());
            viewPart->spin(Base::toRadians(dirEditDlg->getAngle()));
        }

        setUiPrimary();
    }


    delete dirEditDlg;
}

void TaskProjGroup::rotateButtonClicked()
{
    if ( view && ui ) {
        const QObject *clicked = sender();

        auto handleCameraButton = [&]() {
            std::string faceName;
            App::DocumentObject* obj = nullptr;
            auto selection = Gui::Command::getSelection().getSelectionEx();
            for (auto& sel : selection) {
                for (auto& sub : sel.getSubNames()) {
                    if (TechDraw::DrawUtil::getGeomTypeFromName(sub) == "Face") {
                        obj = sel.getObject();
                        faceName = sub;
                        break;
                    }
                }
                if (!faceName.empty()) {
                    break;
                }
            }

            std::pair<Base::Vector3d, Base::Vector3d> dirs = !faceName.empty() ?
                DrawGuiUtil::getProjDirFromFace(obj, faceName)
                : DrawGuiUtil::get3DDirAndRot();
            return dirs;
        };

        if (multiView) {
            //change Front View Dir by 90
            if (clicked == ui->butTopRotate) multiView->rotate("Up");
            else if (clicked == ui->butDownRotate) multiView->rotate("Down");
            else if (clicked == ui->butRightRotate) multiView->rotate("Right");
            else if (clicked == ui->butLeftRotate) multiView->rotate("Left");
            else if (clicked == ui->butCWRotate) multiView->spin("CW");
            else if (clicked == ui->butCCWRotate) multiView->spin("CCW");
            else if (clicked == ui->butFront) {
                multiView->getAnchor()->Direction.setValue(Base::Vector3d(0.0, -1.0, 0.0));
                multiView->getAnchor()->RotationVector.setValue(Base::Vector3d(1.0, 0.0, 0.0));
                multiView->getAnchor()->XDirection.setValue(Base::Vector3d(1.0, 0.0, 0.0));
                multiView->updateSecondaryDirs();
            }
            else if (clicked == ui->butCam) {
                std::pair<Base::Vector3d, Base::Vector3d> dirs = handleCameraButton();
                multiView->getAnchor()->Direction.setValue(dirs.first);
                multiView->getAnchor()->RotationVector.setValue(dirs.second);
                multiView->getAnchor()->XDirection.setValue(dirs.second);
                multiView->updateSecondaryDirs();
            }
        }
        else {
            auto* viewPart = static_cast<TechDraw::DrawViewPart*>(view);
            if (clicked == ui->butTopRotate) viewPart->rotate("Up");
            else if (clicked == ui->butDownRotate) viewPart->rotate("Down");
            else if (clicked == ui->butRightRotate) viewPart->rotate("Right");
            else if (clicked == ui->butLeftRotate) viewPart->rotate("Left");
            else if (clicked == ui->butCWRotate) viewPart->spin("CW");
            else if (clicked == ui->butCCWRotate) viewPart->spin("CCW");
            else if (clicked == ui->butFront) {
                viewPart->Direction.setValue(Base::Vector3d(0.0,-1.0,0.0));
                viewPart->XDirection.setValue(Base::Vector3d(1.0, 0.0, 0.0));
                viewPart->recomputeFeature();
            }
            else if (clicked == ui->butCam) {
                std::pair<Base::Vector3d, Base::Vector3d> dirs = handleCameraButton();

                viewPart->Direction.setValue(dirs.first);
                viewPart->XDirection.setValue(dirs.second);
                viewPart->recomputeFeature();
            }
        }

        setUiPrimary();
    }
}

//void TaskProjGroup::projectionTypeChanged(int index)
void TaskProjGroup::projectionTypeChanged(QString qText)
{
    if(blockUpdate || !multiView) {
        return;
    }

    if (qText == QString::fromUtf8("Page")) {
        multiView->ProjectionType.setValue("Default");
    }
    else {
        std::string text = qText.toStdString();
        multiView->ProjectionType.setValue(text.c_str());
    }

    // Update checkboxes so checked state matches the drawing
    blockCheckboxes = true;
    setupViewCheckboxes();
    blockCheckboxes = false;

    // set the tooltips of the checkboxes
    ui->chkView0->setToolTip(getToolTipForBox(0));
    ui->chkView1->setToolTip(getToolTipForBox(1));
    ui->chkView2->setToolTip(getToolTipForBox(2));
    ui->chkView3->setToolTip(getToolTipForBox(3));
    ui->chkView4->setToolTip(getToolTipForBox(4));
    ui->chkView5->setToolTip(getToolTipForBox(5));
    ui->chkView6->setToolTip(getToolTipForBox(6));
    ui->chkView7->setToolTip(getToolTipForBox(7));
    ui->chkView8->setToolTip(getToolTipForBox(8));
    ui->chkView9->setToolTip(getToolTipForBox(9));

    // R/L and T/B view need to be repositioned and just recomputing a single view will not do this
    multiView->recomputeChildren();
}

void TaskProjGroup::scaleTypeChanged(int index)
{
    if (blockUpdate) {
        return;
    }

    //defaults to prevent scale changing
    ui->sbScaleNum->setEnabled(false);
    ui->sbScaleDen->setEnabled(false);

    if (index == 0) {
        // Document Scale Type
        view->ScaleType.setValue("Page");
    }
    else if (index == 1) {
        // Automatic Scale Type
        //block recompute
        view->ScaleType.setValue("Automatic");
        double autoScale = view->autoScale();
        view->Scale.setValue(autoScale);
        //unblock recompute

    }
    else if (index == 2) {
        // Custom Scale Type
        //block recompute
        view->ScaleType.setValue("Custom");
        ui->sbScaleNum->setEnabled(true);
        ui->sbScaleDen->setEnabled(true);

        int numerator = ui->sbScaleNum->value();
        int denominator = ui->sbScaleDen->value();
        double scale = (double) numerator / (double) denominator;
        view->Scale.setValue(scale);
        //unblock recompute
    }
}

void TaskProjGroup::AutoDistributeClicked(bool clicked)
{
    if (blockUpdate || !multiView) {
        return;
    }
    multiView->AutoDistribute.setValue(clicked);
    multiView->recomputeFeature();
}

void TaskProjGroup::spacingChanged()
{
    if (blockUpdate || !multiView) {
        return;
    }
    multiView->spacingX.setValue(ui->sbXSpacing->value().getValue());
    multiView->spacingY.setValue(ui->sbYSpacing->value().getValue());
    multiView->recomputeFeature();
}

void TaskProjGroup::updateTask()
{
    // Update the scale type
    blockUpdate = true;
    ui->cmbScaleType->setCurrentIndex(view->ScaleType.getValue());

    // Update the scale value
    setFractionalScale(view->getScale());

    blockUpdate = false;
}


void TaskProjGroup::setFractionalScale(double newScale)
{
    blockUpdate = true;

    std::pair<int, int> fraction = DrawUtil::nearestFraction(newScale);

    ui->sbScaleNum->setValue(fraction.first);
    ui->sbScaleDen->setValue(fraction.second);
    blockUpdate = false;
}

void TaskProjGroup::scaleManuallyChanged(int unused)
{
    Q_UNUSED(unused);
    if(blockUpdate) {
        return;
    }
    if (!view->ScaleType.isValue("Custom")) {  //ignore if not custom!
        return;
    }

    int numerator = ui->sbScaleNum->value();
    int denominator = ui->sbScaleDen->value();

    double scale = (double) numerator / (double) denominator;

    Gui::Command::doCommand(Gui::Command::Doc, "App.activeDocument().%s.Scale = %f", view->getNameInDocument()
                                                                                     , scale);
    view->recomputeFeature();
}

void TaskProjGroup::changeEvent(QEvent *event)
{
    if (event->type() == QEvent::LanguageChange) {
        ui->retranslateUi(this);
    }
}

const char * TaskProjGroup::viewChkIndexToCStr(int index)
{
    //   Third Angle:  FTL  T  FTRight
    //                  L   F   Right   Rear
    //                 FBL  B  FBRight
    //
    //   First Angle:  FBRight  B  FBL
    //                  Right   F   L  Rear
    //                 FTRight  T  FTL

    bool thirdAngle = useThirdAngle();
    switch(index) {
        case 0: return (thirdAngle ? "FrontTopLeft" : "FrontBottomRight");
        case 1: return (thirdAngle ? "Top" : "Bottom");
        case 2: return (thirdAngle ? "FrontTopRight" : "FrontBottomLeft");
        case 3: return (thirdAngle ? "Left" : "Right");
        case 4: return "Front";
        case 5: return (thirdAngle ? "Right" : "Left");
        case 6: return "Rear";
        case 7: return (thirdAngle ? "FrontBottomLeft" : "FrontTopRight");
        case 8: return (thirdAngle ? "Bottom" : "Top");
        case 9: return (thirdAngle ? "FrontBottomRight" : "FrontTopLeft");
        default: return nullptr;
    }
}

QString TaskProjGroup::getToolTipForBox(int boxNumber)
{
    bool thirdAngle = useThirdAngle();
    switch(boxNumber) {
        case 0: {return (thirdAngle ? tr("FrontTopLeft") : tr("FrontBottomRight")); break;}
        case 1: {return (thirdAngle ? tr("Top") : tr("Bottom")); break;}
        case 2: {return (thirdAngle ? tr("FrontTopRight") : tr("FrontBottomLeft")); break;}
        case 3: {return (thirdAngle ? tr("Left" ): tr("Right")); break;}
        case 4: {return tr("Front"); break; }
        case 5: {return (thirdAngle ? tr("Right") : tr("Left")); break;}
        case 6: {return tr("Rear"); break; }
        case 7: {return (thirdAngle ? tr("FrontBottomLeft") : tr("FrontTopRight")); break;}
        case 8: {return (thirdAngle ? tr("Bottom") : tr("Top")); break;}
        case 9: {return (thirdAngle ? tr("FrontBottomRight") : tr("FrontTopLeft")); break;}
        default: {return {}; break;}
    }
}

bool TaskProjGroup::useThirdAngle()
{
    if (!view) {
        // something is wrong if this happens
        throw Base::RuntimeError("TaskProjGroup - no view!");
    }

    auto page = view->findParentPage();
    if (!page) {
        return false;
    }

    bool thirdAngle = (bool) Preferences::projectionAngle();
    if (!multiView) {
        return thirdAngle;
    }

    if (multiView->usedProjectionType().isValue("Third Angle")) {
        thirdAngle = true;
    } else if (multiView->usedProjectionType().isValue("Default") &&
        page->ProjectionType.isValue("Third Angle")) {
        thirdAngle = true;
    }
    return thirdAngle;
}

void TaskProjGroup::setupViewCheckboxes(bool addConnections)
{
    if (!view) {
        return;
    }

    // There must be a better way to construct this list...
    QCheckBox * viewCheckboxes[] = { ui->chkView0,
                                     ui->chkView1,
                                     ui->chkView2,
                                     ui->chkView3,
                                     ui->chkView4,
                                     ui->chkView5,
                                     ui->chkView6,
                                     ui->chkView7,
                                     ui->chkView8,
                                     ui->chkView9 };

    for (int i = 0; i < 10; ++i) {
        QCheckBox *box = viewCheckboxes[i];
        box->setToolTip(getToolTipForBox(i));
        const char *viewStr = viewChkIndexToCStr(i);

        if (!multiView) {
            box->setCheckState(strcmp(viewStr, "Front") == 0 ? Qt::Checked : Qt::Unchecked);
        }

        if (addConnections) {
            connect(box, &QCheckBox::toggled, this, &TaskProjGroup::viewToggled);
        }

        if (multiView) {
            if (viewStr && multiView->hasProjection(viewStr)) {
                box->setCheckState(Qt::Checked);
                if (!multiView->canDelete(viewStr)) {
                    box->setEnabled(false);
                }
            }
            else {
                box->setCheckState(Qt::Unchecked);
            }
        }
    }
}


//! sets the main direction of the view
// Note: does not set any of the other values that one would expect to be initialized
void TaskProjGroup::setUiPrimary()
{
    Base::Vector3d frontDir;
    if (multiView) {
        frontDir = multiView->getAnchorDirection();
    }
    else {
        auto* viewPart = static_cast<TechDraw::DrawViewPart*>(view);
        if (viewPart) {
            frontDir = viewPart->Direction.getValue();
        }
    }
    ui->lePrimary->setText(formatVector(frontDir));
}

QString TaskProjGroup::formatVector(Base::Vector3d vec)
{
    QString data = QString::fromLatin1("[%1 %2 %3]")
        .arg(QLocale().toString(vec.x, 'f', 2),
             QLocale().toString(vec.y, 'f', 2),
             QLocale().toString(vec.z, 'f', 2));
    return data;
}

void TaskProjGroup::saveButtons(QPushButton* btnOK,
                             QPushButton* btnCancel,
                             QPushButton* btnApply)
{
    m_btnOK = btnOK;
    m_btnCancel = btnCancel;
    m_btnApply = btnApply;
}


bool TaskProjGroup::apply()
{
    if (multiView) {
        multiView->recomputeChildren();
    }
    view->recomputeFeature();

    return true;
}

bool TaskProjGroup::accept()
{
    Gui::Document* doc = Gui::Application::Instance->getDocument(view->getDocument());
    if (!doc) {
        return false;
    }

    if (multiView) {
        multiView->recomputeChildren();
    }
    view->recomputeFeature();

    Gui::Command::doCommand(Gui::Command::Gui, "Gui.ActiveDocument.resetEdit()");

    return true;
}

bool TaskProjGroup::reject()
{
    Gui::Document* doc = Gui::Application::Instance->getDocument(view->getDocument());
    if (!doc) {
        return false;
    }

    if (getCreateMode()) {
        //remove the object completely from the document
        const char* viewName = view->getNameInDocument();
        const char* PageName = view->findParentPage()->getNameInDocument();

        if (multiView) {
            Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().%s.purgeProjections()",
                viewName);
            Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().%s.removeView(App.activeDocument().%s)",
                PageName, viewName);
        }
        Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().removeObject('%s')", viewName);
        Gui::Command::doCommand(Gui::Command::Gui, "Gui.ActiveDocument.resetEdit()");
    }
    else {
        //set the DPG and its views back to entry state.
        if (Gui::Command::hasPendingCommand()) {
            Gui::Command::abortCommand();
        }
    }
    Gui::Command::runCommand(Gui::Command::Gui, "Gui.ActiveDocument.resetEdit()");
    return false;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TODO: Do we really need to hang on to the TaskDlgProjGroup in this class? IR
TaskDlgProjGroup::TaskDlgProjGroup(TechDraw::DrawView* featView, bool mode)
    : viewProvider(nullptr)
    , view(featView)
{
    //viewProvider = dynamic_cast<const ViewProviderDrawingView *>(featView);
    widget  = new TaskProjGroup(featView, mode);
    taskbox = new Gui::TaskView::TaskBox(Gui::BitmapFactory().pixmap("actions/TechDraw_ProjectionGroup"),
                                         widget->windowTitle(), true, nullptr);
    taskbox->groupLayout()->addWidget(widget);
    Content.push_back(taskbox);
}

void TaskDlgProjGroup::update()
{
    widget->updateTask();
}

void TaskDlgProjGroup::setCreateMode(bool mode)
{
    widget->setCreateMode(mode);
}

void TaskDlgProjGroup::modifyStandardButtons(QDialogButtonBox* box)
{
    QPushButton* btnOK = box->button(QDialogButtonBox::Ok);
    QPushButton* btnCancel = box->button(QDialogButtonBox::Cancel);
    QPushButton* btnApply = box->button(QDialogButtonBox::Apply);
    widget->saveButtons(btnOK, btnCancel, btnApply);
}

//==== calls from the TaskView ===============================================================
void TaskDlgProjGroup::open()
{
    if (!widget->getCreateMode())  {    //this is an edit session, start a transaction
        if (dynamic_cast<TechDraw::DrawProjGroup*>(view)) {
            App::GetApplication().setActiveTransaction("Edit Projection Group", true);
        }
        else {
            App::GetApplication().setActiveTransaction("Edit Part View", true);
        }
    }
}

void TaskDlgProjGroup::clicked(int i)
{
//    Q_UNUSED(i);
    if (i == QMessageBox::Apply) {
        widget->apply();
    }
}

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

bool TaskDlgProjGroup::reject()
{
    widget->reject();
    return true;
}


DirectionEditDialog::DirectionEditDialog(QWidget* parent) : QDialog(parent) {
    setWindowFlags(Qt::Popup); // Make the dialog non-intrusive
    createUI();
}

void DirectionEditDialog::setDirection(const Base::Vector3d& pos) {
    xSpinBox->setValue(pos.x);
    ySpinBox->setValue(pos.y);
    zSpinBox->setValue(pos.z);
}

Base::Vector3d DirectionEditDialog::getDirection() const {
    return Base::Vector3d(xSpinBox->value().getValue(), ySpinBox->value().getValue(), zSpinBox->value().getValue());
}

void DirectionEditDialog::setAngle(double val) {
    angleSpinBox->setValue(val);
}

double DirectionEditDialog::getAngle() const {
    return angleSpinBox->value().getValue();
}

void DirectionEditDialog::showEvent(QShowEvent* event) {
    QDialog::showEvent(event);

    // Calculate the position to ensure the dialog appears within the screen boundaries
    QPoint cursorPos = QCursor::pos();
    QSize screenSize = QApplication::primaryScreen()->size(); // Get the size of the primary screen
    int x = cursorPos.x();
    int y = cursorPos.y();
    int dialogWidth = this->width();
    int dialogHeight = this->height();

    // Check if the dialog goes beyond the right edge of the screen
    if (x + dialogWidth > screenSize.width()) {
        x = screenSize.width() - dialogWidth;
    }

    // Check if the dialog goes beyond the bottom edge of the screen
    if (y + dialogHeight > screenSize.height()) {
        y = screenSize.height() - dialogHeight;
    }

    // Move the dialog to the calculated position
    this->move(x, y);
}

void DirectionEditDialog::createUI() {
    auto* directionGroup = new QGroupBox(tr("Direction"));
    auto* directionLayout = new QVBoxLayout; // Use QVBoxLayout for vertical alignment

    // Create layout and widgets for X
    auto* xLayout = new QHBoxLayout;
    auto* xLabel = new QLabel(QStringLiteral("X: "));
    xSpinBox = new Gui::QuantitySpinBox;
    xSpinBox->setUnit(Base::Unit::Length);
    xLayout->addWidget(xLabel);
    xLayout->addWidget(xSpinBox);

    // Create layout and widgets for Y
    auto* yLayout = new QHBoxLayout;
    auto* yLabel = new QLabel(QStringLiteral("Y: "));
    ySpinBox = new Gui::QuantitySpinBox;
    ySpinBox->setUnit(Base::Unit::Length);
    yLayout->addWidget(yLabel);
    yLayout->addWidget(ySpinBox);

    // Create layout and widgets for Z
    auto* zLayout = new QHBoxLayout;
    auto* zLabel = new QLabel(QStringLiteral("Z: "));
    zSpinBox = new Gui::QuantitySpinBox;
    zSpinBox->setUnit(Base::Unit::Length);
    zLayout->addWidget(zLabel);
    zLayout->addWidget(zSpinBox);

    // Add the layouts to the direction group
    directionLayout->addLayout(xLayout);
    directionLayout->addLayout(yLayout);
    directionLayout->addLayout(zLayout);
    directionGroup->setLayout(directionLayout);

    angleSpinBox = new Gui::QuantitySpinBox;
    angleSpinBox->setUnit(Base::Unit::Angle);

    auto* buttonsLayout = new QHBoxLayout;
    auto* okButton = new QPushButton(tr("OK"));
    auto* cancelButton = new QPushButton(tr("Cancel"));
    buttonsLayout->addWidget(okButton);
    buttonsLayout->addWidget(cancelButton);

    auto* mainLayout = new QVBoxLayout;
    mainLayout->addWidget(directionGroup);
    mainLayout->addWidget(new QLabel(tr("Rotate by")));
    mainLayout->addWidget(angleSpinBox);
    mainLayout->addLayout(buttonsLayout);
    setLayout(mainLayout);

    connect(okButton, &QPushButton::clicked, this, &QDialog::accept);
    connect(cancelButton, &QPushButton::clicked, this, &QDialog::reject);
}

#include <Mod/TechDraw/Gui/moc_TaskProjGroup.cpp>