/**
  * @RDE_HEADER@
  * FileManagement - FileExplorer dialog
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Iuliana Ojog, SLSE, 2017-05-11
  */

#include "flm_dialog.h"
#include "ui_flm_dialog.h"

#include "flm_dialog_model_folder.h"
#include "flm_dialog_model_file.h"
#include "flm_edit_folder.h"
#include "flm_edit_file_content.h"
#include "flm_preview_file_dialog.h"
#include "flm_office_integration.h"
#include <FileManagement/flm_translation.h>
#include <FileManagement/flm_operator_rights.h>
#include <PluginInterfaces/gui_plugin_interface.h>
#include <Plugins/FileManagement/flm_data_plugin_interface.h>
#include <Plugins/FileManagement/flm_combobox_gui_plugin_interface.h>
#include <Plugins/FileManagement/flm_explorer_gui_plugin_interface.h>
#include <Plugins/OperatorManagement/opm_data_plugin_interface.h>
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
#include <Plugins/ParticipantManagement/ppm_data_plugin_interface.h>

#include <LtsSession/lts_session_data.h>

#include <LtsDataView/lts_data_view.h>
#include <LtsSession/lts_session_data.h>
#include <LtsUtilsCore/dds_vector.h>
#include <LtsUtilsSettings/settings.h>
#include <LtsWidgets/lts_base_layout_widget.h>
#include <nglwidgets/ngltreeitem.h>
#include <ngltools/ngltools_filesystem.h>

#include <QFileDialog>
#include <QFileInfo>
#include <QMenu>

namespace FileManagement
{

//-----------------------------------------------------------------------------------------------------------
// FileManagementDialogWidget
//-----------------------------------------------------------------------------------------------------------
FileManagementDialogWidget::FileManagementDialogWidget(QWidget *parent)
  : QWidget(parent)
  , m_ui(new Ui::FileManagementDialogWidget)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_logger(getLogger("FileManagementDialog"))
{
  m_ui->setupUi(this);
  if (LtsSessionData::LtsSessionData::getInstance()->isTablet())
    m_ui->leFile->setFocusPolicy(Qt::ClickFocus);
  m_ui->widgetFiles->setToolButtonsVisible(false);
  m_ui->widgetFiles->setColumnCountVisible(false);
}

//-----------------------------------------------------------------------------------------------------------
FileManagementDialogWidget::~FileManagementDialogWidget()
{
  delete m_getContent;
  delete m_ui;
}

//-----------------------------------------------------------------------------------------------------------
FileManagementDialogTab::~FileManagementDialogTab()
{
  delete m_editItemWidget;
}

//-----------------------------------------------------------------------------------------------------------
FileManagementDialog::~FileManagementDialog()
{
  delete m_editItemWidget;
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogTab::retranslate()
{
  if (m_dialogMode == FileDialogMode::Admin)
    translate(m_editItemWidget->m_ui, tr("Manage Library"));
  else
    translate(m_editItemWidget->m_ui, tr("Organize Library"));
}

//-----------------------------------------------------------------------------------------------------------
bool FileManagementDialogWidget::init(LtsSession::LtsSession *session,                 
                                      FileDialogMode dlgMode,
                                      const QVector<FileType> &fileTypes,
                                      int folderId,
                                      const QString &xmlType)
{
  DEBUG_LOG(m_logger) << "Start init FileManagementDialogWidget";
  if (!session)
  {
    ERROR_LOG(m_logger) << "Failed to init FileManagementDialogWidget";
    return false;
  }

  m_session = session;

  if (!session->getDtc<FileManagement::DataInterface>(m_dtc))
    return false;
  if (!session->getFtc<FileManagement::DataInterface>(m_ftc))
    return false;
  if (!session->getDtc<OperatorManagement::DataInterface>(m_opmDtc))
    return false;
  if (!session->getDtc<ExerciseManagement::DataInterface>(m_exmDtc))
    return false;
  if (!session->getDtc<ParticipantManagement::DataInterface>(m_ppmDtc))
    return false;
  if (!session->getForeignGuiInterface<FileManagement::ForeignGuiComboboxInterface>(m_flmGuiCbxIfc))
    return false;

  m_dialogMode = dlgMode;
  m_fileTypes = fileTypes;
  m_selectedFolderId = folderId;
  m_xmlType = xmlType;

  m_isAdminMode = (m_dialogMode == FileDialogMode::Admin);

  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();
  m_ppmDtc->enableParty();
  m_ppmDtc->waitForHistoricalDataParty();

  m_getContent = new FileManagement::GetFileContent(m_ftc, this);

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

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

  m_modelFolder = new DialogModelFolder(this, rootItem,
                                        QStringList()
                                        << tr("Name"));
  //                                    << tr("Operator") << tr("Id") << tr("Path") << tr("Parent") << tr("Editable"));

  DEBUG_LOG(m_logger) << "Start init model folder";
  m_modelFolder->init(m_session, m_isAdminMode);
  int opId = LtsSessionData::LtsSessionData::getInstance()->getOperatorId();
  if (m_dialogMode == FileDialogMode::Admin) // no filter on operator folders for admin
    opId = 0;
  m_proxyModelFolder = new DialogModelProxyFolder(this);
  m_proxyModelFolder->setOperatorId(opId);
  m_proxyModelFolder->setSourceModel(m_modelFolder);
  m_proxyModelFolder->sort(DialogModelFolder::Columns::NAME, Qt::AscendingOrder);

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

  DEBUG_LOG(m_logger) << "Start init model file content";
  // initial all valid, not-deleted files
  auto predicate = [this](const FileManagement::FileContent &fc, const QString &xmlType)
  {
    if (!m_isAdminMode && fc.isHidden())
      return false;

    return (!fc.isDeleted() && fc.fileStatus() == FileManagement::FileStatus::Valid &&
           (xmlType.isEmpty() || fc.properties().find(xmlType.toStdString()) != std::string::npos));
  };
  m_modelFile->initModel(m_session, xmlType, predicate);

  // UI
  m_ui->tvFolder->setModel(m_proxyModelFolder);
  m_ui->tvFolder->expandAll();
  m_ui->tvFolder->setExpanded(m_proxyModelFolder->index(0, 0), true);

  m_proxyModelFile = new DialogFileProxyModel(this);
  m_proxyModelFile->setSourceModel(m_modelFile);
  m_ui->widgetFiles->setModel(m_proxyModelFile);

  m_ui->widgetFiles->hideColumn(FOLDER);
#ifndef LTS_DEBUG
  m_ui->widgetFiles->hideColumn(FILEID);
#endif

  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
  const bool enableEditPhases = ps->value(QStringLiteral("exm"),
                                          QStringLiteral("enableEditPhases")).toBool();
  if (!enableEditPhases)
  {
    m_ui->widgetFiles->hideColumn(PHASE);
  }

  // double click data view files / select file
  if (m_dialogMode == FileDialogMode::OpenFile || m_dialogMode == FileDialogMode::SaveFile)
  {
    DEBUG_LOG(m_logger) << "Init dialog for open/save modal dialog";

    // double click to select
    connect(m_ui->widgetFiles, &LtsDataView::LtsDataView::signalDoubleClicked, this, &FileManagementDialogWidget::onSelectFile);
  }
  else
  {
    if (!LtsSessionData::LtsSessionData::getInstance()->isTablet())
    {
      // double click tree view folders
      connect(m_ui->tvFolder, &QTreeView::doubleClicked, this, &FileManagementDialogWidget::onEditFolder);

      // double click to edit file metadata
      connect(m_ui->widgetFiles, &LtsDataView::LtsDataView::signalDoubleClicked, this, &FileManagementDialogWidget::onEditFile);
    }
    // ContextMenu Folder actions
    m_ui->tvFolder->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(m_ui->tvFolder, &QTreeView::customContextMenuRequested, this, &FileManagementDialogWidget::folderContextMenuRequested);

    // ContextMenu File actions
    m_ui->widgetFiles->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(m_ui->widgetFiles, &LtsDataView::LtsDataView::customContextMenuRequested, this, &FileManagementDialogWidget::fileContextMenuRequested);
  }

  m_actionAddFolder = new QAction(QIcon(QLatin1String("icon:add.svg")), tr("Add Folder"), this);
  connect(m_actionAddFolder, &QAction::triggered, this, &FileManagementDialogWidget::onAddFolder);

  m_actionRenameFolder = new QAction(QIcon(QLatin1String("icon:edit.svg")), tr("Rename Folder"), this);
  connect(m_actionRenameFolder, &QAction::triggered, this, &FileManagementDialogWidget::onEditFolder);

  m_actionRemoveFolder = new QAction(QIcon(QLatin1String("icon:remove.svg")), tr("Remove Folder"), this);
  connect(m_actionRemoveFolder, &QAction::triggered, this, &FileManagementDialogWidget::onRemoveFolder);

  m_actionRefreshFolders = new QAction(QIcon(QLatin1String("icon:restart.svg")), tr("Refresh Folders"), this);
  connect(m_actionRefreshFolders, &QAction::triggered, this, &FileManagementDialogWidget::onRefreshFolders);

  m_actionCopyFolder = new QAction(QIcon(QLatin1String(":icons/16x16/edit-copy.png")), tr("Copy Folder"), this);
  connect(m_actionCopyFolder, &QAction::triggered, this, &FileManagementDialogWidget::onCopyFolder);

  m_actionCutFolder = new QAction(QIcon(QLatin1String("icon:edit-cut.svg")), tr("Cut Folder"), this);
  connect(m_actionCutFolder, &QAction::triggered, this, &FileManagementDialogWidget::onCutFolder);

  m_actionPasteFolder = new QAction(QIcon(QLatin1String(":icons/16x16/edit-paste.png")), tr("Paste Folder"), this);
  connect(m_actionPasteFolder, &QAction::triggered, this, &FileManagementDialogWidget::onPasteFolder);

  m_actionImportFile = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("Import File"), this);
  connect(m_actionImportFile, &QAction::triggered, this, &FileManagementDialogWidget::onImportFile);

  m_actionNewOfficeExcel = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New Excel File"), this);
  connect(m_actionNewOfficeExcel, &QAction::triggered, this, &FileManagementDialogWidget::onNewOfficeExcel);

  m_actionNewOfficeWord = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New Word File"), this);
  connect(m_actionNewOfficeWord, &QAction::triggered, this, &FileManagementDialogWidget::onNewOfficeWord);

  m_actionNewOfficePowerPoint = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New PowerPoint File"), this);
  connect(m_actionNewOfficePowerPoint, &QAction::triggered, this, &FileManagementDialogWidget::onNewOfficePowerPoint);

  m_actionNewLibreOfficeWrite = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New LibreOffice-Writer File"), this);
  connect(m_actionNewLibreOfficeWrite, &QAction::triggered, this, &FileManagementDialogWidget::onNewLibreOfficeWrite);

  m_actionNewLibreOfficeCalc = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New LibreOffice-Calc File"), this);
  connect(m_actionNewLibreOfficeCalc, &QAction::triggered, this, &FileManagementDialogWidget::onNewLibreOfficeCalc);

  m_actionNewLibreOfficePresent = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New LibreOffice-Impress File"), this);
  connect(m_actionNewLibreOfficePresent, &QAction::triggered, this, &FileManagementDialogWidget::onNewLibreOfficePresent);

  m_actionNewFromTemplate = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New from Template"), this);
  connect(m_actionNewFromTemplate, &QAction::triggered, this, &FileManagementDialogWidget::onNewFileFromTemplate);


  m_actionEditFile = new QAction(QIcon(QLatin1String("icon:document-edit.svg")), tr("Edit Properties"), this);
  connect(m_actionEditFile, &QAction::triggered, this, &FileManagementDialogWidget::onEditFile);

  m_actionDeleteFile = new QAction(QIcon(QLatin1String("icon:document-remove.svg")), tr("Delete File"), this);
  connect(m_actionDeleteFile, &QAction::triggered, this, &FileManagementDialogWidget::onDeleteFile);

  m_actionPreviewFile = new QAction(QIcon(QLatin1String("icon:document-preview.svg")), tr("Preview File"), this);
  connect(m_actionPreviewFile, &QAction::triggered, this, &FileManagementDialogWidget::onPreviewFile);

  m_actionCopyFile = new QAction(QIcon(QLatin1String(":icons/16x16/edit-copy.png")), tr("Copy File"), this);
  connect(m_actionCopyFile, &QAction::triggered, this, &FileManagementDialogWidget::onCopyFile);

  m_actionCutFile = new QAction(QIcon(QLatin1String(":icons/16x16/edit-cut.png")), tr("Cut File"), this);
  connect(m_actionCutFile, &QAction::triggered, this, &FileManagementDialogWidget::onCutFile);

  m_actionPasteFile = new QAction(QIcon(QLatin1String(":icons/16x16/edit-paste.png")), tr("Paste File"), this);
  connect(m_actionPasteFile, &QAction::triggered, this, &FileManagementDialogWidget::onPasteFile);

  m_actionExportFile = new QAction(QIcon(QLatin1String(":icons/16x16/document-save.png")), tr("Export File"), this);
  connect(m_actionExportFile, &QAction::triggered, this, &FileManagementDialogWidget::onExportFile);

  m_actionRemoveFile = new QAction(QIcon(QLatin1String(":icons/16x16/edit-delete.png")), tr("Remove File"), this);
  connect(m_actionRemoveFile, &QAction::triggered, this, &FileManagementDialogWidget::onRemoveFile);

  m_actionRestoreFile = new QAction(QIcon(QLatin1String(":icons/16x16/edit-undo.png")), tr("Restore File"), this);
  connect(m_actionRestoreFile, &QAction::triggered, this, &FileManagementDialogWidget::onRestoreFile);

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

  // initial folder selection
  selectFolder();

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

  // enable filename edit
  if (m_dialogMode == FileDialogMode::SaveFile)
  {
    DEBUG_LOG(m_logger) << "DialogMode Save";
    m_ui->leFile->setEnabled(true);
    connect(m_ui->leFile, &QLineEdit::textChanged, this, &FileManagementDialogWidget::saveFileName);
  }

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

  enaDisa();

  return true;
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::saveFileName(const QString &name)
{
  DEBUG_LOG(m_logger) << "Saving: " << name;

  m_fileName            = name;
  m_selectedFileContent = m_modelFile->findFileFromName(name);

  emit enableButtons();
}

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

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::enaDisa()
{
  bool userHasRightsToEditFolder;
  bool userHasRightsToEditFiles;
  bool userhasAdminRights = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::FileManagementFileAdmin);
  if (userhasAdminRights)
  {
    userHasRightsToEditFolder = true;
    userHasRightsToEditFiles = true;
  }
  else
  {
    userHasRightsToEditFolder = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::FileManagementFoldersEdit);
    userHasRightsToEditFiles  = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::FileManagementFilesEdit);
  }

  // folders
  bool enableAddFolder = false;
  bool enableEditFolder = false;
  bool enableRemoveFolder = false;

  m_actionCutFolder->setEnabled(false);
  m_actionPasteFolder->setEnabled(false);
  m_actionCopyFolder->setEnabled(false);

  // files
  bool enableImportFile = false;
  bool enableNewFile = false;
  bool enableNewFileFromTemplate = false;
  bool enableEditFile = false;
  bool enableDeleteFile = false;
  bool enablePreviewFile = false;
  bool enableExportFile = false;
  bool enableRemoveFile = false;
  bool enableRestoreFile = false;
  bool isOffice = false;

  m_actionCutFile->setEnabled(false);
  m_actionPasteFile->setEnabled(false);
  m_actionCopyFile->setEnabled(false);

  QModelIndex idxFolder = selectedIndexViewFolder();

  if (idxFolder.isValid())
  {
    m_selectedFolderId = m_modelFolder->getFolder(idxFolder).id();

    const auto fldPath = m_dtc->folder(m_selectedFolderId).path();
//   [GUEZE-3142]
//   User can add new Exercise folder; User can only rename / remove folder he created;
//   Admin User operatorId = 99 can remove folder created by users.
//    if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::ExerciseDocuments))
//      enableAddFolder = false; // not possible to add folders under Exercise
//    else
      enableAddFolder = true;

    if (isFolderRemovable(idxFolder))
    {
      enableEditFolder = true;
      enableRemoveFolder = true;
    }

    QString folderName = m_modelFolder->getFolderName(m_modelFolder->getFolder(idxFolder));
    m_ui->lblSelectedFolder->setText(folderName);

    m_actionCopyFolder->setEnabled(true && userHasRightsToEditFolder);
    m_actionCutFolder->setEnabled(enableRemoveFolder && userHasRightsToEditFolder);
    if (m_copyFolder.id() > 0)
      m_actionPasteFolder->setEnabled(true && userHasRightsToEditFolder);

    enableImportFile = true;
    enableNewFile = true;
  }
  else
  {
    m_ui->lblSelectedFolder->setText(tr("None"));
    m_selectedFolderId = 0;
  }

  DEBUG_LOG(m_logger) << "enableRemoveFolder=" << enableRemoveFolder;
  DEBUG_LOG(m_logger) << "enableEditFolder=" << enableEditFolder;
  DEBUG_LOG(m_logger) << "userHasRightsToEditFolder=" << userHasRightsToEditFolder;

  m_actionAddFolder->setEnabled(enableAddFolder && userHasRightsToEditFolder);
  m_actionRemoveFolder->setEnabled(enableRemoveFolder && userHasRightsToEditFolder);
  m_actionRenameFolder->setEnabled(enableEditFolder && userHasRightsToEditFolder);

  m_actionRefreshFolders->setEnabled(true);

  // files
  QModelIndex idxFile = m_ui->widgetFiles->currentIndex();
  if (idxFile.isValid())
  {
    FileManagement::FileContent data = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());
    enableEditFile = true;
    if (data.isTemplate() || data.isUsedBy())
      enableDeleteFile = false;
    else
      enableDeleteFile = true;

    if (data.fileStatus() == FileManagement::FileStatus::Deleted)
    {
      enableDeleteFile = false;
      enableRestoreFile = true;
    }
    else
    {
#ifndef LTS_DEBUG
      if (data.fileType() != FileManagement::FileType::Xml
          && data.fileType() != FileManagement::FileType::OperatorDefinedSymbol
          && data.fileType() != FileManagement::FileType::OperatorFavourite
          && data.fileType() != FileManagement::FileType::EvaluationSchema
          && data.fileType() != FileManagement::FileType::TacticalPlan)
#endif
        enablePreviewFile = true;
      isOffice =  (data.fileType() == FileManagement::FileType::OpenOfficeDocument ||
                   data.fileType() == FileManagement::FileType::OpenOfficeSpreadsheet ||
                   data.fileType() == FileManagement::FileType::OpenOfficePresentation ||
                   data.fileType() == FileManagement::FileType::MSOfficeDocument ||
                   data.fileType() == FileManagement::FileType::MSOfficeDocument97 ||
                   data.fileType() == FileManagement::FileType::MSOfficeSpreadsheet ||
                   data.fileType() == FileManagement::FileType::MSOfficeSpreadsheet97 ||
                   data.fileType() == FileManagement::FileType::MSOfficePresentation ||
                   data.fileType() == FileManagement::FileType::MSOfficePresentation97);
      enableRestoreFile = false;
      if (data.isTemplate())
        enableNewFileFromTemplate = true;
    }
    m_selectedFileContent = data;
    m_fileName = QString::fromStdString(data.name());
    m_ui->leFile->setText(m_fileName);

    enableExportFile = true; // export file always enabled, needed in AHTC
    if (m_dialogMode != FileDialogMode::Admin)
    {
      enableRemoveFile = false;
      enableRestoreFile = false;
    }
    else
    {
      if (data.isTemplate() || data.isUsedBy())
        enableRemoveFile = false;
      else
        enableRemoveFile = true;
    }
  }
  else
  {
    enableExportFile = false;
    m_selectedFileContent = FileManagement::FileContent();
    if (m_dialogMode != FileDialogMode::SaveFile)
    {
      m_fileName.clear();
      m_ui->leFile->setText(m_fileName);
    }
  }

  m_actionImportFile->setEnabled(enableImportFile && userHasRightsToEditFiles);
  m_actionNewOfficeWord->setEnabled(enableNewFile && userHasRightsToEditFiles);
  m_actionNewOfficeExcel->setEnabled(enableNewFile && userHasRightsToEditFiles);
  m_actionNewOfficePowerPoint->setEnabled(enableNewFile && userHasRightsToEditFiles);
  m_actionNewLibreOfficeWrite->setEnabled(enableNewFile && userHasRightsToEditFiles);
  m_actionNewLibreOfficeCalc->setEnabled(enableNewFile && userHasRightsToEditFiles);
  m_actionNewLibreOfficePresent->setEnabled(enableNewFile && userHasRightsToEditFiles);
  m_actionNewFromTemplate->setEnabled(enableNewFileFromTemplate && userHasRightsToEditFiles);
  m_actionEditFile->setEnabled(enableEditFile && userHasRightsToEditFiles);
  m_actionDeleteFile->setEnabled(enableDeleteFile && userHasRightsToEditFiles);

  m_actionPreviewFile->setData(QVariant(isOffice));
  m_actionPreviewFile->setEnabled(enablePreviewFile);

  m_actionExportFile->setEnabled(enableExportFile && userHasRightsToEditFiles);
  m_actionRemoveFile->setEnabled(enableRemoveFile && userhasAdminRights);
  m_actionRestoreFile->setEnabled(enableRestoreFile && userhasAdminRights);

  m_actionCopyFile->setEnabled(enableEditFile && userHasRightsToEditFiles);
  m_actionCutFile->setEnabled(enableDeleteFile && userHasRightsToEditFiles);
  if (m_copyFile.id() > 0) // copy - paste
    m_actionPasteFile->setEnabled(true && userHasRightsToEditFiles);

  emit enableButtons();

}

//-----------------------------------------------------------------------------------------------------------
bool FileManagementDialogWidget::isFolderRemovable(const QModelIndex &idx) const
{
  DEBUG_LOG(m_logger) << "isFolderRemovable index = " << idx.row();

  if (!idx.isValid())
    return false;

  if (!m_modelFolder->isRowRemovable(m_modelFolder->privateData(idx)))
    return false;

  // not allowed to delete the main folders
  if (m_modelFolder->privateData(idx)->data().value<FileManagement::Folder>().id() == FileManagement::MainFolder::GlobalDocuments ||
      m_modelFolder->privateData(idx)->data().value<FileManagement::Folder>().id() == FileManagement::MainFolder::ExerciseDocuments ||
      m_modelFolder->privateData(idx)->data().value<FileManagement::Folder>().id() == FileManagement::MainFolder::UserDocuments)
    return false;

  // Organisator id 99 can remove any folder, another operator can remove only own folders, regardless of child folders owners
  int opId = LtsSessionData::LtsSessionData::getInstance()->getOperatorId();
  bool userhasAdminRights = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::FileManagementFileAdmin);
  if (!userhasAdminRights && opId != 99 && m_modelFolder->privateData(idx)->data().value<FileManagement::Folder>().operatorId() != opId)
    return false;

  // check if subfolders are removable too
  const auto children = m_modelFolder->privateData(idx)->children();
  for (const auto child : children)
    if (!m_modelFolder->isRowRemovable(child))
      return false;

  return true;
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onReject()
{
  m_selectedFileContent = FileManagement::FileContent();
  m_selectedFolderId = -1;
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onAddFolder()
{
  DEBUG_LOG(m_logger) << "onAddFolder";

  QModelIndex selIndex = selectedIndexViewFolder();
  if (!selIndex.isValid())
    return;

  if (m_selectedFolderId > 0)   // valid selection
  {
    FolderEditDialog *dialog = new FolderEditDialog(this);
    if (!dialog->init(selIndex, 0, m_selectedFolderId, m_dtc, m_ftc, m_isAdminMode))
    {
      delete dialog;
      return;
    }

    QObject::connect(dialog, &FolderEditDialog::rejected, dialog, &FolderEditDialog::deleteLater);

    dialog->show();

  }
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onPasteFolder()
{
  DEBUG_LOG(m_logger) << "onPasteFolder";

  QModelIndex selIndex = selectedIndexViewFolder();
  if (!selIndex.isValid())
    return;

  if (m_selectedFolderId > 0)   // valid selection
  {
    FolderEditDialog *dialog = new FolderEditDialog(this);
    if (!dialog->init(selIndex, 0, m_selectedFolderId, m_dtc, m_ftc, m_isAdminMode, m_copyFolder))
    {
      delete dialog;
      return;
    }

    QObject::connect(dialog, &FolderEditDialog::rejected, dialog, &FolderEditDialog::deleteLater);
    dialog->show();
  }
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onPasteFile()
{
  DEBUG_LOG(m_logger) << "onPasteFile";

  if (m_selectedFolderId > 0 && m_copyFile.id() > 0)
  {
    m_copyFile.id(0);   // we need new id
    if (m_selectedFolderId == m_copyFile.folderId() && m_copyFile.name() == m_selectedFileContent.name()) // we need new name if we paste in same folder
    {
      QString newName = QString::fromStdString(m_copyFile.name()) + tr(" (Copy)");
      m_copyFile.name(newName.toStdString());
    }
    m_copyFile.folderId(m_selectedFolderId);

    // reset exercise id and phase id
    int exId = 0;
    int phId = 0;
    m_copyFile.exerciseId();
    m_copyFile.phaseId();

    // change category regardless of original category
    const auto fldPath = m_dtc->folder(m_selectedFolderId).path();

    if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::UserDocuments))
      m_copyFile.fileCategory(FileManagement::FileCategory::User);
    else if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::ExerciseDocuments))
    {
      m_copyFile.fileCategory(FileManagement::FileCategory::Exercise);

      if (fldPath.size() >= 2) // means we are in a specific exercise folder
      {
        exId = m_dtc->getExerciseId(fldPath.at(1));
        if (exId > 0 && fldPath.size() >= 4)  // we got an exercise Id and we are in a phase sub-folder
          phId = m_dtc->getExerciseId(fldPath.at(3));
      }
      else // using current exercise id and phase id
      {
        if (m_session->exerciseId() > 0)
        {
          exId = m_session->exerciseId();
          if (m_session->exerciseData()->phId > 0)
            phId = m_session->exerciseData()->phId;
        }
      }

      if (exId > 0)
        m_copyFile.exerciseId(exId);
      if (phId > 0)
        m_copyFile.phaseId(phId);

    }
    else
      m_copyFile.fileCategory(FileManagement::FileCategory::Global);   // global

    FileContentEditDialog *dialog = new FileContentEditDialog(this);
    QString folderName = m_modelFolder->getFolderName(m_dtc->folder(m_selectedFolderId));    

    if (!dialog->init(m_session, QModelIndex(), m_isAdminMode, folderName, m_copyFile, m_content))
    {
      delete dialog;
      return;
    }

    QObject::connect(dialog, &FolderEditDialog::rejected, dialog, &FolderEditDialog::deleteLater);

    dialog->show();
  }
}


//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onRemoveFolder()
{
  DEBUG_LOG(m_logger) << "onRemoveFolder id = " << m_selectedFolderId;

  QModelIndex selIndex = selectedIndexViewFolder();
  if (!selIndex.isValid())
    return;

  if (LtsWidgets::LtsMessageDialog::showMessage(this, tr("Yes - remove folder, subfolders and all files contained.<br>"
                                                         "No - do not remove folder.<br>"),
                                                tr("Do you really want to remove folder and all files contained?"),
                                                LtsWidgets::Behaviour::Modal,
                                                LtsWidgets::Button::Yes | LtsWidgets::Button::No) != LtsWidgets::Button::Yes)
  {
    return; // do nothing if not confirmed by user
  }

  // check if folder and all subfolders are removable
  if (isFolderRemovable(selIndex))
  {
    DEBUG_LOG(m_logger) << "Removing folder id = " << m_selectedFolderId;

    Core::RemoveElementRequest req(m_selectedFolderId);
    m_requestHelper->startSingleRequest([req, this]()
    {
      return m_ftc->folderRemoveRequest(req, this);
    });
    if (m_requestHelper->failed())
      ERROR_LOG(m_logger) << "Failed to remove folder id = " << m_selectedFolderId;
  }
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::removeCurrentRowFolder()
{
  DEBUG_LOG(m_logger) << "removeCurrentRowFolder";

  QModelIndex selIndex = selectedIndexViewFolder();
  NGLTreeItem *item = m_modelFolder->privateData(selIndex);
  FileManagement::Folder fld = item->data().value<FileManagement::Folder>();
  bool isRootFolder = (fld.id() == 0);

  DEBUG_LOG(m_logger) << "isRootFolder = " << isRootFolder;

  if (!selIndex.isValid() || isRootFolder)
    return;

  m_modelFolder->onDeleteRow(selIndex, true);
}

//-----------------------------------------------------------------------------------------------------------
QString FileManagementDialogWidget::getTemplateFile(const QString &fileName)
{
  return NGL::findFile(NGL::FileType::ConfigFile, fileName);
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onRefreshFolders()
{
  DEBUG_LOG(m_logger) << "onRefreshFolders";

  m_modelFolder->initModel(m_session->exerciseId(), m_isAdminMode);
  m_ui->tvFolder->expandAll();
  m_ui->tvFolder->selectionModel()->clearSelection();

  enaDisa();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onCopyFolder()
{
  DEBUG_LOG(m_logger) << "onCopyFolder";

  QModelIndex selIndex = selectedIndexViewFolder();
  NGLTreeItem *item = m_modelFolder->privateData(selIndex);
  m_copyFolder = item->data().value<FileManagement::Folder>();
  m_copyFolder.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());

  enaDisa();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onCopyFile()
{
  DEBUG_LOG(m_logger) << "onCopyFile";

  m_copyFile = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());

  m_getContent->getContent(m_copyFile.id(), m_content);

  enaDisa();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onCutFolder()
{
  DEBUG_LOG(m_logger) << "onCutFolder";

  QModelIndex selIndex = selectedIndexViewFolder();
  NGLTreeItem *item = m_modelFolder->privateData(selIndex);
  m_copyFolder = item->data().value<FileManagement::Folder>();

  // TODO: only after a succesful Paste??
  onRemoveFolder();

  enaDisa();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onCutFile()
{
  DEBUG_LOG(m_logger) << "onCutFile";

  m_copyFile = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());

  m_getContent->getContent(m_copyFile.id(), m_content);

  onDeleteFile();

  enaDisa();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onEditFolder()
{
  DEBUG_LOG(m_logger) << "onEditFolder Id = " << m_selectedFolderId;

  if (!m_actionRenameFolder->isEnabled())
    return;

  QModelIndex selIndex = selectedIndexViewFolder();
  if (!selIndex.isValid())
    return;

  if (m_selectedFolderId > 0)   // valid selection
  {
    FileManagement::Folder data = m_modelFolder->privateData(selIndex)->data().value<FileManagement::Folder>();

    FolderEditDialog *dialog = new FolderEditDialog(this);
    if (!dialog->init(selIndex, m_selectedFolderId, 0, m_dtc, m_ftc, m_isAdminMode, data))
    {
      delete dialog;
      return;
    }

    dialog->setAttribute(Qt::WA_DeleteOnClose);

    dialog->show();
  }
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onRemoveFile()
{
  const QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
  if (!selIndex.isValid())
    return;

  if (LtsWidgets::LtsMessageDialog::showMessage(this, tr("Yes - remove file.<br>"
                                                         "No - do not remove file.<br>"),
                                                tr("Do you really want to remove this file?"),
                                                LtsWidgets::Behaviour::Modal,
                                                LtsWidgets::Button::Yes | LtsWidgets::Button::No) != LtsWidgets::Button::Yes)
  {
    return; // do nothing if not confirmed by user
  }

  DEBUG_LOG(m_logger) << "onRemoveFile";

  FileManagement::FileContent data = m_modelFile->getRowData(selIndex.row());
  Core::RemoveElementRequest req(data.id());
  m_requestHelper->startSingleRequest([req, this]()
  {
    return m_ftc->fileContentRemoveRequest(req, this);
  });

  if (m_requestHelper->failed())
    ERROR_LOG(m_logger) << "Failed to remove file content";
  else
    reInitModelFile();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onDeleteFile()
{
  QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
  if (!selIndex.isValid())
    return;

  DEBUG_LOG(m_logger) << "onDeleteFile";

  m_requestHelper->startSingleRequest([this]()
  {
    FileManagement::FileContent data = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());

    if (data.fileStatus() == FileManagement::FileStatus::Deleted)
      return int64_t(0);

    DEBUG_LOG(m_logger) << "Deleting file id = " << data.id();

    FileManagement::FileContentChangeStatusRequest req;
    req.id(data.id());

    req.fileStatus(FileManagement::FileStatus::Deleted);
    req.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
    req.lastModified(QDateTime::currentMSecsSinceEpoch());

    return m_ftc->fileContentChangeStatusRequest(FileContentChangeStatusRequest(req), this);
  });

  if (m_requestHelper->failed())
    ERROR_LOG(m_logger) << "Failed to change status file content";
  else
    reInitModelFile();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::reInitModelFile(bool restoreSelected)
{
  int selectedFileId = 0;
  if (restoreSelected)
  {
    QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
    if (selIndex.isValid())
    {
      selectedFileId = m_modelFile->getRowData(selIndex.row()).id();
      ERROR_LOG(m_logger) << "Selected file id = " << selectedFileId;
    }
  }
  else
  {
    m_ui->widgetFiles->setCurrentIndex(QModelIndex());
  }

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

  m_modelFile->initModel(m_session, m_xmlType, predicate);

  if (restoreSelected && selectedFileId > 0)
  {
    DEBUG_LOG(m_logger) << "Restoring selection on file " << selectedFileId;
    QModelIndex idx = m_modelFile->findIndexForId(selectedFileId);
    if (idx.isValid())
      m_ui->widgetFiles->setCurrentIndex(idx);
  }
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onRestoreFile()
{
  QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
  if (!selIndex.isValid())
    return;

  DEBUG_LOG(m_logger) << "onRestoreFile";

  m_requestHelper->startSingleRequest([this]()
  {
    FileManagement::FileContent data = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());

    if (data.fileStatus() == FileManagement::FileStatus::Valid)
      return int64_t(0);

    DEBUG_LOG(m_logger) << "Deleting file id = " << data.id();

    FileManagement::FileContentChangeStatusRequest req;
    req.id(data.id());

    req.fileStatus(FileManagement::FileStatus::Valid);
    req.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
    req.lastModified(QDateTime::currentMSecsSinceEpoch());

    return m_ftc->fileContentChangeStatusRequest(FileContentChangeStatusRequest(req), this);
  });

  if (m_requestHelper->failed())
    ERROR_LOG(m_logger) << "Failed to change status file content";
  else
    reInitModelFile();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onEditFile()
{
  DEBUG_LOG(m_logger) << "onEditFileContent";

  if (!m_actionEditFile->isEnabled())
    return;

  QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
  if (!selIndex.isValid())
    return;

  FileManagement::FileContent data = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());
  DEBUG_LOG(m_logger) << "onEditFileContent Id = " << data.id();

  m_getContent->getContent(data.id(), m_content);

  FileContentEditDialog *dialog = new FileContentEditDialog(this);
  QString folderName = m_modelFolder->getFolderName(m_dtc->folder(data.folderId()));

  if (!dialog->init(m_session, selIndex, m_isAdminMode, folderName, data, m_content))
  {
    delete dialog;
    return;
  }

  dialog->setAttribute(Qt::WA_DeleteOnClose);

  QObject::connect(dialog, &FileContentEditDialog::rejected, dialog, &FolderEditDialog::deleteLater);

  dialog->show();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onImportFile()
{
  DEBUG_LOG(m_logger) << "onImportFile";

  // open dialog
  const QStringList filter(
  {
          tr("PDF Files (*.pdf)"),
          tr("Images (*.jpg *.jpeg *.png)"),
          tr("XML Files (*.xml)"),
          tr("TXT Files (*.txt)"),
          tr("MSOffice Word Documents (*.doc *.dot *.docx *dotx *.docm *.dotm)"),
          tr("MSOffice Excel Documents (*.xls *.xlt *.xlm *.xlsx *.xlst *.xltm *.xltx)"),
          tr("MSOffice PowerPoint Documents (*.ppt *.pot *.pps *.pptx *.pptm *.potx *.potm)"),
          tr("OpenOffice Documents (*.odt *.ods *.odp)"),
#ifdef Q_OS_WIN
          tr("All (*.*)")
#else
          tr("All (*)")
#endif
        });
  // static so it's saved for next time
  static QString defaultPath = QDir::homePath() + QStringLiteral("/scanner/");
  QString fileName = QFileDialog::getOpenFileName(this,
                                                  tr("Load file to library"),
                                                  defaultPath,
                                                  filter.join(QStringLiteral(";;")));
  if (fileName.isEmpty())
    return;

  QFileInfo fileInfo(fileName);
  if (!fileInfo.isReadable())
  {
    LtsWidgets::LtsMessageDialog::showMessage(this, tr("An error occurred while loading the file.\n"
                                                       "The loaded file is not readable."));
    return;
  }

  defaultPath = fileInfo.path();
  QString fileExt = fileInfo.suffix();

  QFile file(fileName);
  if (!file.open(QIODevice::ReadOnly))
  {
    ERROR_LOG(m_logger) << "Cannot read file " << fileName;
    return;
  }
  QByteArray fileContent = file.readAll();

  // metadata, fill in the default values & the content
  FileManagement::FileContent data = FileContent();
  data.folderId(m_selectedFolderId);
  data.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
  data.name(fileInfo.baseName().toStdString());
  data.fileStatus(FileManagement::FileStatus::Valid);

  int exId = 0;
  int phId = 0;
  if (m_session->exerciseId() > 0)
  {
    exId = m_session->exerciseId();
    if (m_session->exerciseData()->phId > 0)
      phId = m_session->exerciseData()->phId;
  }

  const auto fldPath = m_dtc->folder(m_selectedFolderId).path();
  if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::UserDocuments))
    data.fileCategory(FileManagement::FileCategory::User);
  else if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::ExerciseDocuments))
  {
    data.fileCategory(FileManagement::FileCategory::Exercise);
    if (fldPath.size() >= 2) // means we are in a specific exercise folder
    {
      exId = m_dtc->getExerciseId(fldPath.at(1));
      if (exId > 0 && fldPath.size() >= 4)  // we got an exercise Id and we are in a phase sub-folder
        phId = m_dtc->getExerciseId(fldPath.at(3));
    }
  }
  else
  {
    data.fileCategory(FileManagement::FileCategory::Global);   // global
    exId = 0;
    phId = 0;
  }

  DEBUG_LOG(m_logger) << "Exercise id = " << exId << ", phase Id = " << phId;

  if (exId > 0)
    data.exerciseId(exId);
  if (phId > 0)
    data.phaseId(phId);

  data.fileType(getFileType(fileExt)); // match from file extension to file type

  // create dialog
  FileContentEditDialog *dialog = new FileContentEditDialog(this);
  QString folderName = m_modelFolder->getFolderName(m_dtc->folder(data.folderId()));  

  // init & show dialog to modify the meta data
  if (!dialog->init(m_session, QModelIndex(), m_isAdminMode, folderName, data, LtsUtils::convert<std::vector<uint8_t>>(fileContent)))
  {
    delete dialog;
    return;
  }

  dialog->setAttribute(Qt::WA_DeleteOnClose);

  QObject::connect(dialog, &FileContentEditDialog::rejected, dialog, &FileContentEditDialog::deleteLater);

  dialog->show();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::createNewOfficeFile(const QString &fileName)
{
  if (fileName.isEmpty())
    return;

  const QString absFilePath = getTemplateFile(fileName);
  if (absFilePath.isEmpty())
  {
    LtsWidgets::LtsMessageDialog::showMessage(this, tr("An error occurred while loading the file.\n"
                                                       "Can not find template file '%1'.").arg(fileName));
    return;
  }

  QFileInfo fileInfo(absFilePath);
  if (!fileInfo.isReadable())
  {
    LtsWidgets::LtsMessageDialog::showMessage(this, tr("An error occurred while loading the file.\n"
                                                       "The file to load is not readable (%1).").arg(absFilePath));
    return;
  }

  QFile file(absFilePath);
  if (!file.open(QIODevice::ReadOnly))
  {
    ERROR_LOG(m_logger) << "Cannot read file " << absFilePath;
    return;
  }
  QByteArray fileContent = file.readAll();

  // metadata, fill in the default values & the content
  FileManagement::FileContent data;
  data.folderId(m_selectedFolderId);
  data.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
  data.name(tr("<please fill in file name>").toStdString());
  data.fileStatus(FileManagement::FileStatus::Valid);

  int exId = 0;
  int phId = 0;
  if (m_session->exerciseId() > 0)
  {
    exId = m_session->exerciseId();
    if (m_session->exerciseData()->phId > 0)
      phId = m_session->exerciseData()->phId;
  }

  const auto fldPath = m_dtc->folder(m_selectedFolderId).path();
  if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::UserDocuments))
    data.fileCategory(FileManagement::FileCategory::User);
  else if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::ExerciseDocuments))
  {
    data.fileCategory(FileManagement::FileCategory::Exercise);
    if (fldPath.size() >= 2) // means we are in a specific exercise folder
    {
      exId = m_dtc->getExerciseId(fldPath.at(1));
      if (exId > 0 && fldPath.size() >= 4)  // we got an exercise Id and we are in a phase sub-folder
        phId = m_dtc->getExerciseId(fldPath.at(3));
    }
  }
  else
  {
    data.fileCategory(FileManagement::FileCategory::Global);   // global
    exId = 0;
    phId = 0;
  }

  if (exId > 0)
    data.exerciseId(exId);
  if (phId > 0)
    data.phaseId(phId);

  data.fileType(getFileType(fileInfo.suffix())); // match from file extension to file type

  // create dialog
  FileContentEditDialog *dialog = new FileContentEditDialog(this);
  QString folderName = m_modelFolder->getFolderName(m_dtc->folder(data.folderId()));

  // init & show dialog to modify the meta data
  if (!dialog->init(m_session, QModelIndex(), m_isAdminMode, folderName, data, LtsUtils::convert<std::vector<uint8_t>>(fileContent)))
  {
    delete dialog;
    return;
  }

  dialog->setAttribute(Qt::WA_DeleteOnClose);

  QObject::connect(dialog, &FileContentEditDialog::rejected, dialog, &FileContentEditDialog::deleteLater);

  dialog->show();

/* do not start here Office, only after dialog was accepted
  OfficeIntegration *projWindow = new OfficeIntegration(data, this);
  projWindow->openOfficeWindow();
*/
  return;

}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onNewOfficeWord()
{
  createNewOfficeFile(QLatin1String("Default.docx"));
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onNewOfficeExcel()
{
  createNewOfficeFile(QLatin1String("Default.xlsx"));
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onNewOfficePowerPoint()
{
  createNewOfficeFile(QLatin1String("Default.pptx"));
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onNewLibreOfficeWrite()
{
  createNewOfficeFile(QLatin1String("Default.odt"));
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onNewLibreOfficeCalc()
{
  createNewOfficeFile(QLatin1String("Default.ods"));
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onNewLibreOfficePresent()
{
  createNewOfficeFile(QLatin1String("Default.odp"));
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onNewFileFromTemplate()
{
  // possible only when a template is selected
  onCopyFile();
  m_copyFile.isTemplate(false);
  m_copyFile.isUsedBy(false);
  m_copyFile.name(tr("<please fill in file name>").toStdString());
  onPasteFile();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onFolderSelectionChanged()
{
  DEBUG_LOG(m_logger) << "onFolderSelectionChanged";
  enaDisa();

  reInitModelFile();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::folderContextMenuRequested(const QPoint &position)
{
  QModelIndex selIndex = selectedIndexViewFolder();
  if (!selIndex.isValid() || LtsSessionData::LtsSessionData::getInstance()->isTablet())
    return;
  enaDisa();

  QMenu menu(m_ui->tvFolder);
  menu.addAction(m_actionAddFolder);
  menu.addAction(m_actionRenameFolder);
  menu.addAction(m_actionRemoveFolder);
  menu.addSeparator();
  menu.addAction(m_actionCutFolder);
  menu.addAction(m_actionCopyFolder);
  menu.addAction(m_actionPasteFolder);
  menu.addSeparator();
  menu.addAction(m_actionRefreshFolders);
  menu.addSeparator();
  menu.exec(m_ui->tvFolder->viewport()->mapToGlobal(position));
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::fileContextMenuRequested(const QPoint &position)
{
  enaDisa();

  QMenu menu(m_ui->widgetFiles);
  if (!LtsSessionData::LtsSessionData::getInstance()->isTablet())
  {
    menu.addAction(m_actionImportFile);
    menu.addAction(m_actionEditFile);
    menu.addAction(m_actionDeleteFile);
    menu.addSeparator();
  }
  menu.addAction(m_actionPreviewFile);
  if (!LtsSessionData::LtsSessionData::getInstance()->isTablet())
  {
    menu.addSeparator();
    menu.addAction(m_actionCutFile);
    menu.addAction(m_actionCopyFile);
    menu.addAction(m_actionPasteFile);
    menu.addAction(m_actionExportFile);

    if (m_dialogMode == FileDialogMode::Admin)
    {
      menu.addSeparator();
      menu.addAction(m_actionRemoveFile);
      menu.addAction(m_actionRestoreFile);
    }

    menu.addSeparator();
    QMenu *newFileMenu = menu.addMenu(tr("New File"));

    const bool bUseMSOffice = LtsUtils::ProjectSettings::getInstance()->value(QStringLiteral("Office"), QStringLiteral("Type")).toString() == QStringLiteral("MSOffice");
    if (bUseMSOffice)
    {
      newFileMenu->addAction(m_actionNewOfficeWord);
      newFileMenu->addAction(m_actionNewOfficeExcel);
      newFileMenu->addAction(m_actionNewOfficePowerPoint);
    }
    else
    {
      newFileMenu->addAction(m_actionNewLibreOfficeWrite);
      newFileMenu->addAction(m_actionNewLibreOfficeCalc);
      newFileMenu->addAction(m_actionNewLibreOfficePresent);
    }
    newFileMenu->addAction(m_actionNewFromTemplate);
  }
  menu.exec(m_ui->widgetFiles->mapToGlobal(position));
}

//----------------------------------------------------------------------------
void FileManagementDialogWidget::onFolderChanged(const FileManagement::Folder &data, DataModification modType)
{
  DEBUG_LOG(m_logger) << "onFolderChanged: folder name = " << data.name();
  /*
    // old version without re-init model
    if (modType == DataModification::eAdded)
    {
      int row = 0;
      m_modelFolder->onInsertRow(row, selectedIndexViewFolder(), data);
      // so it does not make the update below when updating path
      m_selectedFolderId = 0;
    }
    if (modType == DataModification::eModified && m_selectedFolderId > 0)
      m_modelFolder->onUpdateRow(selectedIndexViewFolder(), data);
    if (modType == DataModification::eRemoved)
    {
      DEBUG_LOG(m_logger) << "Folder removed = " << data.name();
    }
  */
  Q_UNUSED(data);
  Q_UNUSED(modType);

  m_modelFolder->initModel(m_session->exerciseId(), m_isAdminMode);
  m_ui->tvFolder->expandAll();
  m_ui->tvFolder->setExpanded(m_proxyModelFolder->index(0, 0), true);
  // select last selected folder
  selectFolder();
}

//----------------------------------------------------------------------------
FileManagement::FileType FileManagementDialogWidget::getFileType(const QString &fileExt)
{
  FileManagement::FileType type = FileManagement::FileType::Unknown;
  auto ext = fileExt.toLower().toStdString();
  if (fileExt.toLower() == QStringLiteral("jpeg")) ext = "jpg";
  std::function<bool(const FileManagement::FileTypeInfo &fti)> cb = [&type, &ext](const FileManagement::FileTypeInfo & fti)
  {
    if (fti.extension() == ext)
    {
      // assuming is 1-1 relationship between type and typeInfo and typeInfo.id is same with type.id
      type = static_cast<FileType::type>(fti.id());
      return true;
    }
    return false;
  };
  m_dtc->fileTypeInfos(cb);
  return type;
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onPreviewFile()
{
  DEBUG_LOG(m_logger) << "onPreviewFile";

  QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
  if (!selIndex.isValid())
  {
    ERROR_LOG(m_logger) << "No valid selected file for preview!";
    return;
  }

  FileManagement::FileContent data = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());

  FileManagement::FileType ft = data.fileType();

  switch (ft.underlying())
  {
  case FileManagement::FileType::Jpg:
  case FileManagement::FileType::Png:
  case FileManagement::FileType::Text:
  case FileManagement::FileType::Xml:
  case FileManagement::FileType::Pdf:
  case FileManagement::FileType::OperatorFavourite:
  case FileManagement::FileType::TacticalPlan:
  case FileManagement::FileType::EvaluationSchema:
  case FileManagement::FileType::AdlerJson:
  {
    // create dialog
    FileContentPreviewDialog *dialog = new FileContentPreviewDialog(m_session, m_ftc, this);
    if (!dialog->init(data))
    {
      delete dialog;
      return;
    }
    dialog->setAttribute(Qt::WA_DeleteOnClose);
    QObject::connect(dialog, &FileContentPreviewDialog::rejected, dialog, &FolderEditDialog::deleteLater);
    dialog->show();
    break;
  }
  case FileManagement::FileType::MSOfficeDocument:
  case FileManagement::FileType::MSOfficeDocument97:
  case FileManagement::FileType::MSOfficePresentation:
  case FileManagement::FileType::MSOfficePresentation97:
  case FileManagement::FileType::MSOfficeSpreadsheet:
  case FileManagement::FileType::MSOfficeSpreadsheet97:
  case FileManagement::FileType::OpenOfficeDocument:
  case FileManagement::FileType::OpenOfficePresentation:
  case FileManagement::FileType::OpenOfficeSpreadsheet:
  {
    OfficeIntegration *projWindow = new OfficeIntegration(data, this);
    if (!projWindow->openOfficeWindow())
      new LtsWidgets::LtsMessageDialogNew(this, tr("Can not open Office: %1").arg(projWindow->errorString()));
    break;
  }
  case FileManagement::FileType::OperatorDefinedSymbol:
    new LtsWidgets::LtsMessageDialogNew(this, tr("Not yet implemented"));
    break;
  case FileManagement::FileType::Unknown:
    new LtsWidgets::LtsMessageDialogNew(this, tr("Unknown file type! Preview not available."));
    break;
  }

}
QString FileManagementDialogWidget::getFileTypeStr(FileManagement::FileType fileType)
{
  switch (fileType.underlying())
  {
  case FileManagement::FileType::Png:
    return(QStringLiteral(".png"));
  case FileManagement::FileType::Jpg:
    return(QStringLiteral(".jpg"));
  case FileManagement::FileType::Text:
    return(QStringLiteral(".txt"));
  case FileManagement::FileType::EvaluationSchema:
  case FileManagement::FileType::Xml:
    return(QStringLiteral(".xml"));
  case FileManagement::FileType::TacticalPlan:
    return(QStringLiteral(".TacticalPlan"));
  case FileManagement::FileType::OperatorFavourite:
    return(QStringLiteral(".OperatorFavourite"));
  case FileManagement::FileType::Pdf:
    return(QStringLiteral(".pdf"));
  case FileManagement::FileType::OperatorDefinedSymbol:
    return(QStringLiteral(".OperatorDefinedSymbol"));
  case FileManagement::FileType::MSOfficeDocument:
    return(QStringLiteral(".docx"));
  case FileManagement::FileType::MSOfficeDocument97:
    return(QStringLiteral(".doc"));
  case FileManagement::FileType::MSOfficePresentation:
    return(QStringLiteral(".pptx"));
  case FileManagement::FileType::MSOfficePresentation97:
    return(QStringLiteral(".ppt"));
  case FileManagement::FileType::MSOfficeSpreadsheet:
    return(QStringLiteral(".xlsx"));
  case FileManagement::FileType::MSOfficeSpreadsheet97:
    return(QStringLiteral(".xls"));
  case FileManagement::FileType::OpenOfficeDocument:
    return(QStringLiteral(".odt"));
  case FileManagement::FileType::OpenOfficePresentation:
    return(QStringLiteral(".odp"));
  case FileManagement::FileType::OpenOfficeSpreadsheet:
    return(QStringLiteral(".ods"));
  case FileManagement::FileType::AdlerJson:
    return(QStringLiteral(".ajs"));
  case FileManagement::FileType::Unknown:
    return(QStringLiteral(".Unknown"));
  }
  return(QStringLiteral(".Unknown"));
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onExportFile()
{
  DEBUG_LOG(m_logger) << "onExportFile(): fileName = " << m_fileName;

  // static so it's saved for next time
  static QString defaultPath = QDir::homePath() + QStringLiteral("/scanner/");
  DEBUG_LOG(m_logger) << "onExportFile(): old path = " << defaultPath;

  QString folderName = QFileDialog::getExistingDirectory(this,
                                                         tr("Save file from library to local Workstation"),
                                                         defaultPath,
                                                         QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
  DEBUG_LOG(m_logger) << "onExportFile(): folderName = " << folderName;
  if (folderName.isEmpty())
  {
    DEBUG_LOG(m_logger) << "onExportFile(): folderName.isEmpty()";
    return;
  }

  m_getContent->getContent(m_selectedFileContent.id(), m_content);
  DEBUG_LOG(m_logger) << "onExportFile(): Save File to '" << folderName << "/" << m_fileName << "'"
                      << " fileType = " << m_selectedFileContent.fileType()
                      << " getFileTypeStr = " << getFileTypeStr(m_selectedFileContent.fileType())
                      << " exportFileName = " << m_selectedFileContent.exportFileName()
                      << " m_content.size = " << m_content.size();

  QString completeFileName =  m_fileName;
  completeFileName.append(getFileTypeStr(m_selectedFileContent.fileType()));

  QFile file;
  QDir::setCurrent(folderName);
  file.setFileName(completeFileName);

  if (file.exists())
  {
    DEBUG_LOG(m_logger) << "onExportFile(): File already exists (" << completeFileName << ") in folder " << folderName;
    if (LtsWidgets::LtsMessageDialog::showMessage(this, tr("Yes - overwrite file.<br>"
                                                           "No - do not overwrite file.<br>"),
                                                  tr("Do you want to overwrite the existing file?"),
                                                  LtsWidgets::Behaviour::Modal,
                                                  LtsWidgets::Button::Yes | LtsWidgets::Button::No) != LtsWidgets::Button::Yes)
    {
      DEBUG_LOG(m_logger) << "onExportFile(): File exists, will not be overwritten (" << completeFileName << ") in folder " << folderName;
      return;
    }
  }

  file.open(QIODevice::WriteOnly);
  file.write(LtsUtils::toQByteArray(m_content));
  file.close();

  DEBUG_LOG(m_logger) << "onExportFile(): Exported file " << completeFileName << " in folder " << folderName;
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onSelectFile()
{
  DEBUG_LOG(m_logger) << "onSelectFile";

  QModelIndex selIndex = m_ui->widgetFiles->currentIndex();

  if (!selIndex.isValid())
    return;

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

  DEBUG_LOG(m_logger) << "Selected file content id = " << m_selectedFileContent.id();
  emit accepted();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::onChooseFileName()
{
  DEBUG_LOG(m_logger) << "onChooseFileName";

  if ((FileDialogMode::SaveFile == m_dialogMode) && (!m_fileName.isEmpty()))
  {
    DEBUG_LOG(m_logger) << "Choosen file name = " << m_fileName;
    emit accepted();
  }
}

//----------------------------------------------------------------------------
void FileManagementDialogWidget::onFileChanged(const FileManagement::FileContent &data, DataModification modType)
{
  bool condition = showFile(data, m_xmlType);
  DEBUG_LOG(m_logger) << "onFileChanged file name = " << data.name() << ", condition = " << condition << ", modType = " << modType;

  bool reInit = false;
  int row = 0;

  QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
  if (selIndex.isValid())
    row = selIndex.row();

  switch (modType)
  {
  case DataModification::eRemoved:
    m_modelFile->removeRow(row);
    reInit = true;
    break;
  case DataModification::eAdded:
    if (condition)
      m_modelFile->insertRow(data);
    else
      reInit = true;
    break;
  case DataModification::eModified:
    if (condition)
    {
      // modified the selected file
      if (data.id() == m_modelFile->getRowData(row).id())
        m_modelFile->setRowData(row, data);
      else
        reInit = true;
    }
    else
      reInit = true;
    break;
  }
  if (reInit)
    reInitModelFile(true);
  enaDisa();
}

//--------------------------------------------------------------------------
bool FileManagementDialogWidget::showFile(const FileManagement::FileContent &fc, const QString &xmlType)
{
  if (fc.isDeleted())
  {
    DEBUG_LOG(m_logger) << "is deleted: " << fc.name().c_str();
    return false;
  }

  if (fc.folderId() != m_selectedFolderId)
  {
    DEBUG_LOG(m_logger) << "Folder id does not match: " << fc.name().c_str();
    return false;
  }

  if (!m_fileTypes.isEmpty() && !m_fileTypes.contains(fc.fileType()))
  {
    DEBUG_LOG(m_logger) << "file type does not match: " << fc.name().c_str();
    return false;
  }

  if (m_dialogMode != FileDialogMode::Admin)
  {
    if (fc.fileStatus() != FileManagement::FileStatus::Valid)
    {
      DEBUG_LOG(m_logger) << "file status is not valid: " << fc.name().c_str();
      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 QVector<int> fldPath = LtsUtils::convert<QVector<int>>(fld.path());

    // filter in USER DOCUMENTS folder and subfolders
    if (fldPath.contains(FileManagement::MainFolder::UserDocuments))
    {
      const int operatorId = LtsSessionData::LtsSessionData::getInstance()->getOperatorId();
      // filter on OperatorId
      DEBUG_LOG(m_logger) << "Filtering files on OperatorId = " << operatorId;
      if (fc.operatorId() != operatorId)
      {
        DEBUG_LOG(m_logger) << "operator id does not match: " << fc.name().c_str();
        return false;
      }
      DEBUG_LOG(m_logger) << "Filtering files on User Category";
      if (fc.fileCategory() != FileManagement::FileCategory::User)
      {
        DEBUG_LOG(m_logger) << "User category does not match: " << fc.name().c_str();
// filter on User Category not needed anymore, to be able to load also Exercise files saved via "Save to Library" under "User Documents" folder
//        return false;
      }
      // additionally, in Exercise Library filter on exercise Id, if given
      if (m_session->exerciseId() > 0)
      {
        if (fc.exerciseId().is_set() && fc.exerciseId().get() != m_session->exerciseId())
        {
          DEBUG_LOG(m_logger) << "exercise does not match: " << fc.name().c_str() << " is: " << fc.exerciseId()
                              << " should be " << m_session->exerciseId();
          return false;
        }
      }
    }

    // filter in EXERCISE DOCUMENTS folder and subfolders
    if (fldPath.contains(FileManagement::MainFolder::ExerciseDocuments))
    {
      // filter on Category = Exercise
      DEBUG_LOG(m_logger) << "Filtering files on Exercise Category";
      if (fc.fileCategory() != FileManagement::FileCategory::Exercise)
      {
        DEBUG_LOG(m_logger) << "exercise category does not match: " << fc.name().c_str();
        return false;
      }
      if (m_session->exerciseId() > 0)
      {
        // filter on exact exerciseId
        DEBUG_LOG(m_logger) << "Filtering files on Exercise Category and exerciseId = " << m_session->exerciseId();
        if (fc.exerciseId().is_set() && fc.exerciseId().get() != m_session->exerciseId())
        {
          DEBUG_LOG(m_logger) << "exercise does not match: " << fc.name().c_str() << " is: " << fc.exerciseId()
                              << " should be " << m_session->exerciseId();
          return false;
        }
      }
    }

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


  }
  return true;
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogWidget::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);
}

//-----------------------------------------------------------------------------------------------------------
// mapping buttons folders (left side):
// Print     | Import     | Export       |
//----------------------------------------
// AddFolder | EditFolder | RemoveFolder |

// mapping buttons files (right side):
//  Load       | Save       | Add        | Edit      | Show    | Remove     | Hide       |
// --------------------------------------------------------------------------------------
//  RestoreFile| ExportFile | ImportFile | Properties| Preview | RemoveFile | DeleteFile |
//-----------------------------------------------------------------------------------------------------------
FileManagementDialogTab::FileManagementDialogTab(const QString &menuGroup, QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
  , m_editItemWidget(new FileManagementDialogWidget(this))
  , m_logger(getLogger("FileManagementDialog"))
{

  if (menuGroup == tr("Document Library"))
    // Admin-Document Library->Manage Library
    setOnlineHelpFilename(QStringLiteral("Administrator-Library_Management"));
  if (menuGroup == tr("Exercise Documents"))
    // Situation.Extras->Excercise Documents->Organise Library
    setOnlineHelpFilename(QStringLiteral("Situation-Library_Organisation"));
  DEBUG_LOG(m_logger) << "Ctor FileManagementDialogTab";

  LtsWidgets::DialogButton btnAddFolder    = LtsWidgets::DialogButton::Print;
  LtsWidgets::DialogButton btnEditFolder   = LtsWidgets::DialogButton::Import;
  LtsWidgets::DialogButton btnRemoveFolder = LtsWidgets::DialogButton::Export;

  LtsWidgets::DialogButton btnExportFile   = LtsWidgets::DialogButton::Save;
  LtsWidgets::DialogButton btnImportFile   = LtsWidgets::DialogButton::Add;
  LtsWidgets::DialogButton btnEditFile     = LtsWidgets::DialogButton::Edit;
  LtsWidgets::DialogButton btnPreviewFile  = LtsWidgets::DialogButton::Show;
  LtsWidgets::DialogButton btnRemoveFile   = LtsWidgets::DialogButton::Remove;
  LtsWidgets::DialogButton btnDeleteFile   = LtsWidgets::DialogButton::Hide;
  LtsWidgets::DialogButton btnRestoreFile  = LtsWidgets::DialogButton::Load;

  if (!LtsSessionData::LtsSessionData::getInstance()->isTablet())
  {
    m_buttonBox->connectButton(btnAddFolder, m_editItemWidget, &FileManagementDialogWidget::onAddFolder);
    m_buttonBox->setText(btnAddFolder, tr("Add Folder"));
    m_buttonBox->setToolTip(btnAddFolder, tr("Add new folder to library"));
    m_buttonBox->setButtonEnabled(btnAddFolder, false);
    m_buttonBox->setButtonVisible(btnAddFolder, true);

    m_buttonBox->connectButton(btnEditFolder, m_editItemWidget, &FileManagementDialogWidget::onEditFolder);
    m_buttonBox->setText(btnEditFolder, tr("Rename Folder"));
    m_buttonBox->setToolTip(btnEditFolder, tr("Rename folder"));
    m_buttonBox->setButtonEnabled(btnEditFolder, false);
    m_buttonBox->setButtonVisible(btnEditFolder, true);

    m_buttonBox->connectButton(btnRemoveFolder, m_editItemWidget, &FileManagementDialogWidget::onRemoveFolder);
    m_buttonBox->setText(btnRemoveFolder, tr("Remove Folder"));
    m_buttonBox->setToolTip(btnRemoveFolder, tr("Remove folder from library"));
    m_buttonBox->setButtonEnabled(btnRemoveFolder, false);
    m_buttonBox->setButtonVisible(btnRemoveFolder, true);

    m_buttonBox->connectButton(btnExportFile, m_editItemWidget, &FileManagementDialogWidget::onExportFile);
    m_buttonBox->setText(btnExportFile, tr("Export File"));
    m_buttonBox->setToolTip(btnExportFile, tr("Export file to file system"));
    m_buttonBox->setButtonEnabled(btnExportFile, false);
    m_buttonBox->setButtonVisible(btnExportFile, true);

    m_buttonBox->connectButton(btnImportFile, m_editItemWidget, &FileManagementDialogWidget::onImportFile);
    m_buttonBox->setText(btnImportFile, tr("Import File"));
    m_buttonBox->setToolTip(btnImportFile, tr("Import file to library"));
    m_buttonBox->setButtonEnabled(btnImportFile, true);
    m_buttonBox->setButtonVisible(btnImportFile, true);

    m_buttonBox->connectButton(btnEditFile, m_editItemWidget, &FileManagementDialogWidget::onEditFile);
    m_buttonBox->setText(btnEditFile, tr("Properties"));
    m_buttonBox->setToolTip(btnEditFile, tr("Edit file properties"));
    m_buttonBox->setButtonEnabled(btnEditFile, false);
    m_buttonBox->setButtonVisible(btnEditFile, true);


    m_buttonBox->connectButton(btnRemoveFile, m_editItemWidget, &FileManagementDialogWidget::onRemoveFile);

    m_buttonBox->setText(btnRemoveFile, tr("Remove File"));
    m_buttonBox->setToolTip(btnRemoveFile, tr("Remove file from library"));
    m_buttonBox->setButtonEnabled(btnRemoveFile, false);
    m_buttonBox->setButtonVisible(btnRemoveFile, true);

    m_buttonBox->connectButton(btnDeleteFile, m_editItemWidget, &FileManagementDialogWidget::onDeleteFile);
    m_buttonBox->setText(btnDeleteFile, tr("Delete File"));
    m_buttonBox->setToolTip(btnDeleteFile, tr("Delete file from library"));
    m_buttonBox->setButtonEnabled(btnDeleteFile, false);
    m_buttonBox->setButtonVisible(btnDeleteFile, true);

    m_buttonBox->connectButton(btnRestoreFile, m_editItemWidget, &FileManagementDialogWidget::onRestoreFile);
    m_buttonBox->setText(btnRestoreFile, tr("Restore File"));
    m_buttonBox->setToolTip(btnRestoreFile, tr("Restore file to library"));
    m_buttonBox->setButtonEnabled(btnRestoreFile, false);
    m_buttonBox->setButtonVisible(btnRestoreFile, true);
  }
  m_buttonBox->connectButton(btnPreviewFile, m_editItemWidget, &FileManagementDialogWidget::onPreviewFile);
  m_buttonBox->setText(btnPreviewFile, tr("Preview File"));
  m_buttonBox->setToolTip(btnPreviewFile, tr("Preview / Edit file"));
  m_buttonBox->setButtonEnabled(btnPreviewFile, false);
  m_buttonBox->setButtonVisible(btnPreviewFile, true);

  m_editItemWidget->m_ui->lblFolder->setText(tr("Selected Folder:"));
  m_editItemWidget->m_ui->lblFile->setText(tr("Selected File:"));

  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, m_editItemWidget, &FileManagementDialogWidget::onReject);
  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &FileManagementDialogTab::close);

  //hide ok and apply
  m_buttonBox->getButton(LtsWidgets::DialogButton::Apply)->hide();
  m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->hide();
}

//-----------------------------------------------------------------------------------------------------------
FileManagementDialog::FileManagementDialog(QWidget *parent)
  : LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal)
  , m_editItemWidget(new FileManagementDialogWidget(this))
  , m_buttonBox(new LtsWidgets::LtsDialogButtonBox(this))
  , m_dialogMode(FileDialogMode::OpenFile)
  , m_logger(getLogger("FileManagementDialog"))
{
  DEBUG_LOG(m_logger) << "Ctor FileManagementDialog";

  LtsWidgets::DialogButton btnAddFolder    = LtsWidgets::DialogButton::Print;
  LtsWidgets::DialogButton btnSelectFile   = LtsWidgets::DialogButton::Load;

  m_buttonBox->connectButton(btnAddFolder, m_editItemWidget, &FileManagementDialogWidget::onAddFolder);
  m_buttonBox->setText(btnAddFolder, tr("Add Folder"));
  m_buttonBox->setToolTip(btnAddFolder, tr("Add new folder to library"));
  m_buttonBox->setButtonEnabled(btnAddFolder, false);
  m_buttonBox->setButtonVisible(btnAddFolder, true);

  m_buttonBox->setText(btnSelectFile, tr("Select File"));
  m_buttonBox->setToolTip(btnSelectFile, tr("Select file from library"));
  m_buttonBox->setButtonEnabled(btnSelectFile, false);
  m_buttonBox->setButtonVisible(btnSelectFile, true);

  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, m_editItemWidget, &FileManagementDialogWidget::onReject);
  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &FileManagementDialog::close);

  //hide ok and apply
  m_buttonBox->getButton(LtsWidgets::DialogButton::Apply)->hide();
  m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->hide();
}

//-----------------------------------------------------------------------------------------------------------
bool FileManagementDialogTab::init(LtsSession::LtsSession *session,                                  
                                   FileDialogMode dlgMode,
                                   const QVector<FileType> &fileTypes,
                                   const int &folderId,
                                   const QString &buttonName)
{
  DEBUG_LOG(m_logger) << "Start init FileManagementDialogTab";

  if (!m_editItemWidget->init(session, dlgMode, fileTypes, folderId))
  {
    ERROR_LOG(m_logger) << "Init FileManagementDialogTab failed!";
    return false;
  }

  m_dialogMode = dlgMode;

  QVBoxLayout *layout = new QVBoxLayout(this);
  layout->addWidget(m_editItemWidget);
  layout->setMargin(0);

  if (!buttonName.isEmpty())
  {
    m_buttonBox->setText(LtsWidgets::DialogButton::Load, buttonName);
    m_buttonBox->setToolTip(LtsWidgets::DialogButton::Load, buttonName);
  }
  else if (m_dialogMode == FileDialogMode::SaveFile)
  {
    m_buttonBox->setText(LtsWidgets::DialogButton::Load, tr("Save"));
    m_buttonBox->setToolTip(LtsWidgets::DialogButton::Load, tr("Save"));
  }

  if (m_dialogMode != FileDialogMode::Admin)
  {
    m_buttonBox->setButtonVisible(LtsWidgets::DialogButton::Remove, false); // remove file
    //m_buttonBox->setButtonVisible(LtsWidgets::DialogButton::Save, false); // export file
    m_buttonBox->setButtonVisible(LtsWidgets::DialogButton::Load, false); // restore file
  }

  connect(m_editItemWidget, &FileManagementDialogWidget::enableButtons, this, &FileManagementDialogTab::enaDisa);
  connect(m_editItemWidget, &FileManagementDialogWidget::accepted, this, &FileManagementDialogTab::accepted);

  m_editItemWidget->m_ui->leFile->setVisible(false);
  m_editItemWidget->m_ui->lblFile->setVisible(false);
  m_editItemWidget->m_ui->lblFilter->setVisible(false);

  return true;
}

//-----------------------------------------------------------------------------------------------------------
bool FileManagementDialog::init(LtsSession::LtsSession *session,
                                FileDialogMode dlgMode,
                                const QVector<FileType> &fileTypes,
                                int folderId,
                                const QString &xmlType)
{
  DEBUG_LOG(m_logger) << "Start init FileManagementDialog";
  DEBUG_LOG(m_logger) << "Initial folder to select: " << folderId;

  if (!m_editItemWidget->init(session, dlgMode, fileTypes, folderId, xmlType))
  {
    ERROR_LOG(m_logger) << "Init FileManagementDialogWidget failed!";
    return false;
  }

  m_dialogMode = dlgMode;

  QVBoxLayout *layout = new QVBoxLayout(this);
  layout->addWidget(m_editItemWidget);
  layout->addWidget(m_buttonBox);

  if (m_dialogMode == FileDialogMode::SaveFile)
  {
    m_buttonBox->setText(LtsWidgets::DialogButton::Load, tr("Save"));
    m_buttonBox->setToolTip(LtsWidgets::DialogButton::Load, tr("Save"));
    m_buttonBox->connectButton(LtsWidgets::DialogButton::Load, m_editItemWidget, &FileManagementDialogWidget::onChooseFileName);
  }
  else if (m_dialogMode == FileDialogMode::OpenFile)
    m_buttonBox->connectButton(LtsWidgets::DialogButton::Load, m_editItemWidget, &FileManagementDialogWidget::onSelectFile);

  connect(m_editItemWidget, &FileManagementDialogWidget::enableButtons, this, &FileManagementDialog::enaDisa);

  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &FileManagementDialog::reject);
  connect(m_editItemWidget, &FileManagementDialogWidget::accepted, this, &FileManagementDialog::accept);

  enaDisa();

  return true;
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialog::accept()
{
  emit fileSelected(getSelectedFileId(), getSelectedFolderId(), getFileName());
  LtsWidgets::LtsFramelessDialog::accept();
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialog::enaDisa()
{
  DEBUG_LOG(m_logger) << "FileManagementDialog::enaDisa()";

  LtsWidgets::DialogButton btnAddFolder    = LtsWidgets::DialogButton::Print;
  m_buttonBox->setButtonEnabled(btnAddFolder, false);

  QModelIndex idxFolder = m_editItemWidget->m_ui->tvFolder->currentIndex();
  if (m_dialogMode == FileDialogMode::SaveFile && idxFolder.isValid())
    m_buttonBox->setButtonEnabled(btnAddFolder, true);

  LtsWidgets::DialogButton btnSelectFile    = LtsWidgets::DialogButton::Load;
  m_buttonBox->setButtonEnabled(btnSelectFile, false);

  QModelIndex idxFile = m_editItemWidget->m_ui->widgetFiles->currentIndex();
  if (m_dialogMode == FileDialogMode::OpenFile && idxFile.isValid())
    m_buttonBox->setButtonEnabled(btnSelectFile, true);

  DEBUG_LOG(m_logger) << "DialogMode: " << (int)m_dialogMode;
  DEBUG_LOG(m_logger) << "FileName: " << m_editItemWidget->m_fileName;

  if (m_dialogMode == FileDialogMode::SaveFile && !m_editItemWidget->m_fileName.isEmpty())
    m_buttonBox->setButtonEnabled(btnSelectFile, true);
}

//-----------------------------------------------------------------------------------------------------------
void FileManagementDialogTab::enaDisa()
{
  DEBUG_LOG(m_logger) << "FileManagementDialogTab::enaDisa()";

  LtsWidgets::DialogButton btnAddFolder    = LtsWidgets::DialogButton::Print;
  LtsWidgets::DialogButton btnEditFolder   = LtsWidgets::DialogButton::Import;
  LtsWidgets::DialogButton btnRemoveFolder = LtsWidgets::DialogButton::Export;

  LtsWidgets::DialogButton btnExportFile   = LtsWidgets::DialogButton::Save;
  LtsWidgets::DialogButton btnImportFile   = LtsWidgets::DialogButton::Add;
  LtsWidgets::DialogButton btnEditFile     = LtsWidgets::DialogButton::Edit;
  LtsWidgets::DialogButton btnPreviewFile  = LtsWidgets::DialogButton::Show;
  LtsWidgets::DialogButton btnRemoveFile   = LtsWidgets::DialogButton::Remove;
  LtsWidgets::DialogButton btnDeleteFile   = LtsWidgets::DialogButton::Hide;
  LtsWidgets::DialogButton btnRestoreFile  = LtsWidgets::DialogButton::Load;

  m_buttonBox->setButtonEnabled(btnAddFolder, m_editItemWidget->m_actionAddFolder->isEnabled());
  m_buttonBox->setButtonEnabled(btnEditFolder, m_editItemWidget->m_actionRenameFolder->isEnabled());
  m_buttonBox->setButtonEnabled(btnRemoveFolder, m_editItemWidget->m_actionRemoveFolder->isEnabled());

  if (m_editItemWidget->m_actionPreviewFile->data().toBool()) // isOffice
  {
    m_buttonBox->setText(btnPreviewFile, tr("Edit File"));
    m_editItemWidget->m_actionPreviewFile->setText(tr("Edit File"));
  }
  else
  {
    m_buttonBox->setText(btnPreviewFile, tr("Preview File"));
    m_editItemWidget->m_actionPreviewFile->setText(tr("Preview File"));
  }

  m_buttonBox->setButtonEnabled(btnExportFile, m_editItemWidget->m_actionExportFile->isEnabled());
  m_buttonBox->setButtonEnabled(btnImportFile, m_editItemWidget->m_actionImportFile->isEnabled());
  m_buttonBox->setButtonEnabled(btnEditFile, m_editItemWidget->m_actionEditFile->isEnabled());
  m_buttonBox->setButtonEnabled(btnPreviewFile, m_editItemWidget->m_actionPreviewFile->isEnabled());
  m_buttonBox->setButtonEnabled(btnRemoveFile, m_editItemWidget->m_actionRemoveFile->isEnabled());
  m_buttonBox->setButtonEnabled(btnDeleteFile, m_editItemWidget->m_actionDeleteFile->isEnabled());
  m_buttonBox->setButtonEnabled(btnRestoreFile, m_editItemWidget->m_actionRestoreFile->isEnabled());
}

} // namespace FileManagement