/**
  * @RDE_HEADER@
  * LtsFileDialogWidget and LtsFileDialog - custom widgets
  * $Id$
  * $HeadURL$
  * $Author$
  *
  * Created by Iuliana Ojog & Mike Wille, SLSE, 2017-09-15
  */

#include "lts_file_dialog_widget.h"
#include "lts_file_dialog.h"
#include "lts_dialog_model_file.h"
#include "lts_dialog_model_folder.h"
#include "ui_lts_file_dialog.h"

#include <LtsSession/lts_session.h>
#include <LtsSession/lts_session_data.h>
#include <nglwidgets/ngltreeitem.h>
#include <Services/FileManagement/flm_translation.h>
#include <ConnectDialog/connect_dialog_nt.h>
#include <LtsUtilsCore/dds_vector.h>

#include <QItemSelectionModel>

namespace LtsWidgets
{
//-----------------------------------------------------------------------------------------------------------
LtsFileDialogWidget::LtsFileDialogWidget(QWidget *parent)
  : QWidget(parent)
  , m_ui(new Ui::LtsFileDialogWidget)
  , m_selectedFileContent(FileManagement::FileContent())
{
  m_ui->setupUi(this);
}

//-----------------------------------------------------------------------------------------------------------
LtsFileDialogWidget::~LtsFileDialogWidget()
{
  delete m_ui;
}


//-----------------------------------------------------------------------------------------------------------
bool LtsFileDialogWidget::init(LtsSession::LtsSession *session,
                               const std::shared_ptr<FileManagement::Interface::Dtc> &dtc,
                               const std::shared_ptr<OperatorManagement::Interface::Dtc> &opmDtc,
                               const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc,
                               const FileDialogMode &dlgMode,
                               const QVector<FileManagement::MainFolder> &mainFolders,
                               const QVector<FileManagement::FileType> &fileTypes,
                               const int &folderId,
                               const QString &xmlType)
{
  m_session = session;
  m_dtc = dtc;
  m_opmDtc = opmDtc;
  m_exmDtc = exmDtc;
  m_dialogMode = dlgMode;
  m_fileTypes = fileTypes;
  m_selectedFolderId = folderId;
  m_xmlType = xmlType;
  m_mainFolders = mainFolders;

  if ((dtc.get() == nullptr) || (opmDtc.get() == nullptr))
    return false;

  m_dtc->enableFolder();
  m_dtc->waitForHistoricalDataFolder();
  m_dtc->enableFileContent();
  m_dtc->waitForHistoricalDataFileContent();
  m_opmDtc->enableUser();
  m_opmDtc->waitForHistoricalDataUser();
  m_exmDtc->enableExercise();
  m_exmDtc->waitForHistoricalDataExercise();
  m_exmDtc->enableExercisePhase();
  m_exmDtc->waitForHistoricalDataExercisePhase();

  // DDS connects
  connect(m_dtc.get(), &FileManagement::Interface::Dtc::folderChanged, this, &LtsFileDialogWidget::onFolderChanged);
  connect(m_dtc.get(), &FileManagement::Interface::Dtc::fileContentChanged, this, &LtsFileDialogWidget::onFileChanged);

  // model folder
  QVariant data;
  FileManagement::Folder dummyFolder;
  data.setValue(dummyFolder);
  NGLTreeItem *rootItem = new NGLTreeItem(data, QIcon());

  m_modelFolder = new DialogModelFolder(this, rootItem, m_dtc, m_exmDtc,
                                        QStringList()
                                        << tr("Name") << tr("Id"));

  m_modelFolder->initModel(m_session->exerciseId(), m_mainFolders);

  m_proxyModelFolder = new DialogModelProxyFolder(this);
  m_proxyModelFolder->setOperatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
  m_proxyModelFolder->setSourceModel(m_modelFolder);
  m_proxyModelFolder->sort(DialogModelFolder::Columns::ID, Qt::AscendingOrder);

  // UI
  m_ui->tvFolder->setModel(m_proxyModelFolder);
  m_ui->tvFolder->expandAll();
  m_ui->tvFolder->setExpanded(m_proxyModelFolder->index(0,0),true);
  m_ui->tvFolder->hideColumn(DialogModelFolder::Columns::ID);

  // SelectionModel Folder
  QItemSelectionModel *selectionModelFolder = m_ui->tvFolder->selectionModel();
  connect(selectionModelFolder, &QItemSelectionModel::selectionChanged, this, &LtsFileDialogWidget::onFolderSelectionChanged);

  // model file
  m_modelFile = new DialogModelFile(this);

  // initial all valid, not-deleted files
  auto predicate = [](const FileManagement::FileContent &fc, const QString &xmlType)
  {
    return (!fc.isDeleted() && fc.fileStatus() == FileManagement::FileStatus::Valid &&
           (xmlType.isEmpty() || fc.properties().find(xmlType.toStdString()) != std::string::npos));
  };
  m_modelFile->initModel(m_dtc, m_opmDtc, xmlType, predicate);

//  auto predicate = [](const FileManagement::FileContent &fc)
//  {
//    return (!fc.isDeleted() && fc.fileStatus() == FileManagement::FileStatus::Valid);
//  };
//  m_modelFile->initModel(m_dtc, m_opmDtc, m_xmlType, predicate);

  // UI file
  m_ui->widgetFiles->seamless();
  m_proxyModelFile = new DialogFileProxyModel(this);
  m_proxyModelFile->setSourceModel(m_modelFile);
  m_ui->widgetFiles->setModel(m_proxyModelFile);

  m_ui->widgetFiles->hideColumn(FOLDER);

  // double click to select file
  connect(m_ui->widgetFiles, &LtsDataView::LtsDataView::signalDoubleClicked, this, &LtsFileDialogWidget::onSelectFile);

  // initial folder selection
  selectFolder();

  // selection changed File
  connect(m_ui->widgetFiles, &LtsDataView::LtsDataView::signalSelectionChanged, this, &LtsFileDialogWidget::enaDisa);

  // enable filename edit
  if (m_dialogMode == FileDialogMode::modeSaveFile)
  {
    m_ui->leFile->setEnabled(true);
    connect(m_ui->leFile, &QLineEdit::textChanged, this, &LtsFileDialogWidget::saveFileName);
  }

  // filtering on fileTypes
  if (m_fileTypes.contains(FileManagement::FileType::Unknown))  // no filtering
    m_ui->lblFilter->setVisible(false);
  else
  {
    QString labelFilter = tr("Filtering:") + QLatin1String(" <b>");
    QStringList types;
    types.reserve(m_fileTypes.size());
    for (auto &ft : m_fileTypes)
      types << toString(ft);
    labelFilter += types.join(QLatin1String(", "));
    labelFilter += QLatin1String("</b>");
    m_ui->lblFilter->setText(labelFilter);
  }

  enaDisa();

  return true;
}


//-----------------------------------------------------------------------------------------------------------
void LtsFileDialogWidget::selectFolder()
{
  QModelIndex idx;
  QItemSelectionModel *selectionModelFolder = m_ui->tvFolder->selectionModel();
  if (m_selectedFolderId > 0)
    idx = m_proxyModelFolder->mapFromSource(m_modelFolder->getIndex(m_selectedFolderId));
  if (idx.isValid())
    selectionModelFolder->setCurrentIndex(idx, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
  else
    selectionModelFolder->setCurrentIndex(m_modelFolder->index(0,0), QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
}

//-----------------------------------------------------------------------------------------------------------
void LtsFileDialogWidget::onFolderSelectionChanged(const QItemSelection& /*selected*/,
                                                   const QItemSelection& /*deselected*/)
{
  enaDisa();

  auto predicate = [this](const FileManagement::FileContent & fc, const QString &xmlType)
  {
    return showFile(fc, xmlType);
  };

  m_modelFile->initModel(m_dtc, m_opmDtc, m_xmlType, predicate);
}

//-----------------------------------------------------------------------------------------------------------
void LtsFileDialogWidget::requestReadingSelectedFile()
{
  emit readSelectedFile(m_selectedFileContent.id());
}

//-----------------------------------------------------------------------------------------------------------
FileManagement::FileContent LtsFileDialogWidget::onSelectFile()
{
  QModelIndex selIndex = m_ui->widgetFiles->currentIndex();

  if (!selIndex.isValid())
    return FileManagement::FileContent();

  m_selectedFileContent = m_modelFile->getRowData(selIndex.row());

  emit accepted();

  return m_selectedFileContent;
}

//-----------------------------------------------------------------------------------------------------------
void LtsFileDialogWidget::onChooseFileName()
{
  if ((m_dialogMode == FileDialogMode::modeSaveFile) && (!m_fileName.isEmpty()))
  {
    emit accepted();
  }
}

//----------------------------------------------------------------------------
void LtsFileDialogWidget::onFolderChanged(const FileManagement::Folder &data, DataModification modType)
{
  Q_UNUSED(data);
  Q_UNUSED(modType);
  m_modelFolder->initModel(m_session->exerciseId(), m_mainFolders);
  m_ui->tvFolder->expandAll();
  m_ui->tvFolder->setExpanded(m_proxyModelFolder->index(0,0),true);
  // select last selected folder
  selectFolder();
}

//----------------------------------------------------------------------------
void LtsFileDialogWidget::onFileChanged(const FileManagement::FileContent &data, DataModification modType)
{
  bool condition = showFile(data, m_xmlType);

  int row = 0;
  QModelIndex selIndex = m_ui->widgetFiles->currentIndex();

  if (selIndex.isValid())
    row = selIndex.row();

  if (modType == DataModification::eRemoved)
  {
    m_modelFile->removeRow(row);
    return;
  }
  if (modType == DataModification::eAdded && condition)
  {
    m_modelFile->insertRow(data);
    return;
  }
  if (modType == DataModification::eModified && condition)
  {
    m_modelFile->setRowData(row, data);
    return;
  }
}

//-----------------------------------------------------------------------------------------------------------
QString LtsFileDialogWidget::dragMimeType() const
{
  return (m_modelFile) ? m_modelFile->mimeTypes().value(0) : QString();
}

//-----------------------------------------------------------------------------------------------------------
void LtsFileDialogWidget::saveFileName(const QString &name)
{
  m_fileName = name;
  m_selectedFileContent = FileManagement::FileContent();

  emit enableButtons();
}

//-----------------------------------------------------------------------------------------------------------
QModelIndex LtsFileDialogWidget::selectedIndexViewFolder()
{
  QItemSelectionModel *selectionModel =  m_ui->tvFolder->selectionModel();
  QModelIndexList indexL = selectionModel->selectedRows(0);
  if(indexL.size() == 0)
    return {};
  return m_proxyModelFolder->mapToSource(indexL.at(0));
}

//-----------------------------------------------------------------------------------------------------------
void LtsFileDialogWidget::enaDisa()
{
  QModelIndex idxFolder = selectedIndexViewFolder();

  if (idxFolder.isValid())
  {
    QString folderName = m_modelFolder->getFolderName(m_modelFolder->getFolder(idxFolder));
    m_ui->lblSelectedFolder->setText(folderName);
    m_selectedFolderId = m_modelFolder->getFolder(idxFolder).id();
  }
  else
  {
    m_ui->lblSelectedFolder->setText(tr("None"));
    m_selectedFolderId = 0;
  }

  // files
  QModelIndex idxFile = m_ui->widgetFiles->currentIndex();
  if (idxFile.isValid())
  {
    m_selectedFileContent = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());
    m_fileName = QString::fromStdString(m_selectedFileContent.name());
    m_ui->leFile->setText(m_fileName);
  }
  else
  {
    m_selectedFileContent = FileManagement::FileContent();
    if (m_dialogMode != FileDialogMode::modeSaveFile)
    {
      m_fileName = QString();
      m_ui->leFile->setText(m_fileName);
    }
  }

  emit enableButtons();
}

//--------------------------------------------------------------------------
bool LtsFileDialogWidget::showFile(const FileManagement::FileContent &fc, const QString &xmlType)
{
  if (fc.isDeleted())
    return false;

  if (fc.folderId() != m_selectedFolderId)
    return false;

  if (!m_fileTypes.isEmpty() && !m_fileTypes.contains(fc.fileType()))
    return false;

  if (fc.fileStatus() != FileManagement::FileStatus::Valid)
    return false;

  // get folder selected
  const QModelIndex selIndex = selectedIndexViewFolder();
  const NGLTreeItem *item = m_modelFolder->privateData(selIndex);
  const FileManagement::Folder fld = item->data().value<FileManagement::Folder>();
  const auto &fldPath = fld.path();

  // filter in USER DOCUMENTS folder and subfolders
  if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::UserDocuments))
  {
    const int operatorId = LtsSessionData::LtsSessionData::getInstance()->getOperatorId();
    // filter on User Category and OperatorId
    if (fc.fileCategory() == FileManagement::FileCategory::User &&
        fc.operatorId() != operatorId)
      return false;
  }

  // filter in EXERCISE DOCUMENTS folder and subfolders
  if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::ExerciseDocuments))
  {
    // filter on Category = Exercise
    if (fc.fileCategory() != FileManagement::FileCategory::Exercise)
      return false;
    if (m_session->exerciseId() > 0)
    {
      // filter on exact exerciseId
      if (fc.exerciseId() != m_session->exerciseId())
        return false;
    }
  }

  // filter on XmlType
  if (fc.fileType() == FileManagement::FileType::Xml && !xmlType.isEmpty() && fc.properties().size() > 0)
  {
    const QString &prop = QString::fromStdString(fc.properties());
    if (!prop.contains(xmlType, Qt::CaseSensitive))
    {
      return false;
    }
  }

  return true;

}

} // namespace LtsWidgets