/**
 * @file GeneralFunctionDialog.cpp
 * Implements the GeneralFunctionDialog class.
 * @ingroup meshtex-ui
 */

/*
 * Copyright 2012 Joel Baxter
 *
 * This file is part of MeshTex.
 *
 * MeshTex is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * MeshTex 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 General Public License
 * along with MeshTex.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "GenericPluginUI.h"
#include "GeneralFunctionDialog.h"
#include "PluginUIMessages.h"

#include "iundo.h"


/**
 * Constructor. See MeshEntity::GeneralFunction for details of how these
 * arguments are interpreted.
 *
 * @param sFactors      Factors to determine the S texture coords; NULL if S
 *                      axis unaffected.
 * @param tFactors      Factors to determine the T texture coords; NULL if T
 *                      axis unaffected.
 * @param alignRow      Pointer to zero-point row; if NULL, row 0 is assumed.
 * @param alignCol      Pointer to zero-point column; if NULL, column 0 is
 *                      assumed.
 * @param refRow        Pointer to reference row description, including how
 *                      to use the reference; NULL if no reference.
 * @param refCol        Pointer to reference column description, including
 *                      how to use the reference; NULL if no reference.
 * @param surfaceValues true if calculations are for S/T values on the mesh
 *                      surface; false if calculations are for S/T values at
 *                      the control points.
 */
GeneralFunctionDialog::GeneralFunctionVisitor::GeneralFunctionVisitor(
   const MeshEntity::GeneralFunctionFactors *sFactors,
   const MeshEntity::GeneralFunctionFactors *tFactors,
   const MeshEntity::SliceDesignation *alignRow,
   const MeshEntity::SliceDesignation *alignCol,
   const MeshEntity::RefSliceDescriptor *refRow,
   const MeshEntity::RefSliceDescriptor *refCol,
   bool surfaceValues) :
   _sFactors(sFactors),
   _tFactors(tFactors),
   _alignRow(alignRow),
   _alignCol(alignCol),
   _refRow(refRow),
   _refCol(refCol),
   _surfaceValues(surfaceValues)
{
}

/**
 * Visitor action; invoke MeshEntity::GeneralFunction on a mesh.
 *
 * @param [in,out] meshEntity The mesh.
 *
 * @return true.
 */
bool
GeneralFunctionDialog::GeneralFunctionVisitor::Execute(MeshEntity& meshEntity) const
{
   meshEntity.GeneralFunction(_sFactors, _tFactors,
                              _alignRow, _alignCol, _refRow, _refCol,
                              _surfaceValues);
   return true;
}

/**
 * Constructor. Configure the dialog window and create all the contained
 * widgets. Connect widgets to callbacks as necessary.
 *
 * @param key The unique key identifying this dialog.
 */
GeneralFunctionDialog::GeneralFunctionDialog(const std::string& key) :
   GenericDialog(key),
   _nullVisitor(new MeshVisitor())
{
   // Configure the dialog window.
   _dialog->setWindowTitle(DIALOG_GEN_FUNC_TITLE);

   // Create the contained widgets.
   {
      auto grid = new QGridLayout( _dialog ); // 6 x 13
      grid->setSizeConstraint( QLayout::SizeConstraint::SetFixedSize );
      grid->setColumnStretch( 0, 1 );
      grid->setColumnStretch( 3, 1 );
      {
         // Mutually exclusive "Surface values" and "Control values" radio buttons.
         {
            auto radio = surface = new QRadioButton( DIALOG_GEN_FUNC_SURFACE_VALUES );
            grid->addWidget( radio, 0, 1 );
            radio->setChecked( true );
         }
         {
            auto radio = new QRadioButton( DIALOG_GEN_FUNC_CONTROL_VALUES );
            grid->addWidget( radio, 0, 2 );
         }
         {
            auto line = new QFrame;
				line->setFrameShape( QFrame::Shape::HLine );
				line->setFrameShadow( QFrame::Shadow::Raised );
				grid->addWidget( line, 1, 0, 1, 4 );
         }
         // Checkbox for the "S" row of factors. All the other widgets on this row
         // will have a dependence registered on this checkbox; i.e. they will only
         // be active when it is checked.
         {
            auto hbox = new QHBoxLayout;
            grid->addLayout( hbox, 2, 0, 1, 4 );

            auto check = s_apply = new QCheckBox;
            check->setChecked( true );
            hbox->addWidget( check );

            auto container = new QWidget;
            hbox->addWidget( container );
            UIInstance().RegisterWidgetDependence( check, container );

            auto container_hbox = new QHBoxLayout( container );
            container_hbox->setContentsMargins( 0, 0, 0, 0 );
            {
               const struct{ const char* name; QDoubleSpinBox *&spin; } data[] = {
                  { DIALOG_GEN_FUNC_S_FUNC_LABEL, s_oldval },
                  { DIALOG_GEN_FUNC_OLD_S_LABEL, s_rowdist },
                  { DIALOG_GEN_FUNC_ROW_DIST_LABEL, s_coldist },
                  { DIALOG_GEN_FUNC_COL_DIST_LABEL, s_rownum },
                  { DIALOG_GEN_FUNC_ROW_NUM_LABEL, s_colnum },
                  { DIALOG_GEN_FUNC_COL_NUM_LABEL, s_constant },
               };
               for( auto [ name, spin ] : data )
               {
                  container_hbox->addWidget( new QLabel( name ) );
                  container_hbox->addWidget( spin = new DoubleSpinBox( -999, 999, 0, 3, .01 ) );
               }
               s_oldval->setValue( 1 );
            }
         }
         // Checkbox for the "T" row of factors. All the other widgets on this row
         // will have a dependence registered on this checkbox; i.e. they will only
         // be active when it is checked.
         {
            auto hbox = new QHBoxLayout;
            grid->addLayout( hbox, 3, 0, 1, 4 );

            auto check = t_apply = new QCheckBox;
            check->setChecked( true );
            hbox->addWidget( check );

            auto container = new QWidget;
            hbox->addWidget( container );
            UIInstance().RegisterWidgetDependence( check, container );

            auto container_hbox = new QHBoxLayout( container );
            container_hbox->setContentsMargins( 0, 0, 0, 0 );
            {
               const struct{ const char* name; QDoubleSpinBox *&spin; } data[] = {
                  { DIALOG_GEN_FUNC_T_FUNC_LABEL, t_oldval },
                  { DIALOG_GEN_FUNC_OLD_S_LABEL, t_rowdist },
                  { DIALOG_GEN_FUNC_ROW_DIST_LABEL, t_coldist },
                  { DIALOG_GEN_FUNC_COL_DIST_LABEL, t_rownum },
                  { DIALOG_GEN_FUNC_ROW_NUM_LABEL, t_colnum },
                  { DIALOG_GEN_FUNC_COL_NUM_LABEL, t_constant },
               };
               for( auto [ name, spin ] : data )
               {
                  container_hbox->addWidget( new QLabel( name ) );
                  container_hbox->addWidget( spin = new DoubleSpinBox( -999, 999, 0, 3, .01 ) );
               }
               t_oldval->setValue( 1 );
            }
         }
         {
            // Widgets for specifying the alignment column.
            auto group = new QGroupBox( DIALOG_GEN_FUNC_COL_ALIGN_FRAME_LABEL );
            grid->addWidget( group, 4, 1 );

            auto grid = new QGridLayout( group );
            grid->setColumnStretch( 2, 1 );
            {
               auto radio = new QRadioButton;
               grid->addWidget( radio, 0, 0 );
               auto spin = col_num_align = new SpinBox( 0, 30 );
               grid->addWidget( spin, 0, 1 );
               UIInstance().RegisterWidgetDependence( radio, spin );
               radio->setChecked( true );
            }
            {
               auto radio = new QRadioButton( DIALOG_GEN_FUNC_MAX_OPT_LABEL );
               grid->addWidget( radio, 0, 2, Qt::AlignmentFlag::AlignRight );
            }
         }
         {
            // Widgets for specifying the reference row & usage.
            auto group = row_ref = new QGroupBox( DIALOG_GEN_FUNC_REF_ROW_FRAME_LABEL );
            group->setCheckable( true );
            group->setChecked( true );
            grid->addWidget( group, 5, 1 );

            auto grid = new QGridLayout( group );
            grid->setColumnStretch( 2, 1 );
            {
               auto radio = new QRadioButton;
               grid->addWidget( radio, 0, 0 );
               auto spin = row_num_ref = new SpinBox( 0, 30 );
               grid->addWidget( spin, 0, 1 );
               UIInstance().RegisterWidgetDependence( radio, spin );
               radio->setChecked( true );
            }
            {
               auto radio = new QRadioButton( DIALOG_GEN_FUNC_MAX_OPT_LABEL );
               grid->addWidget( radio, 0, 2, Qt::AlignmentFlag::AlignRight );
            }
            {
               auto check = row_ref_total = new QCheckBox( DIALOG_GEN_FUNC_REF_TOTAL_OPT_LABEL );
               grid->addWidget( check, 1, 0, 1, 3 );
               check->setChecked( true );
            }
         }
         {
            // Widgets for specifying the alignment row.
            auto group = new QGroupBox( DIALOG_GEN_FUNC_ROW_ALIGN_FRAME_LABEL );
            grid->addWidget( group, 4, 2 );

            auto grid = new QGridLayout( group );
            grid->setColumnStretch( 2, 1 );
            {
               auto radio = new QRadioButton;
               grid->addWidget( radio, 0, 0 );
               auto spin = row_num_align = new SpinBox( 0, 30 );
               grid->addWidget( spin, 0, 1 );
               UIInstance().RegisterWidgetDependence( radio, spin );
               radio->setChecked( true );
            }
            {
               auto radio = new QRadioButton( DIALOG_GEN_FUNC_MAX_OPT_LABEL );
               grid->addWidget( radio, 0, 2, Qt::AlignmentFlag::AlignRight );
            }
         }
         {
            // Widgets for specifying the reference column & usage.
            auto group = col_ref = new QGroupBox( DIALOG_GEN_FUNC_REF_COL_FRAME_LABEL );
            group->setCheckable( true );
            group->setChecked( true );
            grid->addWidget( group, 5, 2 );

            auto grid = new QGridLayout( group );
            grid->setColumnStretch( 2, 1 );
            {
               auto radio = new QRadioButton;
               grid->addWidget( radio, 0, 0 );
               auto spin = col_num_ref = new SpinBox( 0, 30 );
               grid->addWidget( spin, 0, 1 );
               UIInstance().RegisterWidgetDependence( radio, spin );
               radio->setChecked( true );
            }
            {
               auto radio = new QRadioButton( DIALOG_GEN_FUNC_MAX_OPT_LABEL );
               grid->addWidget( radio, 0, 2, Qt::AlignmentFlag::AlignRight );
            }
            {
               auto check = col_ref_total = new QCheckBox( DIALOG_GEN_FUNC_REF_TOTAL_OPT_LABEL );
               grid->addWidget( check, 1, 0, 1, 3 );
               check->setChecked( true );
            }
         }
         {
            auto buttons = new QDialogButtonBox;
            grid->addWidget( buttons, 6, 0, 1, 4 );
            CreateOkButtonCallback( buttons->addButton( QDialogButtonBox::StandardButton::Ok ) );
            CreateApplyButtonCallback( buttons->addButton( QDialogButtonBox::StandardButton::Apply ) );
            CreateCancelButtonCallback( buttons->addButton( QDialogButtonBox::StandardButton::Cancel ) );
         }
      }
   }
}

/**
 * Destructor.
 */
GeneralFunctionDialog::~GeneralFunctionDialog()
{
}

/**
 * Handler for the Apply logic for this dialog. Apply the specified equations
 * to the selected mesh entities.
 *
 * @return true if any meshes are selected, false otherwise.
 */
bool
GeneralFunctionDialog::Apply()
{
   // Before doing anything, check to see if there are some meshes selected.
   _nullVisitor->ResetVisitedCount();
   GlobalSelectionSystem().foreachSelected(*_nullVisitor);
   if (_nullVisitor->GetVisitedCount() == 0)
   {
      // Nope. Warn and bail out.
      GenericPluginUI::WarningReportDialog(DIALOG_WARNING_TITLE,
                                           DIALOG_NOMESHES_MSG);
      return false;
   }

   // See if we're going to be affecting the S and/or T texture axis.
   const bool sApply = s_apply->isChecked();
   const bool tApply = t_apply->isChecked();

   if (!sApply && !tApply)
   {
      // Not affecting either, so bail out.
      return true;
   }

   // OK read the remaining info from the widgets.

   MeshEntity::GeneralFunctionFactors s, t;
   MeshEntity::GeneralFunctionFactors *sFactors = NULL;
   MeshEntity::GeneralFunctionFactors *tFactors = NULL;
   if (sApply)
   {
      // S axis is affected, so read the S factors.
      s.oldValue = s_oldval->value();
      s.rowDistance = s_rowdist->value();
      s.colDistance = s_coldist->value();
      s.rowNumber = s_rownum->value();
      s.colNumber = s_colnum->value();
      s.constant = s_constant->value();
      sFactors = &s;
   }
   if (tApply)
   {
      // T axis is affected, so read the T factors.
      t.oldValue = t_oldval->value();
      t.rowDistance = t_rowdist->value();
      t.colDistance = t_coldist->value();
      t.rowNumber = t_rownum->value();
      t.colNumber = t_colnum->value();
      t.constant = t_constant->value();
      tFactors = &t;
   }
   MeshEntity::SliceDesignation alignRow, alignCol;
   alignRow.maxSlice = !row_num_align->isEnabled();
   alignRow.index = row_num_align->value();
   alignCol.maxSlice = !col_num_align->isEnabled();
   alignCol.index = col_num_align->value();
   MeshEntity::RefSliceDescriptor row, col;
   MeshEntity::RefSliceDescriptor *refRow = NULL;
   MeshEntity::RefSliceDescriptor *refCol = NULL;
   if ( row_ref->isChecked() )
   {
      // Reference row is specified, so get that info.
      row.designation.maxSlice = !row_num_ref->isEnabled();
      row.designation.index = row_num_ref->value();
      row.totalLengthOnly = row_ref_total->isChecked();
      refRow = &row;
   }
   if ( col_ref->isChecked() )
   {
      // Reference column is specified, so get that info.
      col.designation.maxSlice = !col_num_ref->isEnabled();
      col.designation.index = col_num_ref->value();
      col.totalLengthOnly = col_ref_total->isChecked();
      refCol = &col;
   }
   const bool surfaceValues = surface->isChecked();

   // Let Radiant know the name of the operation responsible for the changes
   // that are about to happen.
   UndoableCommand undo(_triggerCommand.c_str());

   // Apply the specified equation to every selected mesh.
   SmartPointer<GeneralFunctionVisitor> funcVisitor(
      new GeneralFunctionVisitor(sFactors, tFactors,
                                 &alignRow, &alignCol, refRow, refCol,
                                 surfaceValues));
   GlobalSelectionSystem().foreachSelected(*funcVisitor);

   // Done!
   return true;
}