/**
  * @RDE_HEADER@
  * The DataManager class handles data to be send to the websocket
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Philipp Dassow, SLST, 2017-12-05
  */
#include "data_manager.h"
#include "Messages/reply_message.h"
#include "main_handler.h"
#include "flm_db.h"
#include "json_keys.h"
#include <ngldb/nsqlquery.h>

namespace FileManagement
{
namespace WebSocketInterface
{
//---------------------------------------------------------------------------------------------------------
DataManager::DataManager(MainHandler *mainHandler)
  : LtsWebSocket::DataManagerBaseDl<DatabaseInterface>(mainHandler->db(), getLogger("DataManager"))
{}

//---------------------------------------------------------------------------------------------------------


LtsWebSocket::ReplyMessage *DataManager::folderBaseData(const QString &uuid) const
{
  return toBaseDataMessageFromDb<Database::FlmFolder, ReplyMessages::FolderBaseData>(uuid);
}

LtsWebSocket::ReplyMessage *DataManager::fileContentBaseData(const QString &uuid, int exerciseId) const
{
  DEBUG_LOG(m_logger) << "preparing file content base data for exercise " << exerciseId;
  QVector<Database::FlmFolder> folderVec;
  m_dbInterface->select(folderVec);
  int snapshotFolderId = getFolderId(folderVec, QStringLiteral("Snapshots"), exerciseId);

  // Filter for everything that is in the given exercise + global tactical plans and symbols
  QVector<Database::FlmFileContent> dataVec;
  
  
  //this is DONE BY HAND!!!!  so very uncool
  //I HATE YOU SO MUCH YOU FUCKING FUCK FUCK!
  const QString where = QStringLiteral(" WHERE exercise_id is null OR exercise_id = ") + QString::number(exerciseId) + QStringLiteral(" and file_type_id in (1,2,4,5,6,7,8)");
  const QString tableName(QStringLiteral("flm.flm_file_content"));
  const QString stmt(QStringLiteral("SELECT id, name, is_template, folder_id, file_category_id, file_type_id, file_status_id, exercise_id, phase_id, operator_id, content, properties, is_used_by, used_by, last_modified"
                                    " FROM ") + tableName + where);

  std::unique_ptr<NSqlQuery> query = std::unique_ptr<NSqlQuery>(new NSqlQuery(m_dbInterface->database(), m_logger));
  query->prepare(stmt);

  if(query->exec())
  {
    Database::FlmFileContent data;
    while (query->next())
    {
      int i = 0;

      data.id = query->value(i++).toLongLong();
      data.name = query->value(i++).toString();
      data.isTemplate = query->value(i++).toBool();
      data.folderId = query->value(i++).toLongLong();
      data.fileCategoryId = static_cast<FileManagement::FileCategory_def::type>(query->value(i++).toInt());
      data.fileTypeId = static_cast<FileManagement::FileType_def::type>(query->value(i++).toInt());
      data.fileStatusId = static_cast<FileManagement::FileStatus_def::type>(query->value(i++).toInt());
      data.exerciseId = query->value(i++);
      data.phaseId = query->value(i++);
      data.operatorId = query->value(i++).toInt();
      data.content = query->value(i++).toByteArray();
      QVariant xx = query->value(i++);
      data.properties =  xx.isNull() ? QStringLiteral("{}") : xx.toString();
      data.isUsedBy = query->value(i++).toBool();
      data.usedBy = query->value(i++).toInt();
      data.lastModified = query->value(i++).toLongLong();
      if ((data.fileTypeId == FileManagement::FileType::Jpg ||
           data.fileTypeId == FileManagement::FileType::Png)
          && data.folderId == snapshotFolderId )
      {
        //ERROR_LOG(m_logger) << "errorMessage";
        continue;
        }
      //ERROR_LOG(m_logger) << "ADD " << data.name;

      dataVec.append(data);
    }

  }else
  {
    const QString errorMessage = QStringLiteral("Error reading data from database!");
    ERROR_LOG(m_logger) << errorMessage;
    LtsWebSocket::ErrorMessage::ErrorData errData;
    errData.errorMessage = errorMessage;
    errData.uuid = uuid;
    return new LtsWebSocket::ErrorMessage(errData);
  }
  
  DEBUG_LOG(m_logger) << "filtering file content base data for exercise ID: " << exerciseId;
  DEBUG_LOG(m_logger) << "sending file content base data" << dataVec.size();

  return new ReplyMessages::FileContentBaseData(DatabaseInterface::toJson(dataVec), uuid);
  
  /*
  auto cb = [&dataVec, snapshotFolderId, exerciseId](const Database::FlmFileContent & content)
  {
    if ((content.exerciseId != exerciseId) && (content.exerciseId != 0))
      return;
    //now skip all unneeded document types -> i prefer opt out instead of opt in
    if (content.fileTypeId == FileManagement::FileType::MSOfficeDocument || 12
        content.fileTypeId == FileManagement::FileType::MSOfficeDocument97 || 13
        content.fileTypeId == FileManagement::FileType::MSOfficeSpreadsheet || 10 
        content.fileTypeId == FileManagement::FileType::MSOfficeSpreadsheet97 || 13
        content.fileTypeId == FileManagement::FileType::MSOfficePresentation || 16
        content.fileTypeId == FileManagement::FileType::MSOfficePresentation97 || 17
        content.fileTypeId == FileManagement::FileType::OpenOfficePresentation || 11
        content.fileTypeId == FileManagement::FileType::OpenOfficeSpreadsheet || 10
        content.fileTypeId == FileManagement::FileType::OpenOfficeDocument || 9
        content.fileTypeId == FileManagement::FileType::Unknown || 0 
        content.fileTypeId == FileManagement::FileType::Pdf) 3
        * 1 2 4 5 6 7 8 18*
      return;
    if ((content.fileTypeId == FileManagement::FileType::Jpg ||
         content.fileTypeId == FileManagement::FileType::Png)
        && content.folderId == snapshotFolderId)
      return; //no snapsholts
    dataVec += content;
  };
  // read all data from database
  if (!m_dbInterface->select(cb))
  {
    const QString errorMessage = QStringLiteral("Error reading data from database!");
    ERROR_LOG(m_logger) << errorMessage;
    LtsWebSocket::ErrorMessage::ErrorData errData;
    errData.errorMessage = errorMessage;
    errData.uuid = uuid;
    return new LtsWebSocket::ErrorMessage(errData);
  }

  DEBUG_LOG(m_logger) << "filtering file content base data for exercise ID: " << exerciseId;
  DEBUG_LOG(m_logger) << "sending file content base data";

  return new ReplyMessages::FileContentBaseData(DatabaseInterface::toJson(dataVec), uuid);
  */
}

LtsWebSocket::ReplyMessage *DataManager::pdfList(const QString &uuid, int exerciseId) const
{
  DEBUG_LOG(m_logger) << "Preparing file content base data for PDF list";
  QJsonArray dataArr;

  auto cb = [&dataArr, exerciseId] (const Database::FlmFileContent &current)
  {
    if ((current.exerciseId != exerciseId) && (current.exerciseId != 0))
      return;
    if (current.fileTypeId != FileManagement::FileType::Pdf)
      return;

    QJsonObject obj({{JsonKeys::NAME(), current.name},
                     {JsonKeys::FILE_ID(), current.id},
                     {JsonKeys::FILE_SIZE(), current.content.size()},
                     {JsonKeys::FILE_CATEGORY(), current.fileCategoryId.underlying()},
                     {JsonKeys::IS_TEMPLATE(), current.isTemplate},
                     {JsonKeys::PROPERTIES(), current.properties},
                     {JsonKeys::FILE_STATUS(), current.fileStatusId.underlying() },
                     {JsonKeys::FOLDER_ID(), current.folderId      },
                     {JsonKeys::PHASE_ID(), current.phaseId.toInt()      },
                     {JsonKeys::OPERATOR_ID(), current.operatorId},
                     {JsonKeys::EXERCISE_ID(), current.exerciseId.toInt()}});
    dataArr.append(obj);
  };
  if (!m_dbInterface->select(cb))
  {
    const QString errorMessage = QStringLiteral("Error reading data from database!");
    ERROR_LOG(m_logger) << errorMessage;
    LtsWebSocket::ErrorMessage::ErrorData errData;
    errData.errorMessage = errorMessage;
    errData.uuid = uuid;
    return new LtsWebSocket::ErrorMessage(errData);
  }

  return new ReplyMessages::PdfListData(dataArr, uuid);
}

int DataManager::getFolderId(const QVector<Database::FlmFolder> &dataVec, const QString &folderName, int exerciseId) const
{
  int parentFolder = 0;
  if (exerciseId > 0)
  {
    const QString exName = QLatin1String("$EX_")+QString::number(exerciseId);
    parentFolder = getFolderId(dataVec, exName, 0);

  }

  for (const auto &fld :dataVec)
  {
    if (fld.name == folderName)
    {
      if (exerciseId > 0  && parentFolder > 0)
      {
        if (fld.path().size() > 1 && fld.path().at(fld.path().size() - 2) == parentFolder)
          return fld.id;
      }
      else
        return fld.id;
    }
  }
  return 0;
}

} // namespace WebSocketInterface
} // namespace FileManagement