MSSessionStorage.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include "MSSessionStorage.hpp"

#include "MSContext.hpp"
#include "MSData.hpp"
#include "MSDefs.hpp"
#include "MSElement.hpp"
#include "MSSessionStorageInterface.hpp"

#include <MCDefs.hpp>
#include <MCLog.hpp>

#include <qdatetime.h>
#include <qdir.h>
#include <qmap.h>
#include <qsqlerror.h>
#include <qsqlquery.h>
#include <qsqldatabase.h>
#include <qvariant.h>
#include <qvector.h>

#include <boost/make_shared.hpp>

static MSSessionStorage* SessionSingleton = nullptr;

MSSessionStorage::MSSessionStorage() : PlaybackPath(""), RecordPath(""), RecordStoragePeriod(500),
  PlayedHeartBeats(0)
{
  MSContext::RegisterTimer("StoragePlayback", "Storage playback time");
  MSContext::RegisterTimer("StorageRecord", "Storage record time");
}


MSSessionStorage::~MSSessionStorage()
{
  // Finalize and remove the storages
  if (!SessionStorages.isEmpty())
  {
    RemoveStorages();
  }
}


MSSessionStorage* MSSessionStorage::GetInstance()
{
  if (!SessionSingleton)
  {
    SessionSingleton = new MSSessionStorage();
  }
  return SessionSingleton;
}


QString MSSessionStorage::GetPlaybackPath() const
{
  return PlaybackPath;
}


void MSSessionStorage::SetPlaybackPath(const QString& path)
{
  if (PlaybackDatabase.get() || PlaybackStorage.get())
  {
    MC_WARNING("A database or storage has been opened for playback already.");
    return;
  }
  PlaybackPath = path;
  PlayedHeartBeats = 0;
}


QString MSSessionStorage::GetRecordPath() const
{
  return RecordPath;
}


void MSSessionStorage::SetRecordPath(const QString& record_path)
{
  if (RecordDatabase.get() || RecordStorage.get())
  {
    MC_WARNING("A database or storage has been opened for record already.");
    return;
  }
  RecordPath = record_path;
}


bool MSSessionStorage::IsStorageAvailable() const
{
  return !SessionStorages.isEmpty();
}



int MSSessionStorage::GetPlayedHeartBeats() const
{
  return PlayedHeartBeats;
}


void MSSessionStorage::BeatEnd(int beat_id)
{
  Q_UNUSED(beat_id);
  if (PlaybackDatabase.get())
  {
    MSContext::StartTimer("StoragePlayback");
    LoadStatesFromDatabase();
    MSContext::StopTimer("StoragePlayback");
  }
  if (PlaybackStorage.get())
  {
    MSContext::StartTimer("StoragePlayback");
    LoadStatesFromStorage();
    MSContext::StopTimer("StoragePlayback");
  }
  if (RecordDatabase.get())
  {
    MSContext::StartTimer("StorageRecord");
    RecordStatesToDatabase();
    MSContext::StopTimer("StorageRecord");
  }
  if (RecordStorage.get())
  {
    MSContext::StartTimer("StorageRecord");
    RecordStatesToStorage();
    MSContext::StopTimer("StorageRecord");
  }
}


void MSSessionStorage::RegisterStorage(MSSessionStorageInterface& storage)
{
  if (SessionStorages.contains(&storage))
  {
    MC_WARNING("This storage is registered already!");
    return;
  }
  SessionStorages.append(QPointer<MSSessionStorageInterface>(&storage));
}


void MSSessionStorage::RemoveStorages()
{
  if (SessionStorages.isEmpty())
  {
    MC_WARNING("No storage have been loaded yet!");
    return;
  }
  Finalize();
  // Clean up the storages
  SessionStorages.clear();
}


void MSSessionStorage::ResetTimers()
{
  MSContext::ResetTimer("StoragePlayback");
  MSContext::ResetTimer("StorageRecord");
}


void MSSessionStorage::RegisterElement(MSElement& element)
{
  if (element.GetElementID() == -1)
  {
    MC_WARNING("Object does not have valid ID!");
    return;
  }
  if (!RecordDatabase.get() && !RecordStorage.get() && !PlaybackDatabase.get() && !PlaybackStorage.get())
  {
    MC_WARNING("Nor a recorded neither a new database has not been opened yet.");
    return;
  }
  if (RegElements.contains(&element))
  {
    MC_WARNING("The element instance has been registered already.");
    return;
  }
  if (element.GetType() != MS::Source)
  {
    MC_WARNING("The class of the element is not a source class.");
    return;
  }
  QString ClassName = element.GetClass();

  if (PlaybackDatabase.get())
  {
    QString SqlQuery1;
    QString SqlQuery2;

    SqlQuery1 = "SELECT DISTINCT ID FROM "+ClassName.toUpper()+
                " WHERE ID = "+QString::number(element.GetElementID())+';';
    SqlQuery2 = "SELECT DISTINCT ID FROM "+ClassName.toUpper()+';';
    if (ExecuteSqlQuery(*PlaybackDatabase, SqlQuery1).isEmpty())
    {
      QString Result = ExecuteSqlQuery(*PlaybackDatabase, SqlQuery2);
      bool ConversionResult = true;
      int CandidateID = Result.toInt(&ConversionResult);

      // Only one candidate ID can be re-mapped to one source object
      if (Result.contains(','))
      {
        QString Message = "The source element ("+ClassName+") is not found in the database with the ID "+
                          QString::number(element.GetElementID())+" and there are more candidate IDs ("+
                          Result+"), thus re-mapping cannot be done reliably.";

        MC_ERROR(qPrintable(Message));
      }
      if (!ConversionResult)
      {
        QString Message = "The element class "+ClassName+" with ID "+QString::number(element.GetElementID())+
                          " is not found in the played session and no candidate ID available.";

        MC_ERROR(qPrintable(Message));
      }
      if (element.GetElementID() != CandidateID)
      {
        RemappedIDs.insert(element.GetElementID(), CandidateID);
        QString Message = "The source element "+ClassName+" with ID "+QString::number(element.GetElementID())+
                          " has been re-mapped to the candidate ID "+Result+'.';

        MC_WARNING(qPrintable(Message));
      }
    }
    if (!TableColumns.contains(ClassName))
    {
      QString ResultStr = ExecuteSqlQuery(*PlaybackDatabase, QString("PRAGMA table_info(%1);").arg(ClassName));
      QStringList Columns;
      bool DataEnd = false;
      int i1 = 3;

      // Create the cache of the columns
      while (!DataEnd)
      {
        QString Column = ResultStr.section(',', 1+i1*6, 1+i1*6);

        if (!Column.isEmpty())
        {
          Columns += Column;
        } else {
          DataEnd = true;
        }
        i1++;
      }
      // TODO: Race conditions? Empty database?
      if (PlayedHeartBeats == 0)
      {
        QString QuesryStr = QString("SELECT BEATID FROM %1 ORDER BY BEATID DESC LIMIT 1;").arg(ClassName);
        QString ResultStr = ExecuteSqlQuery(*PlaybackDatabase, QuesryStr);

        PlayedHeartBeats = ResultStr.toInt();
      }
      if (!Columns.isEmpty())
      {
        TableColumns[ClassName] = Columns;
      }
    }
  }
  if (PlaybackStorage.get())
  {
    MC::DataContainerSPtr ElementsContainer = PlaybackStorage->GetContainer("SourceElements");

    if (!ElementsContainer.get())
    {
      MC_ERROR("No SourceElements container in the session storage in playback mode");
    }
    MCDataItemBase* IDsPtr = ElementsContainer->GetData("IDs");
    MCDataItemBase* ElementsPtr = ElementsContainer->GetData("Elements");

    if (!IDsPtr || !ElementsPtr)
    {
      MC_ERROR("No IDs or Elements items in SourceElements container in the session storage in playback mode");
    }
    MC::StringList* IDs = reinterpret_cast<MC::StringList*>(IDsPtr->DataPtr);
    MC::StringList* Elements = reinterpret_cast<MC::StringList*>(ElementsPtr->DataPtr);
    int ElementsInStorage = MCItemCountInContainer(*Elements, ClassName.toStdString());

    if (ElementsInStorage == 0)
    {
      MC_WARNING("Can't register %s element because it is not in the playback storage",
                 qPrintable(ClassName));
      return;
    }
    // Only one candidate ID can be re-mapped to one source object
    if (ElementsInStorage > 1)
    {
      QString Message = "The source element ("+ClassName+") is not found in the storage with the ID "+
                        QString::number(element.GetElementID())+" and there are more candidate IDs ("+
                        QString::number(ElementsInStorage)+"), thus re-mapping cannot be done reliably.";

      MC_ERROR(qPrintable(Message));
    }
    bool ConversionResult = true;
    std::string Result = (*IDs)[MCItemIndicesInContainer(*Elements, ClassName.toStdString())[0]];
    int CandidateID = QString::fromStdString(Result).toInt(&ConversionResult);

    if (!ConversionResult)
    {
      QString Message = "The element class "+ClassName+" with ID "+QString::number(element.GetElementID())+
                        " is not found in the played session storage and no candidate ID available.";

      MC_ERROR(qPrintable(Message));
    }
    // Use the candidate ID for remapping
    if (element.GetElementID() != CandidateID)
    {
      RemappedIDs.insert(element.GetElementID(), CandidateID);
      QString Message = "The source element "+ClassName+" with ID "+QString::number(element.GetElementID())+
                        " has been re-mapped to the candidate ID "+Result.c_str()+'.';

      MC_WARNING(qPrintable(Message));
    }
    if (PlayedHeartBeats == 0)
    {
      void* HeartBeatsPtr = ElementsContainer->GetData("HeartBeats")->DataPtr;

      if (HeartBeatsPtr)
        PlayedHeartBeats = *reinterpret_cast<int*>(HeartBeatsPtr);
    }
  }
  if (RecordDatabase.get())
  {
    QString QueryStr = QString("INSERT INTO SOURCE_ELEMENTS VALUES(%1, '%2');").
                           arg(QString::number(element.GetElementID()), ClassName);

    MC_LOG("New element into the db: %s", qPrintable(QueryStr));
    ExecuteSqlQuery(*RecordDatabase, QueryStr);

    QString TempStr = RecordPath;

    TempStr += '/';
    TempStr += QString::number(element.GetElementID());

    MCCreatePath(TempStr);

    // Keep the list of registered class names up-to-date
    if (!ElementClassNames.contains(ClassName))
    {
      ElementClassNames += ClassName;
      CreateTableForAClass(element);
    }
  }

  if (RecordStorage.get())
  {
    MC::DataContainerSPtr ElementContainer = RecordStorage->GetContainer("SourceElements");

    if (!ElementContainer.get())
    {
      MC::StringList TempList;
      int TempInt = 0;

      ElementContainer = RecordStorage->CreateContainer("SourceElements");
      ElementContainer->AddData(*new MCDataItem<MC::StringList>(TempList, "IDs", true));
      ElementContainer->AddData(*new MCDataItem<MC::StringList>(TempList, "Elements", true));
      ElementContainer->AddData(*new MCDataItem<int>(TempInt, "HeartBeats", true));
    }
    void* IDsPtr = ElementContainer->GetData("IDs")->DataPtr;
    MC::StringList* IDs = reinterpret_cast<MC::StringList*>(IDsPtr);
    void* ElementsPtr = ElementContainer->GetData("Elements")->DataPtr;
    MC::StringList* Elements = reinterpret_cast<MC::StringList*>(ElementsPtr);

    IDs->push_back(MCToStr(element.GetElementID()));
    Elements->push_back(ClassName.toStdString());
    MC_LOG("New element into the storage: %s", qPrintable(ClassName));
    QString TempStr = RecordPath;

    TempStr += '/';
    TempStr += QString::number(element.GetElementID());
    MCCreatePath(TempStr);
    // Keep the list of registered class names up-to-date
    if (!ElementClassNames.contains(ClassName))
    {
      ElementClassNames += ClassName;
      CreateNewDataItemsForAClass(element);
    }
  }
  // Register the element instance
  RegElements.append(&element);
}


void MSSessionStorage::PrepareRecord()
{
  if (RecordDatabase.get())
  {
    MC_WARNING("A database has been opened for record already.");
    return;
  }
  if (RecordPath.isEmpty())
  {
    MC_WARNING("Record path has not been specified.");
    return;
  }
  MCCreatePath(RecordPath);
  // TODO: Remove Sqlite support?
//  CreateRecordDatabase();
  CreateRecordStorage();
}


void MSSessionStorage::PreparePlay()
{
  // Open a recorded session
  QString StorageName = PlaybackPath+"/Session.bdb";

  if (QFile(StorageName).exists())
  {
    OpenPlaybackStorage();
  } else {
    OpenPlaybackDatabase();
  }
}


void MSSessionStorage::Finalize()
{
  // Finalize playing the session
  if (!PlaybackPath.isEmpty())
  {
    if (PlaybackDatabase.get())
    {
      ClosePlaybackDatabase();
    }
    if (PlaybackStorage.get())
    {
      ClosePlaybackStorage();
    }
    SetPlaybackPath("");
    PlayedHeartBeats = 0;
  }
  // Finalize recording the session
  if (!RecordPath.isEmpty())
  {
    if (RecordDatabase.get())
    {
      CloseRecordDatabase();
    }
    if (RecordStorage.get())
    {
      CloseRecordStorage();
    }
    SetRecordPath("");
  }
  // Clean up the storages
  for (int i = 0; i < SessionStorages.size(); ++i)
  {
    if (!SessionStorages[i].isNull())
      SessionStorages[i].data()->Finalize();
  }
  // Unregister the element instances
  RegElements.clear();
  RemappedIDs.clear();
  // Delete the registered class names
  ElementClassNames.clear();
}


QString MSSessionStorage::ConstructFileName(int element_id, int beat_id, const QString& base_path,
                                            const QString& output_name,
                                            const MSSessionStorageInterface::StorageDataType& storage_type) const
{
  if (output_name.isEmpty())
  {
    MC_WARNING("Empty output name is not valid.");
    return QString();
  }
  if (base_path.isEmpty())
  {
    MC_WARNING("Empty base path is not valid.");
    return QString();
  }
  if (storage_type == MSSessionStorageInterface::sd_Unknown)
  {
    MC_WARNING("Unknown storage interface type is not valid.");
    return QString();
  }
  QString BinaryFileName = base_path;

  BinaryFileName += QDir::separator();
  BinaryFileName += QString::number(element_id);
  BinaryFileName += QDir::separator();
  BinaryFileName += output_name.toUpper();

  // Add suffix for the file name because it will be one file per heart beat.
  // Note: Video and audio streams go to one file per element.
  if (storage_type == MSSessionStorageInterface::sd_Binary)
  {
    BinaryFileName += '_';
    BinaryFileName += QString::number(beat_id);
  }
  BinaryFileName += '.';
  return BinaryFileName;
}


void MSSessionStorage::CreateRecordDatabase()
{
  if (!QSqlDatabase::drivers().contains("QSQLITE"))
  {
    MC_ERROR("Please install or compile the Qt's SQL driver for SQLite, it is required for AiBO+.");
  }
  QString DatabaseName = RecordPath;

  DatabaseName += "/Session.db";
  RecordDatabase.reset(new QSqlDatabase());
  *RecordDatabase = QSqlDatabase::addDatabase("QSQLITE", "RecordSession");
  RecordDatabase->setDatabaseName(DatabaseName);
  if (!RecordDatabase->open())
  {
    MC_ERROR("Sqlite error: %s", qPrintable(RecordDatabase->lastError().text()));
  }
  // Switch of the journal file to avoid high performance overhead
  ExecuteSqlQuery(*RecordDatabase, "PRAGMA journal_mode = OFF;");
#if defined(__MINGW32__) || defined(__MINGW64__)
  // Start one big transaction to avoid the high performance overhead under MinGW/Windows
  // On the other hand, the whole database can be lost in a nasty crash
  RecordDatabase->transaction();
#endif
  ExecuteSqlQuery(*RecordDatabase, "CREATE TABLE IF NOT EXISTS SOURCE_ELEMENTS(ID INTEGER, CLASSNAME TEXT);");
}


void MSSessionStorage::CreateTableForAClass(MSElement& element)
{
  if (!RecordDatabase.get())
  {
    MC_WARNING("Database has not been created for record yet.");
    return;
  }

  QStringList OutputList = element.GetOutputList();
  QString TableHeader;
  bool TypeFound = false;
  QString ClassName = element.GetClass();

  TableHeader = QString("CREATE TABLE IF NOT EXISTS %1 (ID INTEGER, BEATID INTEGER, OUTPUTS TEXT").
                arg(ClassName.toUpper());

  // Do not create a table because there is no output data
  if (OutputList.isEmpty())
    return;

  // Process the possible output data to store in the database
  for (int i = 0; i < OutputList.size(); ++i)
  {
    if (OutputList[i].isEmpty())
    {
      MC_WARNING("The %d. parameter is empty in the output list of the element class: %s",
                 i, qPrintable(ClassName));
      continue;
    }
    if (OutputList[i].contains(","))
    {
      MC_ERROR("The %d. parameter contains prohibited COMMA in the output list of the element class: %s",
               i, qPrintable(ClassName));
    }
    QString OutputName = OutputList[i].section(':', 0, 0);
    QString OutputType = OutputList[i].section(':', 1, 1);

    if (OutputName.isEmpty() || OutputType.isEmpty())
    {
      MC_ERROR("An output parameter has wrong syntax for class %s. "
               "The string \'%s\' must follow the 'name:type' format.",
               qPrintable(ClassName), qPrintable(OutputList[i]));
    }
    // Get the appropriate storage
    MSSessionStorageInterface* Storage = GetStorage(OutputType);

    if (!Storage)
    {
      MC_ERROR("Unable to find a storage for type %s.", qPrintable(OutputType));
    }

    MSData* OutputData = element.GetOutputData(OutputList[i]);

    if (!OutputData)
    {
      MC_ERROR("Output data %s cannot be fetched from %s.", qPrintable(OutputList[i]), qPrintable(ClassName));
    }
    if (OutputData->GetVariableMap().isEmpty())
    {
      MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(OutputType);

      TypeFound = true;
      if (StorageType == MSSessionStorageInterface::sd_Unknown)
      {
        MC_ERROR("Type %s cannot be translated to an Sql type.", qPrintable(OutputType));
      }
      if (StorageType == MSSessionStorageInterface::sd_Binary ||
          StorageType == MSSessionStorageInterface::sd_BinaryStream)
      {
        continue;
      }
      TableHeader += ", ";
      TableHeader += OutputName.toUpper();
      TableHeader += ' ';

      if (StorageType == MSSessionStorageInterface::sd_Text)
      {
        TableHeader += "TEXT";
      } else
      if (StorageType == MSSessionStorageInterface::sd_Integer)
      {
        TableHeader += "INTEGER";
      } else
      if (StorageType == MSSessionStorageInterface::sd_Real)
      {
        TableHeader += "REAL";
      }
    } else {
      TypeFound = true;
      // Process the structure
      for (auto iter = OutputData->GetVariableMap().constBegin(); iter != OutputData->GetVariableMap().constEnd(); ++iter)
      {
        if (iter.key().isEmpty())
        {
          MC_ERROR("A parameter is empty in the field list of the type: %s", qPrintable(OutputType));
        }
        QString FieldName = iter.key().section(':', 0, 0);
        QString FieldType = iter.key().section(':', 1, 1);

        if (FieldName.isEmpty() || FieldType.isEmpty())
        {
          MC_ERROR("A field has wrong syntax for type %s. The string \'%s\' must follow the 'name:type' format.",
                   qPrintable(OutputType), qPrintable(iter.key()));
        }

        MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(FieldType);

        if (StorageType == MSSessionStorageInterface::sd_Unknown)
        {
          MC_ERROR("Field %s in the type %s cannot be translated to an Sql type.",
                   qPrintable(FieldType), qPrintable(OutputType));
        }
        if (StorageType == MSSessionStorageInterface::sd_Binary ||
            StorageType == MSSessionStorageInterface::sd_BinaryStream)
        {
          continue;
        }
        TableHeader += ", "+OutputName.toUpper()+'_'+FieldName.toUpper()+' ';

        if (StorageType == MSSessionStorageInterface::sd_Text)
        {
          TableHeader += "TEXT";
        }
        if (StorageType == MSSessionStorageInterface::sd_Integer)
        {
          TableHeader += "INTEGER";
        }
        if (StorageType == MSSessionStorageInterface::sd_Real)
        {
          TableHeader += "REAL";
        }
      } // End of iterating through a structure
    } // End of processing a structure
  } // End of output list processing

  // Do not create a table because there is no output data
  if (!TypeFound)
  {
    MC_ERROR("No output type to store from a source element?!?");
  }
  TableHeader += ");";
  ExecuteSqlQuery(*RecordDatabase, TableHeader);
}


void MSSessionStorage::LoadStatesFromDatabase()
{
  if (!PlaybackDatabase.get())
  {
    MC_WARNING("Database has not been opened for play yet.");
    return;
  }
  // Load the recorded states of the sources
  for (int i = 0; i < RegElements.size(); ++i)
  {
    QStringList OutputList = RegElements[i]->GetOutputList();
    QString ClassName = RegElements[i]->GetClass();
    int ElementID = RegElements[i]->GetElementID();
    int BeatID = RegElements[i]->GetBeatID();
    QString QueryPart2;

    // Continue if there is no output data
    if (OutputList.isEmpty())
    {
      continue;
    }
    // Re-mapping the source element ID to the candidate ID
    if (RemappedIDs.contains(ElementID))
    {
      ElementID = RemappedIDs[ElementID];
    }
    // Construct the second part of the SQL queries
    QueryPart2 = "FROM "+ClassName.toUpper()+" WHERE ID = "+QString::number(ElementID)+
                 " AND BEATID = "+QString::number(BeatID)+';';
    // Extract the actual outputs from the database
    RegElements[i]->CurrentOutputList = ExecuteSqlQuery(*PlaybackDatabase, "SELECT OUTPUTS "+QueryPart2).split(',');

    // Process the output data to load from the database
    for (int i1 = 0; i1 < OutputList.size(); ++i1)
    {
      QString QueryPart1;

      if (OutputList[i1].isEmpty())
      {
        MC_WARNING("The %d. parameter is empty in the output list of the element class: %s",
                   i1, qPrintable(ClassName));
        continue;
      }

      QString OutputName = OutputList[i1].section(':', 0, 0);
      QString OutputType = OutputList[i1].section(':', 1, 1);

      // The output is not available in this heart beat
      if (!RegElements[i]->CurrentOutputList.contains(OutputList[i1]))
        continue;

      if (OutputName.isEmpty() || OutputType.isEmpty())
      {
        MC_ERROR("An output has wrong syntax for class %s. The string \'%s\' must follow the 'name:type' format.",
                 qPrintable(ClassName), qPrintable(OutputList[i1]));
      }
      // Get the appropriate storage
      MSSessionStorageInterface* Storage = GetStorage(OutputType);

      if (!Storage)
      {
        MC_ERROR("Unable to find a storage for type %s.", qPrintable(OutputType));
      }
      // Extract the type fields
      MSData* OutputData = RegElements[i]->GetOutputData(OutputList[i1]);

      if (!OutputData)
      {
        MC_ERROR("Output data %s cannot be fetched from %s.", qPrintable(OutputList[i1]), qPrintable(ClassName));
      }
      // It is a simple type
      if (OutputData->GetVariableMap().isEmpty())
      {
        // Extract the output data
        MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(OutputType);

        if (StorageType == MSSessionStorageInterface::sd_Unknown)
        {
          MC_ERROR("Type %s cannot be translated to a storage type. Implementation is missing "
                   "in the registered storages.", qPrintable(OutputType));
        }
        if (StorageType == MSSessionStorageInterface::sd_Text ||
            StorageType == MSSessionStorageInterface::sd_Integer ||
            StorageType == MSSessionStorageInterface::sd_Real)
        {
          // Let's continue if the column does not exist in the database
          if (!TableColumns[ClassName].contains(OutputName.toUpper()))
            continue;

          QueryPart1 = "SELECT "+OutputName.toUpper()+' '+QueryPart2;
          QString ResultStr = ExecuteSqlQuery(*PlaybackDatabase, QueryPart1);

          if (!Storage->ConvertSqlStringToData(OutputType, ResultStr, OutputData))
          {
            MC_ERROR("Type %s cannot be extracted from the Sql string. Implementation is missing "
                     "in the storages in MSSessionStorageInterface::ConvertSqlStringToData().",
                     qPrintable(OutputType));
          }
          continue;
        }
        if (StorageType == MSSessionStorageInterface::sd_Binary ||
            StorageType == MSSessionStorageInterface::sd_BinaryStream)
        {
          QString FileName = ConstructFileName(ElementID, BeatID, PlaybackPath, OutputName, StorageType);

          if (!Storage->LoadBinaryDataFromFile(FileName, OutputType, StorageType, OutputData))
          {
            MC_ERROR("Unable to load type %s as binary. Implementation is missing in the storages in "
                     "MSSessionStorageInterface::LoadBinaryDataFromFile().", qPrintable(OutputType));
          }
          continue;
        }
      } else {
        // Cache of the field types and data to improve the performance
        QList<QString> FieldTypeList;
        QList<void*> FieldDataList;

        QueryPart1 = "SELECT ";
        // Process the structure
        for (auto iter = OutputData->GetVariableMap().constBegin(); iter != OutputData->GetVariableMap().constEnd(); ++iter)
        {
          // Check the variable
          if (iter.key().isEmpty())
          {
            MC_ERROR("A parameter is empty in the field list of the type: %s",
                     qPrintable(OutputType));
          }
          // Check the variable data
          if (!iter.value())
          {
            MC_ERROR("Field %s in the type %s cannot be extracted.",
                     qPrintable(iter.key()), qPrintable(OutputType));
          }
          QString FieldName = iter.key().section(':', 0, 0);
          QString FieldType = iter.key().section(':', 1, 1);

          if (FieldName.isEmpty() || FieldType.isEmpty())
          {
            MC_ERROR("A field has wrong syntax for type %s. "
                     "The string \'%s\' must follow the 'name:type' format.",
                     qPrintable(OutputType), qPrintable(iter.key()));
          }

          // Get the storage type
          MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(FieldType);

          if (StorageType == MSSessionStorageInterface::sd_Unknown)
          {
            MC_ERROR("Field %s in the type %s cannot be translated to an Sql type."
                     "Implementation is missing in the storages in MSSessionStorageInterface::FindStorageType().",
                     qPrintable(FieldType), qPrintable(OutputType));
          }
          if (StorageType == MSSessionStorageInterface::sd_Text ||
              StorageType == MSSessionStorageInterface::sd_Integer ||
              StorageType == MSSessionStorageInterface::sd_Real)
          {
            // Let's continue if the column does not exist in the database
            if (!TableColumns[ClassName].contains(OutputName.toUpper()+'_'+FieldName.toUpper()))
              continue;

            QueryPart1 += OutputName.toUpper()+'_'+FieldName.toUpper()+',';
            FieldTypeList += FieldType;
            FieldDataList += iter.value();
            continue;
          }
          if (StorageType == MSSessionStorageInterface::sd_Binary ||
              StorageType == MSSessionStorageInterface::sd_BinaryStream)
          {
            QString IDStr = OutputName.toUpper()+'_'+FieldName.toUpper();
            QString FileName = ConstructFileName(ElementID, BeatID, PlaybackPath, IDStr, StorageType);

            if (!Storage->LoadBinaryDataFromFile(FileName, FieldType, StorageType, iter.value()))
            {
              MC_ERROR("Unable to load type %s as binary. Implementation is missing in the storages in "
                       "MSSessionStorageInterface::LoadBinaryDataFromFile().", qPrintable(FieldType));
            }
            continue;
          } // End of storage if {}
        } // End of structure processing for {}

        // Execute the query of the needed fields in a more efficient way at one query
        QueryPart1.remove(QueryPart1.length()-1, 1);
        QueryPart1 += ' '+QueryPart2;
        QStringList Results = ExecuteSqlQuery(*PlaybackDatabase, QueryPart1).split(',');

        // Process the queried fields
        for (int i3 = 0; i3 < FieldTypeList.size(); ++i3)
        {
          if (!Storage->ConvertSqlStringToData(FieldTypeList[i3], Results[i3], FieldDataList[i3]))
          {
            MC_ERROR("Type %s cannot be extracted from the Sql string. Implementation is missing in "
                     "the storages in MSSessionStorageInterface::ConvertSqlStringToData().",
                     qPrintable(FieldTypeList[i3]));
          }
        } // End of the processing the cache query {}
      } // End of structure if {}
    } // End of output list for {}
  } // End of elements for {}

  // End of database signal
  if (RegElements.size() > 0 && RegElements[0]->GetBeatID() == PlayedHeartBeats)
  {
    MC_LOG("End of played session database");
    Q_EMIT(EndOfDatabase());
  }
}


void MSSessionStorage::RecordStatesToDatabase()
{
  if (!RecordDatabase.get())
  {
    MC_WARNING("Database has not been created for record yet.");
    return;
  }

  for (int i = 0; i < RegElements.size(); ++i)
  {
    QStringList OutputList = RegElements[i]->GetOutputList();
    QString InsertIDStr;
    QString InsertValueStr;
    QString ClassName = RegElements[i]->GetClass();
    int ElementID = RegElements[i]->GetElementID();
    int BeatID = RegElements[i]->GetBeatID();

    // Continue if there is no output data
    if (OutputList.isEmpty())
    {
      continue;
    }

    InsertIDStr = QString("INSERT INTO %1 (ID, BEATID, OUTPUTS").arg(ClassName.toUpper());
    InsertValueStr = QString("VALUES (%1, %2, '%3'").arg(QString::number(ElementID), QString::number(BeatID),
                                                         RegElements[i]->CurrentOutputList.join(","));

    // Process the possible output data to store in the database
    for (int i1 = 0; i1 < OutputList.size(); ++i1)
    {
      if (OutputList[i1].isEmpty())
      {
        MC_WARNING("The %d. parameter is empty in the output list of the element class: %s",
                   i1, qPrintable(ClassName));
        continue;
      }
      QString OutputName = OutputList[i1].section(':', 0, 0);
      QString OutputType = OutputList[i1].section(':', 1, 1);

      // The output is not available in this heart beat
      if (!RegElements[i]->CurrentOutputList.contains(OutputList[i1]))
      {
        continue;
      }
      if (OutputName.isEmpty() || OutputType.isEmpty())
      {
        MC_ERROR("An output has wrong syntax for class %s. The string \'%s\' must follow the 'name:type' format.",
                 qPrintable(ClassName), qPrintable(OutputList[i1]));
      }

      // Get the appropriate storage
      MSSessionStorageInterface* Storage = GetStorage(OutputType);

      if (!Storage)
      {
        MC_ERROR("Unable to find a storage for type %s.", qPrintable(OutputType));
      }

      // Extract the output data
      MSData* OutputData = RegElements[i]->GetOutputData(OutputList[i1]);

      // No output data, let's continue.
      if (!OutputData)
      {
        continue;
      }
      // It is a simple type
      if (OutputData->GetVariableMap().isEmpty())
      {
        MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(OutputType);

        if (StorageType == MSSessionStorageInterface::sd_Unknown)
        {
          MC_ERROR("Type %s cannot be translated to a storage type. Implementation is missing "
                   "in the storages in MSSessionStorageInterface::FindStorageType().",
                   qPrintable(OutputType));
        }
        if (StorageType == MSSessionStorageInterface::sd_Text ||
            StorageType == MSSessionStorageInterface::sd_Integer ||
            StorageType == MSSessionStorageInterface::sd_Real)
        {
          QString SqlValue = Storage->ConvertDataToSqlString(OutputType, OutputData);

          if (SqlValue.isEmpty())
          {
            MC_ERROR("Type %s cannot be converted to an Sql type. Implementation is missing "
                     "in the storages in MSSessionStorageInterface::ConvertDataToSqlString().",
                     qPrintable(OutputType));
          } else {
            InsertIDStr += ", "+OutputName.toUpper();
            InsertValueStr += ", \""+SqlValue+"\"";
          }
          continue;
        }
        if (StorageType == MSSessionStorageInterface::sd_Binary ||
            StorageType == MSSessionStorageInterface::sd_BinaryStream)
        {
          QString FileName = ConstructFileName(ElementID, BeatID, RecordPath, OutputName, StorageType);

          if (!Storage->SaveBinaryDataToFile(FileName, OutputType, StorageType, OutputData))
          {
            MC_ERROR("Unable to save type %s as binary. Implementation is missing "
                     "in the storages in MSSessionStorageInterface::SaveBinaryDataToFile().",
                     qPrintable(OutputType));
          }
          continue;
        }
      } else {
        // Process the structure
        for (auto iter = OutputData->GetVariableMap().constBegin(); iter != OutputData->GetVariableMap().constEnd(); ++iter)
        {
          // Check the variable
          if (iter.key().isEmpty())
          {
            MC_ERROR("A parameter is empty in the field list of the type: %s",
                     qPrintable(OutputType));
          }
          // Check the variable data
          if (!iter.value())
          {
            MC_ERROR("Field %s in the type %s cannot be extracted.",
                     qPrintable(iter.key()), qPrintable(OutputType));
          }

          QString FieldName = iter.key().section(':', 0, 0);
          QString FieldType = iter.key().section(':', 1, 1);

          if (FieldName.isEmpty() || FieldType.isEmpty())
          {
            MC_ERROR("A field has wrong syntax for type %s. "
                     "The string \'%s\' must follow the 'name:type' format.",
                     qPrintable(OutputType), qPrintable(iter.key()));
          }

          // Process the output data
          MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(FieldType);

          if (StorageType == MSSessionStorageInterface::sd_Unknown)
          {
            MC_ERROR("Field %s in the type %s cannot be translated to an Sql type."
                     "Implementation is missing in the storages in MSSessionStorageInterface::FindStorageType().",
                     qPrintable(FieldType), qPrintable(OutputType));
          }
          if (StorageType == MSSessionStorageInterface::sd_Text ||
              StorageType == MSSessionStorageInterface::sd_Integer ||
              StorageType == MSSessionStorageInterface::sd_Real)
          {
            QString SqlValue = Storage->ConvertDataToSqlString(FieldType, iter.value());

            if (SqlValue.isEmpty())
            {
              MC_ERROR("Type %s cannot be converted to an Sql type. Implementation is missing "
                       "in the storages in MSSessionStorageInterface::ConvertDataToSqlString().",
                       qPrintable(OutputType));
            } else {
              InsertIDStr += ", "+OutputName.toUpper()+'_'+FieldName.toUpper();
              InsertValueStr += ", "+SqlValue;
            }
            continue;
          }
          if (StorageType == MSSessionStorageInterface::sd_Binary ||
              StorageType == MSSessionStorageInterface::sd_BinaryStream)
          {
            QString IDStr = OutputName.toUpper()+'_'+FieldName.toUpper();
            QString FileName = ConstructFileName(ElementID, BeatID, RecordPath, IDStr, StorageType);

            if (!Storage->SaveBinaryDataToFile(FileName, FieldType, StorageType, iter.value()))
            {
              MC_ERROR("Unable to save type %s as binary. Implementation is missing "
                       "in the storages in MSSessionStorageInterface::SaveBinaryDataToFile().",
                       qPrintable(OutputType));
            }
            continue;
          } // End of storage if {}
        } // End of structure processing for {}
      } // End of structure if {}
    } // End of output list for {}

    // Finish the Sql insert
    InsertIDStr += ") "+InsertValueStr+");";
    ExecuteSqlQuery(*RecordDatabase, InsertIDStr);
  } // End of elements for {}
}


MSSessionStorageInterface* MSSessionStorage::GetStorage(const QString& type_name) const
{
  if (type_name.isEmpty())
  {
    MC_WARNING("Empty type name is not valid.");
    return nullptr;
  }
  for (int i = 0; i < SessionStorages.size(); ++i)
  {
    if (SessionStorages[i]->GetSupportedTypes().contains(type_name))
    {
      return SessionStorages[i];
    }
  }
  return nullptr;
}


QString MSSessionStorage::ExecuteSqlQuery(const QSqlDatabase& database, const QString& query_str) const
{
  if (query_str.isEmpty())
  {
    MC_WARNING("Empty query string is not valid.");
    return nullptr;
  }
  QSqlQuery Query(database);
  QStringList Results;

  if (!Query.exec(qPrintable(query_str)))
  {
    if (!Query.lastError().text().isEmpty())
    {
      MC_WARNING("Sqlite query: %s", qPrintable(query_str));
      MC_WARNING("Sqlite error in the query: %s", qPrintable(Query.lastError().text()));
    }
    if (!database.lastError().text().isEmpty())
    {
      MC_WARNING("Sqlite error in the database: %s", qPrintable(database.lastError().text()));
    }
    return QString();
  }

  while (Query.next())
  {
    for (int i = 0; Query.value(i) != QVariant::Invalid; ++i)
      Results += Query.value(i).toString();
  }

  if (!Results.isEmpty())
  {
    return Results.join(",");
  } else {
    return QString();
  }
}


void MSSessionStorage::CloseRecordDatabase()
{
  if (!RecordDatabase.get())
  {
    MC_WARNING("Database has not been created for record yet.");
    return;
  }
#if defined(__MINGW32__) || defined(__MINGW64__)
  // Commit one big transaction to avoid the high performance overhead under MinGW/Windows
  // On the other hand, the whole database can be lost in a nasty crash
  RecordDatabase->commit();
#endif
  RecordDatabase->close();
  RecordDatabase.reset();
  QSqlDatabase::removeDatabase("RecordSession");
}


void MSSessionStorage::OpenPlaybackDatabase()
{
  if (PlaybackPath.isEmpty())
  {
    MC_WARNING("Session playback location has not been set.");
    return;
  }
  if (PlaybackDatabase.get())
  {
    MC_WARNING("A database has been opened for play already.");
    return;
  }
  QString DatabaseName = PlaybackPath;

  DatabaseName += "/Session.db";
  if (!QSqlDatabase::drivers().contains("QSQLITE"))
  {
    MC_ERROR("Please install or compile the Qt's SQL driver for SQLite, it is required for AiBO+.");
  }
  PlaybackDatabase.reset(new QSqlDatabase());
  *PlaybackDatabase = QSqlDatabase::addDatabase("QSQLITE", "PlaybackSession");
  PlaybackDatabase->setDatabaseName(DatabaseName);
  if (!QFile(DatabaseName).exists())
  {
    MC_ERROR("Database file does not exist: %s", qPrintable(DatabaseName));
  }
  if (!PlaybackDatabase->open())
  {
    MC_ERROR("Sqlite error: %s", qPrintable(RecordDatabase->lastError().text()));
  }
  TableColumns.clear();
}


void MSSessionStorage::ClosePlaybackDatabase()
{
  if (!PlaybackDatabase.get())
  {
    MC_WARNING("Database has not been opened for play yet.");
    return;
  }
  PlaybackDatabase->close();
  PlaybackDatabase.reset();
  QSqlDatabase::removeDatabase("PlaybackSession");
}


void MSSessionStorage::CreateRecordStorage()
{
  QString StorageName = RecordPath+"/Session.bdb";

  RecordStorage.reset(new MCDataStorage("RecordSession", true));
  if (!RecordStorage->SaveToFile(StorageName.toStdString()))
  {
    MC_ERROR("Can't create session storage (%s)", qPrintable(StorageName));
  }
}


void MSSessionStorage::CreateNewDataItemsForAClass(MSElement& element)
{
  if (!RecordStorage.get())
  {
    MC_WARNING("Storage has not been created for record yet.");
    return;
  }
  QStringList OutputList = element.GetOutputList();

  // Do not create a table because there is no output data
  if (OutputList.isEmpty())
    return;

  bool TypeFound = false;
  std::string ClassName = element.GetClass().toStdString();
  MC::StringTable NewTable;
  MC::StringList TableHeader;
  MC::DataContainerSPtr ElementContainer = RecordStorage->GetContainer(ClassName);

  if (!ElementContainer.get())
  {
    ElementContainer = RecordStorage->CreateContainer(ClassName);
  }
  // First column
  TableHeader.push_back("ID");
  // Second column
  TableHeader.push_back("Outputs");
  // Process the possible output data to store in the database
  for (int i = 0; i < OutputList.size(); ++i)
  {
    if (OutputList[i].isEmpty())
    {
      MC_WARNING("The %d. parameter is empty in the output list of the element class: %s",
                 i, ClassName.c_str());
      continue;
    }
    QString OutputName = OutputList[i].section(':', 0, 0);
    QString OutputType = OutputList[i].section(':', 1, 1);

    if (OutputName.isEmpty() || OutputType.isEmpty())
    {
      MC_ERROR("An output parameter has wrong syntax for class %s. "
               "The string \'%s\' must follow the 'name:type' format.",
               ClassName.c_str(), qPrintable(OutputList[i]));
    }
    // Get the appropriate storage
    MSSessionStorageInterface* Storage = GetStorage(OutputType);

    if (!Storage)
    {
      MC_ERROR("Unable to find a storage for type %s.", qPrintable(OutputType));
    }
    MSData* OutputData = element.GetOutputData(OutputList[i]);

    if (!OutputData)
    {
      MC_ERROR("Output data %s cannot be fetched from %s.", qPrintable(OutputList[i]),
               ClassName.c_str());
    }
    if (OutputData->GetVariableMap().isEmpty())
    {
      MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(OutputType);

      TypeFound = true;
      if (StorageType == MSSessionStorageInterface::sd_Unknown)
      {
        MC_ERROR("Type %s cannot be translated to an Sql type.", qPrintable(OutputType));
      }
      if (StorageType == MSSessionStorageInterface::sd_Binary ||
          StorageType == MSSessionStorageInterface::sd_BinaryStream)
      {
        continue;
      }
      if (StorageType == MSSessionStorageInterface::sd_Text)
      {
        TableHeader.push_back(OutputName.toStdString());
      } else
      if (StorageType == MSSessionStorageInterface::sd_Integer)
      {
        TableHeader.push_back(OutputName.toStdString());
      } else
      if (StorageType == MSSessionStorageInterface::sd_Real)
      {
        TableHeader.push_back(OutputName.toStdString());
      }
    } else {
      TypeFound = true;
      // Process the structure
      for (auto iter = OutputData->GetVariableMap().constBegin(); iter != OutputData->GetVariableMap().constEnd(); ++iter)
      {
        if (iter.key().isEmpty())
        {
          MC_ERROR("A parameter is empty in the field list of the type: %s", qPrintable(OutputType));
        }
        QString FieldName = iter.key().section(':', 0, 0);
        QString FieldType = iter.key().section(':', 1, 1);

        if (FieldName.isEmpty() || FieldType.isEmpty())
        {
          MC_ERROR("A field has wrong syntax for type %s. The string \'%s\' must follow the 'name:type' format.",
                   qPrintable(OutputType), qPrintable(iter.key()));
        }
        MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(FieldType);

        if (StorageType == MSSessionStorageInterface::sd_Unknown)
        {
          MC_ERROR("Field %s in the type %s cannot be translated to an Sql type.",
                   qPrintable(FieldType), qPrintable(OutputType));
        }
        if (StorageType == MSSessionStorageInterface::sd_Binary ||
            StorageType == MSSessionStorageInterface::sd_BinaryStream)
        {
          continue;
        }
        if (StorageType == MSSessionStorageInterface::sd_Text)
        {
          TableHeader.push_back(OutputName.toStdString()+'_'+FieldName.toStdString());
        }
        if (StorageType == MSSessionStorageInterface::sd_Integer)
        {
          TableHeader.push_back(OutputName.toStdString()+'_'+FieldName.toStdString());
        }
        if (StorageType == MSSessionStorageInterface::sd_Real)
        {
          TableHeader.push_back(OutputName.toStdString()+'_'+FieldName.toStdString());
        }
      } // End of iterating through a structure
    } // End of processing a structure
  } // End of output list processing

  // Do not create a table because there is no output data
  if (!TypeFound)
  {
    MC_ERROR("No output type to store from a source element?!?");
  }
  std::string ContainerIndexStr = MCToStr((element.GetBeatID() / RecordStoragePeriod)+1);
  MC::StringList BeatIDs;

  ElementContainer->AddData(*new MCDataItem<MC::StringList>(BeatIDs, "BeatIDs::"+ContainerIndexStr, true));
  NewTable.push_back(TableHeader);
  ElementContainer->AddData(*new MCDataItem<MC::StringTable>(NewTable, ClassName+"::"+ContainerIndexStr, true));
}


void MSSessionStorage::LoadStatesFromStorage()
{
  if (!PlaybackStorage.get())
  {
    MC_WARNING("Storage has not been opened for playback yet.");
    return;
  }
  // Load the recorded states of the sources
  for (int i = 0; i < RegElements.size(); ++i)
  {
    QString ClassName = RegElements[i]->GetClass();
    int BeatID = RegElements[i]->GetBeatID();
    MC::DataContainerSPtr ElementContainer = PlaybackStorage->GetContainer(ClassName.toStdString());

    if (!ElementContainer.get() || !RegElements[i]->HasOutputs())
      continue;

    std::string ContainerIndexStr = MCToStr((BeatID / RecordStoragePeriod)+1);
    void* BeatIDsPtr = ElementContainer->GetData("BeatIDs::"+ContainerIndexStr)->DataPtr;
    MC::StringList* BeatIDs = reinterpret_cast<MC::StringList*>(BeatIDsPtr);
    std::string OutputsTableContainerName = ClassName.toStdString()+"::"+ContainerIndexStr;
    void* OutputsTablePtr = ElementContainer->GetData(OutputsTableContainerName)->DataPtr;
    MC::StringTable* OutputsTable = reinterpret_cast<MC::StringTable*>(OutputsTablePtr);

    if (!BeatIDs || !OutputsTable)
      continue;

    std::string BeatIDStr = MCToStr(BeatID);
    std::pair<int, std::string> Result = MCBinarySearch(*BeatIDs, BeatIDStr);
    QStringList OutputList = RegElements[i]->GetOutputList();
    int FinalIndex = 0;

    // Continue if the beat ID is not found
    if (Result.first == -1)
      continue;

    // Re-mapping source element ID to candidate ID
    int ElementID = RegElements[i]->GetElementID();

    if (RemappedIDs.contains(ElementID))
    {
      ElementID = RemappedIDs[ElementID];
    }
    std::string ElementIDStr = MCToStr(ElementID);

    // Determinate the exact line in the table with the outputs
    for (unsigned int i1 = Result.first; i1 < BeatIDs->size(); ++i1)
    {
      if ((*OutputsTable)[i1][0] == ElementIDStr)
      {
        FinalIndex = i1+1;
        break;
      }
    }
    // Extract the actual outputs from the database
    RegElements[i]->CurrentOutputList = QString::fromStdString((*OutputsTable)[FinalIndex][1]).split(',');
    // Remove empty output names
    for (int i1 = 0; i1 < RegElements[i]->CurrentOutputList.size(); ++i1)
    {
      if (RegElements[i]->CurrentOutputList[i1].isEmpty())
      {
        RegElements[i]->CurrentOutputList.removeAt(i1);
        --i1;
      }
    }
    // Process the output data to load from the database
    for (int i1 = 0; i1 < RegElements[i]->CurrentOutputList.size(); ++i1)
    {
      if (RegElements[i]->CurrentOutputList[i1].isEmpty())
      {
        MC_WARNING("The %d. parameter is empty in the output list of the element class: %s",
                   i1, qPrintable(ClassName));
        continue;
      }
      // The output is not available in this heart beat
      if (!OutputList.contains(RegElements[i]->CurrentOutputList[i1]))
        continue;

      QString OutputName = RegElements[i]->CurrentOutputList[i1].section(':', 0, 0);
      QString OutputType = RegElements[i]->CurrentOutputList[i1].section(':', 1, 1);

      if (OutputName.isEmpty() || OutputType.isEmpty())
      {
        MC_ERROR("An output has wrong syntax for class %s. The string \'%s\' must follow the 'name:type' format.",
                 qPrintable(ClassName), qPrintable(RegElements[i]->CurrentOutputList[i1]));
      }
      // Get the appropriate storage
      MSSessionStorageInterface* Storage = GetStorage(OutputType);

      if (!Storage)
      {
        MC_ERROR("Unable to find a storage for type %s.", qPrintable(OutputType));
      }
      // Extract the type fields
      MSData* OutputData = RegElements[i]->GetOutputData(RegElements[i]->CurrentOutputList[i1]);

      if (!OutputData)
      {
        MC_ERROR("Output data %s cannot be fetched from %s.",
                 qPrintable(RegElements[i]->CurrentOutputList[i1]), qPrintable(ClassName));
      }
      // It is a simple type
      if (OutputData->GetVariableMap().isEmpty())
      {
        // Extract the output data
        MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(OutputType);

        if (StorageType == MSSessionStorageInterface::sd_Unknown)
        {
          MC_ERROR("Type %s cannot be translated to a storage type. Implementation is missing "
                   "in the registered storages.", qPrintable(OutputType));
        }
        if (StorageType == MSSessionStorageInterface::sd_Text ||
            StorageType == MSSessionStorageInterface::sd_Integer ||
            StorageType == MSSessionStorageInterface::sd_Real)
        {
          int DataIndex = -1;

          for (unsigned int i2 = 2; i2 < (*OutputsTable)[0].size(); ++i2)
          {
            if (QString::fromStdString((*OutputsTable)[0][i2]) == OutputName)
              DataIndex = i2;
          }
          // Let's continue if the column does not exist in the database
          if (DataIndex == -1)
            continue;

          QString ResultStr = QString::fromStdString((*OutputsTable)[FinalIndex][DataIndex]);

          if (!Storage->ConvertSqlStringToData(OutputType, ResultStr, OutputData))
          {
            MC_ERROR("Type %s cannot be extracted from the Sql string. Implementation is missing "
                     "in the storages in MSSessionStorageInterface::ConvertSqlStringToData().",
                     qPrintable(OutputType));
          }
          continue;
        }
        if (StorageType == MSSessionStorageInterface::sd_Binary ||
            StorageType == MSSessionStorageInterface::sd_BinaryStream)
        {
          QString FileName = ConstructFileName(ElementID, BeatID, PlaybackPath, OutputName, StorageType);

          if (!Storage->LoadBinaryDataFromFile(FileName, OutputType, StorageType, OutputData))
          {
            MC_ERROR("Unable to load type %s as binary. Implementation is missing in the storages in "
                     "MSSessionStorageInterface::LoadBinaryDataFromFile().", qPrintable(OutputType));
          }
          continue;
        }
      } else {
        // Process the structure
        for (auto iter = OutputData->GetVariableMap().constBegin(); iter != OutputData->GetVariableMap().constEnd(); ++iter)
        {
          // Check the variable
          if (iter.key().isEmpty())
          {
            MC_ERROR("A parameter is empty in the field list of the type: %s", qPrintable(OutputType));
          }
          // Check the variable data
          if (!iter.value())
          {
            MC_ERROR("Field %s in the type %s cannot be extracted.", qPrintable(iter.key()),
                     qPrintable(OutputType));
          }
          QString FieldName = iter.key().section(':', 0, 0);
          QString FieldType = iter.key().section(':', 1, 1);

          if (FieldName.isEmpty() || FieldType.isEmpty())
          {
            MC_ERROR("A field has wrong syntax for type %s. "
                     "The string \'%s\' must follow the 'name:type' format.",
                     qPrintable(OutputType), qPrintable(iter.key()));
          }
          // Get the storage type
          MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(FieldType);

          if (StorageType == MSSessionStorageInterface::sd_Unknown)
          {
            MC_ERROR("Field %s in the type %s cannot be translated to an Sql type."
                     "Implementation is missing in the storages in MSSessionStorageInterface::FindStorageType().",
                     qPrintable(FieldType), qPrintable(OutputType));
          }
          if (StorageType == MSSessionStorageInterface::sd_Text ||
              StorageType == MSSessionStorageInterface::sd_Integer ||
              StorageType == MSSessionStorageInterface::sd_Real)
          {
            int DataIndex = -1;

            for (unsigned int i2 = 2; i2 < (*OutputsTable)[0].size(); ++i2)
            {
              if (QString::fromStdString((*OutputsTable)[0][i2]) == OutputName+'_'+FieldName)
                DataIndex = i2;
            }
            // Let's continue if the column does not exist in the database
            if (DataIndex == -1)
              continue;

            QString ResultStr = QString::fromStdString((*OutputsTable)[FinalIndex][DataIndex]);
            if (!Storage->ConvertSqlStringToData(FieldType, ResultStr, iter.value()))
            {
              MC_ERROR("Type %s cannot be extracted from the Sql string. Implementation is missing in "
                       "the storages in MSSessionStorageInterface::ConvertSqlStringToData().",
                       qPrintable(FieldType));
            }
            continue;
          }
          if (StorageType == MSSessionStorageInterface::sd_Binary ||
              StorageType == MSSessionStorageInterface::sd_BinaryStream)
          {
            QString IDStr = OutputName.toUpper()+'_'+FieldName.toUpper();
            QString FileName = ConstructFileName(ElementID, BeatID, PlaybackPath, IDStr, StorageType);

            if (!Storage->LoadBinaryDataFromFile(FileName, FieldType, StorageType, iter.value()))
            {
              MC_ERROR("Unable to load type %s as binary. Implementation is missing in the storages in "
                       "MSSessionStorageInterface::LoadBinaryDataFromFile().", qPrintable(FieldType));
            }
            continue;
          } // End of storage if {}
        } // End of structure processing for {}

      } // End of structure if {}
    } // End of output list for {}
  } // End of elements for {}

  // End of database signal
  if (RegElements.size() > 0 && RegElements[0]->GetBeatID()+1 == PlayedHeartBeats)
  {
    MC_LOG("End of played session database");
    Q_EMIT(EndOfDatabase());
  }
}


void MSSessionStorage::RecordStatesToStorage()
{
  if (!RecordStorage.get())
  {
    MC_WARNING("Storage has not been created for record yet.");
    return;
  }
  for (int i = 0; i < RegElements.size(); ++i)
  {
    if (!RegElements[i]->HasOutputs())
      continue;

    QStringList OutputList = RegElements[i]->GetOutputList();
    QString ClassName = RegElements[i]->GetClass();
    int ElementID = RegElements[i]->GetElementID();

    // Continue if there is no output data
    if (OutputList.isEmpty())
      continue;

    MC::DataContainerSPtr ElementContainer = RecordStorage->GetContainer(ClassName.toStdString());

    if (!ElementContainer.get())
      continue;

    int BeatID = RegElements[i]->GetBeatID();
    std::string ContainerIndexStr = MCToStr((BeatID / RecordStoragePeriod)+1);
    MCDataItemBase* BeatIDsPtr = ElementContainer->GetData("BeatIDs::"+ContainerIndexStr);
    std::string OutputsTableContainerName = ClassName.toStdString()+"::"+ContainerIndexStr;
    MCDataItemBase* OutputsTablePtr = ElementContainer->GetData(OutputsTableContainerName);

    if (!BeatIDsPtr || !OutputsTablePtr)
    {
      CreateNewDataItemsForAClass(*RegElements[i]);
      BeatIDsPtr = ElementContainer->GetData("BeatIDs::"+ContainerIndexStr);
      OutputsTablePtr = ElementContainer->GetData(OutputsTableContainerName);
    }
    MC::StringList* BeatIDs = reinterpret_cast<MC::StringList*>(BeatIDsPtr->DataPtr);
    MC::StringTable* OutputsTable = reinterpret_cast<MC::StringTable*>(OutputsTablePtr->DataPtr);
    MC::StringList NewTableRow;

    for (unsigned int i1 = 0; i1 < (*OutputsTable)[0].size(); ++i1)
      NewTableRow.push_back("");

    BeatIDs->push_back(MCToStr(BeatID));
    NewTableRow[0] = MCToStr(ElementID);
    NewTableRow[1] = RegElements[i]->CurrentOutputList.join(",").toStdString();

    // Process the possible output data to store in the database
    for (int i1 = 0; i1 < OutputList.size(); ++i1)
    {
      if (OutputList[i1].isEmpty())
      {
        MC_WARNING("The %d. parameter is empty in the output list of the element class: %s",
                   i1, qPrintable(ClassName));
        continue;
      }
      QString OutputName = OutputList[i1].section(':', 0, 0);
      QString OutputType = OutputList[i1].section(':', 1, 1);

      // The output is not available in this heart beat
      if (!RegElements[i]->CurrentOutputList.contains(OutputList[i1]))
      {
        continue;
      }
      if (OutputName.isEmpty() || OutputType.isEmpty())
      {
        MC_ERROR("An output has wrong syntax for class %s. The string \'%s\' must follow the 'name:type' format.",
                 qPrintable(ClassName), qPrintable(OutputList[i1]));
      }
      // Get the appropriate storage
      MSSessionStorageInterface* Storage = GetStorage(OutputType);

      if (!Storage)
      {
        MC_ERROR("Unable to find a storage for type %s.", qPrintable(OutputType));
      }

      // Extract the output data
      MSData* OutputData = RegElements[i]->GetOutputData(OutputList[i1]);

      // No output data, let's continue.
      if (!OutputData)
      {
        continue;
      }
      // It is a simple type
      if (OutputData->GetVariableMap().isEmpty())
      {
        MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(OutputType);

        if (StorageType == MSSessionStorageInterface::sd_Unknown)
        {
          MC_ERROR("Type %s cannot be translated to a storage type. Implementation is missing "
                   "in the storages in MSSessionStorageInterface::FindStorageType().",
                   qPrintable(OutputType));
        }
        if (StorageType == MSSessionStorageInterface::sd_Text ||
            StorageType == MSSessionStorageInterface::sd_Integer ||
            StorageType == MSSessionStorageInterface::sd_Real)
        {
          QString SqlValue = Storage->ConvertDataToSqlString(OutputType, OutputData);

          if (SqlValue.isEmpty())
          {
            MC_ERROR("Type %s cannot be converted to an Sql type. Implementation is missing "
                     "in the storages in MSSessionStorageInterface::ConvertDataToSqlString().",
                     qPrintable(OutputType));
          } else {
            int DataIndex = -1;

            for (unsigned int i2 = 2; i2 < (*OutputsTable)[0].size(); ++i2)
            {
              if (QString::fromStdString((*OutputsTable)[0][i2]) == OutputName)
                DataIndex = i2;
            }
            // Let's continue if the column does not exist in the database
            if (DataIndex == -1)
              continue;

            NewTableRow[DataIndex] = SqlValue.toStdString();
          }
          continue;
        }
        if (StorageType == MSSessionStorageInterface::sd_Binary ||
            StorageType == MSSessionStorageInterface::sd_BinaryStream)
        {
          QString FileName = ConstructFileName(ElementID, BeatID, RecordPath, OutputName, StorageType);

          if (!Storage->SaveBinaryDataToFile(FileName, OutputType, StorageType, OutputData))
          {
            MC_ERROR("Unable to save type %s as binary. Implementation is missing "
                     "in the storages in MSSessionStorageInterface::SaveBinaryDataToFile().",
                     qPrintable(OutputType));
          }
          continue;
        }
      } else {
        // Process the structure
        for (auto iter = OutputData->GetVariableMap().constBegin(); iter != OutputData->GetVariableMap().constEnd(); ++iter)
        {
          // Check the variable
          if (iter.key().isEmpty())
          {
            MC_ERROR("A parameter is empty in the field list of the type: %s",
                     qPrintable(OutputType));
          }
          // Check the variable data
          if (!iter.value())
          {
            MC_ERROR("Field %s in the type %s cannot be extracted.",
                     qPrintable(iter.key()), qPrintable(OutputType));
          }
          QString FieldName = iter.key().section(':', 0, 0);
          QString FieldType = iter.key().section(':', 1, 1);

          if (FieldName.isEmpty() || FieldType.isEmpty())
          {
            MC_ERROR("A field has wrong syntax for type %s. "
                     "The string \'%s\' must follow the 'name:type' format.",
                     qPrintable(OutputType), qPrintable(iter.key()));
          }

          // Process the output data
          MSSessionStorageInterface::StorageDataType StorageType = Storage->FindStorageType(FieldType);

          if (StorageType == MSSessionStorageInterface::sd_Unknown)
          {
            MC_ERROR("Field %s in the type %s cannot be translated to an Sql type."
                     "Implementation is missing in the storages in MSSessionStorageInterface::FindStorageType().",
                     qPrintable(FieldType), qPrintable(OutputType));
          }
          if (StorageType == MSSessionStorageInterface::sd_Text ||
              StorageType == MSSessionStorageInterface::sd_Integer ||
              StorageType == MSSessionStorageInterface::sd_Real)
          {
            QString SqlValue = Storage->ConvertDataToSqlString(FieldType, iter.value());

            if (SqlValue.isEmpty())
            {
              MC_ERROR("Type %s cannot be converted to an Sql type. Implementation is missing "
                       "in the storages in MSSessionStorageInterface::ConvertDataToSqlString().",
                       qPrintable(OutputType));
            } else {
              int DataIndex = -1;

              for (unsigned int i2 = 2; i2 < (*OutputsTable)[0].size(); ++i2)
              {
                if (QString::fromStdString((*OutputsTable)[0][i2]) == OutputName+'_'+FieldName)
                  DataIndex = i2;
              }
              // Let's continue if the column does not exist in the database
              if (DataIndex == -1)
                continue;

              NewTableRow[DataIndex] = SqlValue.toStdString();
            }
            continue;
          }
          if (StorageType == MSSessionStorageInterface::sd_Binary ||
              StorageType == MSSessionStorageInterface::sd_BinaryStream)
          {
            QString IDStr = OutputName.toUpper()+'_'+FieldName.toUpper();
            QString FileName = ConstructFileName(ElementID, BeatID, RecordPath, IDStr, StorageType);

            if (!Storage->SaveBinaryDataToFile(FileName, FieldType, StorageType, iter.value()))
            {
              MC_ERROR("Unable to save type %s as binary. Implementation is missing "
                       "in the storages in MSSessionStorageInterface::SaveBinaryDataToFile().",
                       qPrintable(OutputType));
            }
            continue;
          } // End of storage if {}
        } // End of structure processing for {}
      } // End of structure if {}
    } // End of output list for {}

    // Add new row
    OutputsTable->push_back(NewTableRow);
  } // End of elements for {}

  MC::DataContainerSPtr ElementsContainer = RecordStorage->GetContainer("SourceElements");

  if (ElementsContainer.get() && RegElements.size() > 0)
  {
    void* HeartBeatsPtr = ElementsContainer->GetData("HeartBeats")->DataPtr;

    if (HeartBeatsPtr)
      *reinterpret_cast<int*>(HeartBeatsPtr) = RegElements[0]->GetBeatID();
  }

  // Save the record database content
  if (RegElements.size() > 0 && (RegElements[0]->GetBeatID() % 50 == 0))
  {
    QString StorageName = RecordPath+"/Session.bdb";

    if (!RecordStorage->SaveToFile(StorageName.toStdString()))
    {
      MC_ERROR("Can't save session storage (%s)", qPrintable(StorageName));
    }
    // Don't cache the previous container anymore
    if (RegElements[0]->GetBeatID() > 0 && RegElements[0]->GetBeatID() % RecordStoragePeriod == 0)
    {
      RecordStorage->OptimizeCachedContainers();
    }
  }
}


void MSSessionStorage::CloseRecordStorage()
{
  if (!RecordStorage.get())
  {
    MC_WARNING("Storage has not been created for record yet.");
    return;
  }
  // Flush the content first
  QString StorageName = RecordPath+"/Session.bdb";

  if (!RecordStorage->SaveToFile(StorageName.toStdString()))
  {
    MC_ERROR("Can't save session storage (%s)", qPrintable(StorageName));
  }
  RecordStorage.reset();
}


void MSSessionStorage::OpenPlaybackStorage()
{
  if (PlaybackPath.isEmpty())
  {
    MC_WARNING("Session playback location has not been set.");
    return;
  }
  if (PlaybackStorage.get())
  {
    MC_WARNING("A storage has been opened for playback already.");
    return;
  }
  QString StorageName = PlaybackPath+"/Session.bdb";

  if (!QFile(StorageName).exists())
  {
    MC_ERROR("Session storage file does not exist: %s", qPrintable(StorageName));
  }
  PlaybackStorage.reset(new MCDataStorage("PlaybackSession", true));
  if (!PlaybackStorage->LoadFromFile(StorageName.toStdString()))
  {
    MC_ERROR("Can't open session storage (%s)", qPrintable(StorageName));
  }
}


void MSSessionStorage::ClosePlaybackStorage()
{
  if (!PlaybackStorage.get())
  {
    MC_WARNING("Storage has not been opened for playback yet.");
    return;
  }
  PlaybackStorage.reset();
}