#include "handler_charge_effect.h"

#include "handler_charge_administration.h"
#include "handler_effect_cluster.h"
#include "handler_trajectory.h"
#include "main_handler.h"
#include "object_charge_effect.h"
#include "object_trajectory.h"
#include "settings.h"

namespace AreaEffectSimulation
{

HandlerChargeEffect::HandlerChargeEffect(AreaEffectSimulation::MainHandler *mainhandler, QObject *parent)
    : QObject(parent)
    , Interface::Fts::ChargeEffectModifyRequestHandler(mainhandler->dds()->fts())
    , m_mainHandler(mainhandler)
    , m_trajectoryHandler(new HandlerTrajectory(m_mainHandler))
    , m_logger(getLogger(QStringLiteral("HandlerChargeEffect")))
{
}

HandlerChargeEffect::~HandlerChargeEffect()
{
  if (m_trajectoryHandler)
    delete m_trajectoryHandler;
  m_trajectoryHandler = nullptr;
}

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

bool HandlerChargeEffect::init()
{
  qDeleteAll(m_chargeEffects);
  m_chargeEffects.clear();

  if (!m_mainHandler)
  {
    ERROR_LOG(m_logger) << QStringLiteral("Not possible to init HandlerChargeEffect --> No MainHandler present.");

    return false;
  }

  QVector<Database::AesChargeEffect> chargeEffectDbData;

  if (!m_mainHandler->db()->select(chargeEffectDbData))
  {
    ERROR_LOG(m_logger) << QStringLiteral("Not possible to init HandlerChargeEffect --> Not possible to get database data.");

    return false;
  }

  ObjectChargeEffect::s_afterglowMsecs = Settings::getChargeEffectAfterGlow();

  for (const Database::AesChargeEffect &currentChargeEffectData : qAsConst(chargeEffectDbData))
  {
    ObjectChargeEffect *newChargeEffect = new ObjectChargeEffect(currentChargeEffectData, m_mainHandler, this);

    if (newChargeEffect->isFinished())
    {
      delete newChargeEffect;

      newChargeEffect = nullptr;

      continue;
    }

    newChargeEffect->init();
    // init
    m_chargeEffects.insert(newChargeEffect->id(), newChargeEffect);
    connect(newChargeEffect, &ObjectChargeEffect::finished, this, &HandlerChargeEffect::onChargeEffectFinished);
    connect(newChargeEffect, &ObjectChargeEffect::chargeEffectStateChanged, this, &HandlerChargeEffect::onChargeEffectStateChanged);
  }

  return true;
}

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

void HandlerChargeEffect::onChargeEffectModifyRequest(const rti::core::SampleIdentity &cookie, const ChargeEffectModifyRequest &request)
{
  if (!m_mainHandler)
  {
    ERROR_LOG(m_logger) << QStringLiteral("Not possible to process ChargeEffectModifyRequest --> No MainHandler present.");

    return;
  }

  if (request.id() == 0) // create
  {
    m_mainHandler->dds()->fts()->chargeEffectModifyReply(cookie, createChargeEffect(request));

    return;
  }

  if (request.id() < 0) // create with id
  {
    ChargeEffectModifyRequest requestWithPositiveId = request;

    requestWithPositiveId.id(qAbs(request.id()));

    m_mainHandler->dds()->fts()->chargeEffectModifyReply(cookie, createChargeEffect(requestWithPositiveId));

    return;
  }

  // request id is >0 here --> update
  m_mainHandler->dds()->fts()->chargeEffectModifyReply(cookie, updateChargeEffect(request));
}

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

void HandlerChargeEffect::onChargeEffectFinished(qint32 chargeEffectId)
{
  ObjectChargeEffect *chargeEffect = m_chargeEffects.value(chargeEffectId, nullptr);

  if (chargeEffect == nullptr)
  {
    ERROR_LOG(m_logger) << "onChargeEffectExpired: got invalid chargeEffectId " << chargeEffectId;
    return;
  }

  if (!chargeEffect->remove())
  {
    ERROR_LOG(m_logger) << "onChargeEffectExpired: failed to remove ChargeEffect with id " << chargeEffectId;
    return;
  }

  m_chargeEffects.remove(chargeEffectId);
  delete chargeEffect;
  chargeEffect = nullptr;

  // remove trajectory
  const int trajId = m_trajObjIds.value(chargeEffectId, -1);
  if (!m_trajectoryHandler->remove(trajId))
  {
    ERROR_LOG(m_logger) << "onChargeEffectExpired: failed to remove trajectory from chargeEffect id " << chargeEffectId;
    return;
  }
  m_trajObjIds.remove(chargeEffectId);
}

void HandlerChargeEffect::onChargeEffectStateChanged(const int id, AesEffectState newState)
{
  DEBUG_LOG(m_logger) << " [CHARGE EFFECT STATE] state changed !! id: " << id << " state: " << newState;

  if (id <= 0)
    return;
  if (newState == AesEffectState::EsActivated)
    emit chargeEffectActive(id);
  if (newState == AesEffectState::EsExpired)
    emit chargeEffectExpired(id);
}

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

Core::FunctionReplyObject HandlerChargeEffect::createChargeEffect(const ChargeEffectModifyRequest &request)
{
  ObjectChargeEffect *newChargeEffect = new ObjectChargeEffect(m_mainHandler, this);
  Core::FunctionReplyObject reply = newChargeEffect->create(request);

  if (!reply.error())
  {
    m_chargeEffects.insert(newChargeEffect->id(), newChargeEffect);

    // Create ChargeAdministration Entry for reports
    DEBUG_LOG(m_logger) << "newChargeEffect id: " << newChargeEffect->id();
    DEBUG_LOG(m_logger) << "request.originatorTypeId: " << request.originatorTypeId();
    if (request.originatorTypeId() == ProjectDataManagement::StateChangeOriginator::AreaEffectSimulation)
    {
      int amount = 1;
      int partyId = m_mainHandler->effectClusterHandler()->getPartyId(request.originatorId());
      m_mainHandler->chargeAdministrationHandler()->consumeCharge(request.chargeTypeId(), partyId, amount);
    }

    // create
    connect(newChargeEffect, &ObjectChargeEffect::finished, this, &HandlerChargeEffect::onChargeEffectFinished);
    connect(newChargeEffect, &ObjectChargeEffect::chargeEffectStateChanged, this, &HandlerChargeEffect::onChargeEffectStateChanged);

    newChargeEffect->init();

    // create trajectory
    if (request.trajectoryTimeAware().is_set())
    {
      int trajId = m_trajectoryHandler->create(trajectoryData(newChargeEffect->id(), request.trajectoryTimeAware().get()));
      if (trajId < 0)
        ERROR_LOG(m_logger) << " Couldn't create trajectory for chargeEffect id: " << newChargeEffect->id();
      else
        m_trajObjIds.insert(newChargeEffect->id(), trajId);
    }
  }
  else
  {
    delete newChargeEffect;
    newChargeEffect = nullptr;
  }

  return reply;
}

TrajectoryData HandlerChargeEffect::trajectoryData(int chargeEffectId, // act as paretnId
                                                   const TrajectoryTimeAware &trajectoryTimeAware,
                                                   int trajObjId)
{
  TrajectoryData td;
  td.id = trajObjId;
  td.index = trajectoryTimeAware.index();
  td.startTime = trajectoryTimeAware.trajectoryStartTime();
  td.geometry = trajectoryTimeAware.geometry();
  // [E01562-259] use originatorId, originatorTypeId (instead of aesItemId, aesTypeId)
  // td.aesItemId = trajectoryTimeAware.aesItemId(); // charge effect's parent
  // td.aesTypeId = trajectoryTimeAware.aesTypeId();
  td.originatorId = chargeEffectId;
  td.originatorTypeId = ProjectDataManagement::StateChangeOriginator::ChargeEffect;

  return td;
}

const ObjectChargeEffect *HandlerChargeEffect::getChargeEffectById(int chargeEffectId)
{
  if (m_chargeEffects.contains(chargeEffectId))
    return m_chargeEffects.value(chargeEffectId);
  return {};
}

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

Core::FunctionReplyObject HandlerChargeEffect::updateChargeEffect(const ChargeEffectModifyRequest &request)
{
  Core::FunctionReplyObject reply(request.id());
  if (!m_mainHandler)
  {
    reply.setStr("Not possible to update ChargeEffect --> No MainHandler present.");

    ERROR_LOG(m_logger) << reply.str();

    return reply;
  }

  if (!m_chargeEffects.contains(request.id()))
  {

    reply.setStr("Not possible to update ChargeEffect --> Got invalid id.");

    ERROR_LOG(m_logger) << reply.str();

    return reply;
  }

  ObjectChargeEffect *chargeEffetObj = m_chargeEffects[request.id()];
  reply = chargeEffetObj->update(request);

  // update trajectory
  if (!reply.error() && request.trajectoryTimeAware().is_set()
      && m_trajectoryHandler->update(trajectoryData(chargeEffetObj->id(), request.trajectoryTimeAware().get(), m_trajObjIds.value(chargeEffetObj->id(), -1))))
  {
    // update failed should the trajectory be created again?
    reply.setStr("Not possible to update ChargeEffect --> Got invalid trajectory id.");
    ERROR_LOG(m_logger) << " Couldn't update trajectory: unknown chargeEffect id: " << chargeEffetObj->id();
  }

  return reply;
}

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

} // namespace AreaEffectSimulation