/**
  * Handler for infrastructure data
  * $Id$
  * $HeadURL$
  * $Author:
  * Created by hjl, SLSE, 2016-07-22
  */

#include "handler_infrastructure_data.h"
#include "settings.h"

#include <QVector>

using namespace VideoOverlayManagement;

HandlerInfrastructureData::HandlerInfrastructureData(const std::shared_ptr<DdsHandler> &ddsHandler, QObject *parent)
  : QObject(parent)
  , m_ddsHandler(ddsHandler)
  , m_exerciseId(0)
  , m_logger(getLogger("HandlerInfrastructureData"))
{
} // end of ctor()
//-----------------------------------------------------------------------------

HandlerInfrastructureData::~HandlerInfrastructureData()
{
} // end of dtor()
//-----------------------------------------------------------------------------

bool HandlerInfrastructureData::init(int exerciseId)
{
  m_exerciseId = exerciseId;
  // DTC InfrastructureManagement
  m_dtc = InfrastructureManagement::Interface::Dtc::create(m_ddsHandler->dds());
  if (m_dtc == nullptr)
  {
    ERROR_LOG(m_logger) << "Could not create DTC InfrastructureManagement";
    return false;
  }

  if (!m_dtc->enableMainStructureElement() ||
      !m_dtc->enableMountingPointAsset() ||
      !m_dtc->enableInstrumentationAsset() ||
      !m_dtc->waitForHistoricalDataMainStructureElement() ||
      !m_dtc->waitForHistoricalDataMountingPointAsset() ||
      !m_dtc->waitForHistoricalDataInstrumentationAsset())
  {
    ERROR_LOG(m_logger) << "init() DTC InfrastructureManagement failed";
    return false;
  }

  // Get 'static' data for all rooms where a camera is available
  QMap<int, QVector<InfrastructureManagement::InstrumentationAsset>> assetsMap;   // (roomId, QVector<Asset>)

  auto predicate =
    [](const InfrastructureManagement::InstrumentationAsset & a)
  {
    return a.mountingPointTypeId() == InfrastructureManagement::MountingPointType::IndoorCamera;
  };
  if (!m_dtc->getAllAssetsPerRoom(predicate, assetsMap))
  {
    WARNING_LOG(m_logger) << "HandlerInfrastructureData::getAllAssetsPerRoom() failed"
                          << " assetsMap.size(): " << assetsMap.size();
  }

  for (auto i = assetsMap.cbegin(); i != assetsMap.cend(); ++i)
  {
    const int roomId = i.key();
    for (const InfrastructureManagement::InstrumentationAsset &asset : i.value())
    {
      auto it = std::find(asset.availableInExercise().begin(),
                          asset.availableInExercise().end(), m_exerciseId);
      if (it == asset.availableInExercise().end())
      {
        DEBUG_LOG(m_logger) << "Asset " << asset.id()
                            << " is not available in current exercise - skipping";
        continue;
      }
      // in interne m_roomId2CameraNameMap eintragen, zur Zeit nur eine Kamera pro Raum möglich
      m_roomId2CameraNameMap.insert(roomId, QString::fromStdString(asset.name()));
      // und fuer subscribe in m_assetId2RoomIdMap eintragen
      m_assetId2RoomIdMap.insert(asset.id(), roomId);
      DEBUG_LOG(m_logger) << " assetId: " << asset.id()
                          << " mountingPointTypeId: " << asset.mountingPointTypeId()
                          << " name: " << asset.name();
    }
  }  // for(auto i = assetMap...

  INFO_LOG(m_logger) << "m_roomId2CameraNameMap.size(): " << m_roomId2CameraNameMap.size();
  for (auto i = m_roomId2CameraNameMap.begin(); i != m_roomId2CameraNameMap.end(); ++i)
  {
    INFO_LOG(m_logger) << "roomId: " << i.key()
                       << " cameraName: " << i.value();
  }

  // Subsribe for AssetChanged (Daten der cameras aus den Assets ermitteln)
  connect(m_dtc.get(), &InfrastructureManagement::Interface::Dtc::instrumentationAssetChanged,
          this, &HandlerInfrastructureData::onAssetChanged);

  // we don't need them now anymore -> unsubscribe (really?)
  m_dtc->enableMainStructureElement(false);
  m_dtc->enableMountingPointAsset(false);

  INFO_LOG(m_logger) << "HandlerInfrastructureData::init() finished. "
                     << " m_roomId2CameraNameMap.size(): " << m_roomId2CameraNameMap.size();
  return true;
} // end of init()
//-----------------------------------------------------------------------------

bool HandlerInfrastructureData::isCameraAvailable(int roomId) const
{
  return m_roomId2CameraNameMap.contains(roomId);
} // end of isCameraAvailable()
//-----------------------------------------------------------------------------

QString HandlerInfrastructureData::getStreamNameFromRoomId(int roomId) const
{
  auto it = m_roomId2CameraNameMap.find(roomId);
  const QString qs(it == m_roomId2CameraNameMap.end() ? QString() : it.value());
  DEBUG_LOG(m_logger) << "streamName for roomId: " << roomId << " '" << qs << "' ";

  return qs;
} // end of getStreamNameFromRoomId()
//-----------------------------------------------------------------------------

void HandlerInfrastructureData::onAssetChanged(const InfrastructureManagement::InstrumentationAsset &data, DataModification modType)
{
  Q_UNUSED(modType);
  if (data.mountingPointTypeId() != InfrastructureManagement::MountingPointType::IndoorCamera)
    return;

  INFO_LOG(m_logger) << "onAssetChanged()"
                     << " assetId: " << data.id()
                     << " name: " << data.name();

  auto it = std::find(data.availableInExercise().begin(),
                      data.availableInExercise().end(), m_exerciseId);
  if (it == data.availableInExercise().end())
  {
    DEBUG_LOG(m_logger) << "Asset " << data.id()
                        << " is not available in current exercise - skipping";
    return;
  }

  // Hier muss aus der AssetId die zugehoerige roomid verwendet werden !!
  m_roomId2CameraNameMap.insert(getRoomIdFromAssetId(data.id()), QString::fromStdString(data.name()));

  for (auto i = m_roomId2CameraNameMap.begin(); i != m_roomId2CameraNameMap.end(); ++i)
  {
    DEBUG_LOG(m_logger) << "m_roomId2CameraNameMap changed... "
                        << " m_roomId2CameraNameMap.size(): " << m_roomId2CameraNameMap.size()
                        << " roomId: " << i.key()
                        << " cameraName: " << *i;
  }
} // end of onAssetChanged()
//-----------------------------------------------------------------------------

int HandlerInfrastructureData::getRoomIdFromAssetId(int assetId) const
{
  return m_assetId2RoomIdMap.value(assetId, -1);
} // end of getRoomIdFromAssetId()
//-----------------------------------------------------------------------------