/* massXpert - the true massist's program.
   --------------------------------------
   Copyright(C) 2006,2007 Filippo Rusconi

   http://www.massxpert.org/massXpert

   This file is part of the massXpert project.

   The massxpert project is the successor to the "GNU polyxmass"
   project that is an official GNU project package(see
   www.gnu.org). The massXpert project is not endorsed by the GNU
   project, although it is released ---in its entirety--- under the
   GNU General Public License. A huge part of the code in massXpert
   is actually a C++ rewrite of code in GNU polyxmass. As such
   massXpert was started at the Centre National de la Recherche
   Scientifique(FRANCE), that granted me the formal authorization to
   publish it under this Free Software License.

   This software is free software; you can redistribute it and/or
   modify it under the terms of the GNU  General Public
   License version 3, as published by the Free Software Foundation.
   

   This software 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 this software; if not, write to the

   Free Software Foundation, Inc.,

   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*/


/////////////////////// Qt includes
#include <QMessageBox>
#include <QFileDialog>


/////////////////////// Local includes
#include "fragmentationDlg.hpp"
#include "application.hpp"


namespace massXpert
{

  FragmentationDlg::FragmentationDlg(QWidget *parent,
				      Polymer *polymer,
				      const PolChemDef *polChemDef,
				      const CalcOptions &calcOptions,
				      const IonizeRule *ionizeRule)
    : QDialog(parent),
      mp_polymer(polymer), 
      mp_polChemDef(polChemDef), 
      m_calcOptions(calcOptions),
      mp_ionizeRule(ionizeRule)
  {
    Q_ASSERT(parent);
    Q_ASSERT(!mp_polymer.isNull() && mp_polChemDef);
    Q_ASSERT(mp_ionizeRule);
    
    m_ui.setupUi(this);
  
    mp_editorWnd = static_cast<SequenceEditorWnd *>(parent);

    populateSelectedOligomerData();
    populateFragSpecList();

    m_ui.fragmentationPatternListWidget->
      setSelectionMode(QAbstractItemView::MultiSelection);

    mpa_oligomerTreeViewModel = 0;
    mpa_proxyModel = 0;
  
    // Absolutely required that the pointer be 0 at creation because we
    // rely on its being non-0 to free it when required(pointer used
    // many times).
    mpa_fragmenter = 0;
  

    // The tolerance when filtering mono/avg masses...
    QStringList stringList;
  
    stringList << tr("AMU") << tr("PCT") << tr("PPM");
  
    m_ui.toleranceComboBox->insertItems(0, stringList);
  
    m_ui.toleranceComboBox->setToolTip(tr("AMU: atom mass unit \n"
					    "PCT: percent \n"
					    "PPM: part per million"));

    filterAct = new QAction(tr("Toggle Filtering"), this);
    filterAct->setShortcut(QKeySequence(Qt::CTRL+Qt::Key_F));
    this->addAction(filterAct);
    connect(filterAct, 
	     SIGNAL(triggered()), 
	     this, 
	     SLOT(filterOptionsToggled()));
  
    m_ui.filteringOptionsGroupBox->addAction(filterAct);
    // When the dialog box is created it is created with the groupbox
    // unchecked.
    m_ui.filteringOptionsFrame->setVisible(false);
  
    // When the filtering group box will be opened, the focus will be on the 
    // first widget of the groupbox:
    mp_focusWidget = m_ui.filterPatternLineEdit;


    // The results-exporting menus. ////////////////////////////////

    QStringList comboBoxItemList;

    comboBoxItemList 
      << tr("To Clipboard") 
      << tr("To File")
      << tr("Select File");
  
    m_ui.exportResultsComboBox->addItems(comboBoxItemList);
  
    connect(m_ui.exportResultsComboBox,
	     SIGNAL(activated(int)),
	     this,
	     SLOT(exportResults(int)));

    mpa_resultsString = new QString();
  
    //////////////////////////////////// The results-exporting menus.
  

    QSettings settings 
     (static_cast<Application *>(qApp)->configSettingsFilePath(), 
       QSettings::IniFormat);
  
    settings.beginGroup("fragmentation_dlg");

    restoreGeometry(settings.value("geometry").toByteArray());

    m_ui.oligomersSplitter->
      restoreState(settings.value("oligomersSplitter").toByteArray());
  
    m_ui.oligoDetailsSplitter->
      restoreState(settings.value("oligoDetailsSplitter").toByteArray());
  
    settings.endGroup();


    connect(m_ui.fragmentPushButton,
	     SIGNAL(clicked()),
	     this,
	     SLOT(fragment()));

    connect(m_ui.filterPatternLineEdit,
	     SIGNAL(returnPressed()),
	     this,
	     SLOT(filterPattern()));
  
    connect(m_ui.filterMonoMassLineEdit,
	     SIGNAL(returnPressed()),
	     this,
	     SLOT(filterMonoMass()));
  
    connect(m_ui.filterAvgMassLineEdit,
	     SIGNAL(returnPressed()),
	     this,
	     SLOT(filterAvgMass()));
  
    connect(m_ui.filterChargeLineEdit,
	     SIGNAL(returnPressed()),
	     this,
	     SLOT(filterCharge()));

    connect(m_ui.filteringOptionsGroupBox,
	     SIGNAL(clicked(bool)),
	     this,
	     SLOT(filterOptions(bool)));
  }


  FragmentationDlg::~FragmentationDlg()
  {
    delete mpa_oligomerTreeViewModel;
    delete mpa_proxyModel;
    delete mpa_fragmenter;
    delete mpa_resultsString;
  }


  void 
  FragmentationDlg::closeEvent(QCloseEvent *event)
  {
    if (event)
      printf("%s", "");
  
    QSettings settings 
     (static_cast<Application *>(qApp)->configSettingsFilePath(), 
       QSettings::IniFormat);
  
    settings.beginGroup("fragmentation_dlg");

    settings.setValue("geometry", saveGeometry());

    settings.setValue("oligomersSplitter", 
		       m_ui.oligomersSplitter->saveState());

    settings.setValue("oligoDetailsSplitter", 
		       m_ui.oligoDetailsSplitter->saveState());

    settings.endGroup();
  }


  bool
  FragmentationDlg::populateSelectedOligomerData() 
  {
    CoordinateList coordList;
    
    bool res = mp_editorWnd->mpa_editorGraphicsView->
      selectionIndices(&coordList);
    
    if (!res)
      {
	QMessageBox::information(this, tr("massxpert - Fragmentation"),
				  tr("No oligomer is selected. "
				      "Select an oligomer first"),
				  QMessageBox::Ok);
	return false;
      }
    
    if (coordList.size() > 1)
      {
	QMessageBox::information(this, tr("massxpert - Fragmentation"),
				  tr("Fragmentation simulations with\n"
				      "multi-region selection are not " 
				      "supported."),
				  QMessageBox::Ok);
	return false;
      }
    
    m_calcOptions.setCoordinateList(coordList);
  
    Coordinates *coordinates = coordList.last();
    
    m_ui.oligomerStartLabel->
      setText(QString().setNum(coordinates->start() + 1));
    
    m_ui.oligomerEndLabel->
      setText(QString().setNum(coordinates->end() + 1));
    
    return true;
  }
  


  void
  FragmentationDlg::populateFragSpecList()
  {
    for (int iter = 0; iter < mp_polChemDef->fragSpecList().size(); ++iter)
      {
	FragSpec *fragSpec = mp_polChemDef->fragSpecList().at(iter);
	Q_ASSERT(fragSpec);
      
	m_ui.fragmentationPatternListWidget->addItem(fragSpec->name());
      }
  
    return;
  }


  SequenceEditorWnd *
  FragmentationDlg::editorWnd()
  {
    return mp_editorWnd;
  }


  void 
  FragmentationDlg::fragment()
  {
    // Update the options from the parent window.
    m_calcOptions = mp_editorWnd->calcOptions();
    
    // And now override the selection data by using the
    // selection-specific function below.
    if (!populateSelectedOligomerData())
      return ;
    
    // For each fragmentation specification selected in the list of
    // available fragmentation specifications we have to construct a
    // FragOptions instance and add it to the list of such frag
    // options. If no item is currently selected, just return.

    // What are the currently selected specifications ?
    QList<QListWidgetItem *> selectionList = 
      m_ui.fragmentationPatternListWidget->selectedItems();
  
    if (!selectionList.size())
      return;

    // We'll need to use the specifications in the polymer chemistry
    // definition... for each frag options object.
    QList<FragSpec *> refList = mp_polChemDef->fragSpecList();

    // We'll have to store all the fragOptions in a list:
    QList<FragOptions *> fragOptionList;
  
    // We'll need a fragmentation specification each time we iterate in
    // a new specification item below.
    FragSpec fragSpec(mp_polChemDef, "NOT_SET");

    // Finally parse all the different fragmentation specification items
    // currently selected in the list widget.

    for (int iter = 0; iter < selectionList.size(); ++iter)
      {
	QListWidgetItem *item = selectionList.at(iter);
      
	if(item->isSelected())
	  {
	    // Need to create a new fragOptions with the correct
	    // fragmentation specification. First get its name from the
	    // list widget. Then use that name to find the FragSpec
	    // from the list of frag specs in the polymer chemistry
	    // definition. Finally allocate a new frag options object
	    // and set data into it.

	    QString name = item->text();

	    int res = FragSpec::isNameInList(name, refList, &fragSpec);
      
	    if (res == -1)
	      {
		return;
	      }
      
	    FragOptions *fragOptions = new FragOptions(fragSpec);
	  
	    // We got the coordinates of the oligomer to fragment in the
	    // mp_calcOptions from the sequence editor window.

	    Coordinates *coordinates = m_calcOptions.coordinateList().last();
	    
	    fragOptions->setStartIndex(coordinates->start());
	    fragOptions->setEndIndex(coordinates->end());
	  

	    // Set the ionization levels.
	    int valueStart = m_ui.ionizeLevelStartSpinBox->value();
	    int valueEnd = m_ui.ionizeLevelEndSpinBox->value();

	    if (valueStart > valueEnd)
	      {
		fragOptions->setStartIonizeLevel(valueEnd);
		fragOptions->setEndIonizeLevel(valueStart);
	      }
	    else
	      {
		fragOptions->setStartIonizeLevel(valueStart);
		fragOptions->setEndIonizeLevel(valueEnd);
	      }

	  
	    //   qDebug() << "Start:" << fragOptions.startIonizeLevel();
	    //   qDebug() << "End:" << fragOptions.endIonizeLevel();
	  
	    // Add the frag options to the list.
	    fragOptionList.append(fragOptions);
	  }
	else
	  continue;
      }
  
    // At this point the list of frag options should contain the same
    // number of items as the number of items selected in the list
    // widget.

    Q_ASSERT(fragOptionList.size() == selectionList.size());
  
    // Now that we have all the fragmentation options in the list, we
    // can allocate the fragmenter! Note that this function might be
    // called many time, which means that we first have to free the
    // mpa_fragmenter allocated member if non-0.

    delete mpa_fragmenter;
    mpa_fragmenter = 0;
    
    mpa_fragmenter = new Fragmenter(mp_polymer, mp_polChemDef,
				     fragOptionList, 
				     m_calcOptions, *mp_ionizeRule);
  
    if (!mpa_fragmenter->fragment())
      {
	delete mpa_fragmenter;
      
	QMessageBox msgBox;

	msgBox.setText("Failed to perform the fragmentation.");

	msgBox.setStandardButtons(QMessageBox::Ok);
	
	msgBox.exec();
      
	return;
      }
  
    QList<OligomerList *> &dataList = mpa_fragmenter->oligomerLists();
  
    delete mpa_oligomerTreeViewModel;
    mpa_oligomerTreeViewModel = 0;
    
    delete mpa_proxyModel;
    mpa_proxyModel = 0;
    
    // Model stuff all thought for sorting.
    mpa_oligomerTreeViewModel = 
      new FragmentOligomerTreeViewModel(&dataList, this);

    mpa_proxyModel = new FragmentOligomerTreeViewSortProxyModel(this);
    mpa_proxyModel->setSourceModel(mpa_oligomerTreeViewModel);
    mpa_proxyModel->setFilterKeyColumn(-1);

    m_ui.oligomerTreeView->setModel(mpa_proxyModel);

    m_ui.oligomerTreeView->setParentDlg(this);
  
    mpa_oligomerTreeViewModel->setTreeView(m_ui.oligomerTreeView);
  
    updateFragmentationDetails();

    // Set focus to the treeView.
    m_ui.oligomerTreeView->setFocus();

    QPoint tvPoint = m_ui.oligomerTreeView->pos();
    QList<int> splitList = m_ui.oligomersSplitter->sizes();
    tvPoint.ry() += splitList.at(0);
    QPoint destPoint(mapToGlobal(tvPoint));
    
    QToolTip::showText(destPoint, 
			QString(tr("Generated %1 oligomers")
				 .arg(mpa_oligomerTreeViewModel->rowCount())), 
			m_ui.oligomerTreeView);
  }


  void
  FragmentationDlg::updateFragmentationDetails()
  {
    if (m_calcOptions.monomerEntities() & MXT_MONOMER_CHEMENT_MODIF)
      m_ui.modifsPixmapLabel->setPixmap(QPixmap(":/images/greenled.png"));
    else
      m_ui.modifsPixmapLabel->setPixmap(QPixmap(":/images/redled.png"));

    if (m_calcOptions.polymerEntities() & MXT_POLYMER_CHEMENT_LEFT_END_MODIF)
      m_ui.leftModifPixmapLabel->setPixmap(QPixmap(":/images/greenled.png"));
    else
      m_ui.leftModifPixmapLabel->setPixmap(QPixmap(":/images/redled.png"));

    if (m_calcOptions.polymerEntities() & MXT_POLYMER_CHEMENT_RIGHT_END_MODIF)
      m_ui.rightModifPixmapLabel->setPixmap(QPixmap(":/images/greenled.png"));
    else
      m_ui.rightModifPixmapLabel->setPixmap(QPixmap(":/images/redled.png"));
  }


  void
  FragmentationDlg::updateOligomerSequence(QString *text)
  {
    Q_ASSERT(text);
  
    m_ui.oligomerSequenceTextEdit->clear();
    m_ui.oligomerSequenceTextEdit->append(*text);
  }



  bool
  FragmentationDlg::calculateTolerance(double mass)
  {
    // Get the tolerance that is in its lineEdit.
  
    QString text = m_ui.toleranceLineEdit->text();
    double tolerance = 0;
    bool ok = false;
  
    if (!text.isEmpty())
      {
	// Convert the string to a double.
	Application *application = static_cast<Application *>(qApp);
	QLocale locale = application->locale();

	ok = false;
	tolerance = locale.toDouble(text, &ok);
      
	if(!tolerance && !ok)
	  return false;
      }
    else
      {
	m_tolerance = 0;
      }
    
    // What's the item currently selected in the comboBox?
    int index = m_ui.toleranceComboBox->currentIndex();
  
    if (index == 0)
      {
	// MXT_MASS_TOLERANCE_AMU
	m_tolerance = tolerance;
      }
    else if (index == 1)
      {
	// MXT_MASS_TOLERANCE_PCT
	m_tolerance =(tolerance / 100) * mass;
      }
    else if (index == 2)
      {
	// MXT_MASS_TOLERANCE_PPM
	m_tolerance =(tolerance / 1000000) * mass;
      }
    else
      Q_ASSERT(0);
  
    return true;
  }


  void 
  FragmentationDlg::filterOptions(bool checked)
  {
    if (!checked)
      {
	mpa_proxyModel->setFilterKeyColumn(-1);
      
	mpa_proxyModel->applyNewFilter();

	m_ui.filteringOptionsFrame->setVisible(false);
      }
    else
      {
	m_ui.filteringOptionsFrame->setVisible(true);

	// In this case, set focus to the last focused widget in the
	// groupbox or the first widget in the groubox if this is the
	// first time the filtering is used.
	mp_focusWidget->setFocus();
      }
  }


  void 
  FragmentationDlg::filterOptionsToggled()
  {
    bool isChecked = m_ui.filteringOptionsGroupBox->isChecked();
  
    m_ui.filteringOptionsGroupBox->setChecked(!isChecked);
    filterOptions(!isChecked);
  }


  void 
  FragmentationDlg::filterPattern()
  {
    // First off, we have to get the pattern that is in the lineEdit.
  
    QString text = m_ui.filterPatternLineEdit->text();

    if (text.isEmpty())
      return;

    mpa_proxyModel->setPatternFilter(text);
    mpa_proxyModel->setFilterKeyColumn(0);
    mpa_proxyModel->applyNewFilter();

    mp_focusWidget = m_ui.filterPatternLineEdit;
  }


  void 
  FragmentationDlg::filterMonoMass()
  {
    // First off, we have to get the mass that is in the lineEdit.

    QString text = m_ui.filterMonoMassLineEdit->text();
  
    if (text.isEmpty())
      return;
  
    // Convert the string to a double.
    Application *application = static_cast<Application *>(qApp);
    QLocale locale = application->locale();

    bool ok = false;
    double mass = locale.toDouble(text, &ok);
  
    if (!mass && !ok)
      return;

    // At this point, depending on the item that is currently selected
    // in the comboBox, we'll have to actually compute the tolerance.

    if (!calculateTolerance(mass))
      return ;

    mpa_proxyModel->setMonoFilter(mass);
    mpa_proxyModel->setTolerance(m_tolerance);
  
    mpa_proxyModel->setFilterKeyColumn(3);
    mpa_proxyModel->applyNewFilter();

    mp_focusWidget = m_ui.filterMonoMassLineEdit;
  }


  void 
  FragmentationDlg::filterAvgMass()
  {
    // First off, we have to get the mass that is in the lineEdit.

    QString text = m_ui.filterAvgMassLineEdit->text();
  
    if (text.isEmpty())
      return;
  
    // Convert the string to a double.
    Application *application = static_cast<Application *>(qApp);
    QLocale locale = application->locale();

    bool ok = false;
    double mass = locale.toDouble(text, &ok);
  
    if (!mass && !ok)
      return;

    // At this point, depending on the item that is currently selected
    // in the comboBox, we'll have to actually compute the tolerance.

    if (!calculateTolerance(mass))
      return ;

    mpa_proxyModel->setAvgFilter(mass);
    mpa_proxyModel->setTolerance(m_tolerance);
  
    mpa_proxyModel->setFilterKeyColumn(4);
    mpa_proxyModel->applyNewFilter();

    mp_focusWidget = m_ui.filterAvgMassLineEdit;
  }


  void 
  FragmentationDlg::filterCharge()
  {
    // First off, we have to get the charge that is in the lineEdit.

    QString text = m_ui.filterChargeLineEdit->text();

    if (text.isEmpty())
      return;
  
    // Convert the string to a int.
    Application *application = static_cast<Application *>(qApp);
    QLocale locale = application->locale();

    bool ok = false;
    int charge = locale.toInt(text, &ok);
  
    if (!charge && !ok)
      return;

    mpa_proxyModel->setChargeFilter(charge);
    mpa_proxyModel->setFilterKeyColumn(5);
    mpa_proxyModel->applyNewFilter();

    mp_focusWidget = m_ui.filterChargeLineEdit;
  }



  // The results-exporting functions. ////////////////////////////////
  // The results-exporting functions. ////////////////////////////////
  // The results-exporting functions. ////////////////////////////////
  void
  FragmentationDlg::exportResults(int index)
  {
    // Remember that we had set up the combobox with the following strings:
    // << tr("To Clipboard") 
    // << tr("To File")
    // << tr("Select File");

    if (index == 0)
      {
	exportResultsClipboard();
      }
    else if (index == 1)
      {
	exportResultsFile();
      }
    else if (index == 2)
      {
	selectResultsFile();
      }
    else 
      Q_ASSERT(0);
  
  }


  void
  FragmentationDlg::prepareResultsTxtString()
  {
    mpa_resultsString->clear();
  
    *mpa_resultsString += QObject::tr("\n---------------------------\n"
				       "Fragmentation: \n"
				       "---------------------------\n");
  
    bool withSequence = m_ui.withSequenceCheckBox->isChecked();
    
    QString *text = 
      m_ui.oligomerTreeView->selectedOligomersAsPlainText(withSequence);

    *mpa_resultsString += *text;
    
    delete text;
  }



  bool 
  FragmentationDlg::exportResultsClipboard()
  {
    prepareResultsTxtString();
  
    QClipboard *clipboard = QApplication::clipboard();

    clipboard->setText(*mpa_resultsString, QClipboard::Clipboard);
  
    return true;
  }


  bool 
  FragmentationDlg::exportResultsFile()
  {
    if (m_resultsFilePath.isEmpty())
      {
	if(!selectResultsFile())
	  return false;
      }
  
    QFile file(m_resultsFilePath);
  
    if (!file.open(QIODevice::WriteOnly | QIODevice::Append))
      {
	QMessageBox::information(0, 
				  tr("massXpert - Export Data"),
				  tr("Failed to open file in append mode."),
				  QMessageBox::Ok);
	return false;
      }
  
    QTextStream stream(&file);
    stream.setCodec("UTF-8");

    prepareResultsTxtString();
  
    stream << *mpa_resultsString;
  
    file.close();

    return true;
  }


  bool 
  FragmentationDlg::selectResultsFile()
  {
    m_resultsFilePath = 
      QFileDialog::getSaveFileName(this, tr("Select file to export data to"),
				    QDir::homePath(),
				    tr("Data files(*.dat *.DAT)"));
  
    if (m_resultsFilePath.isEmpty())
      return false;

    return true;
  }
  //////////////////////////////////// The results-exporting functions.
  //////////////////////////////////// The results-exporting functions.
  //////////////////////////////////// The results-exporting functions.

} // namespace massXpert