#include "handler_nasat_aircraft.h"
#include <utility>
#include "initialization.h"
#include "dds_handler.h"
#include "handler_nasat_aircraft_participant.h"
#include <GuezNasat/gna_db.h>

namespace GuezNasat
{
Database::NasatAircraft toDb(const NasatAircraft &dds)
{
  Database::NasatAircraft ret;
  ret.id = dds.id;
  ret.nasatId = dds.nasatId;
  ret.simulationActive = dds.simulationActive;
  ret.name = QString::fromStdString(dds.name);
  return ret;
}

NasatAircraft fromDb(const Database::NasatAircraft &db)
{
  NasatAircraft ret;
  ret.id = db.id;
  ret.nasatId = db.nasatId;
  ret.simulationActive = db.simulationActive;
  ret.name = db.name.toStdString();
  return ret;
}

HandlerNasatAircraft::HandlerNasatAircraft(Initialization *mainHandler)
  : QObject()
  , Interface::Fts::ModifyNasatAircraftRequestHandler(mainHandler->dds()->fts())
  , m_logger(getLogger("HandlerNasatAircraft"))
  , m_mainHandler(mainHandler)
  , m_dts(mainHandler->dds()->dts())
  , m_fts(mainHandler->dds()->fts())
  , m_db(mainHandler->db())
{}

HandlerNasatAircraft::~HandlerNasatAircraft()
{
  for (const auto &data : std::as_const(m_nasatAircrafts))
    m_dts->removeNasatAircraftByKey(data.id);
}

bool HandlerNasatAircraft::init()
{
  auto cb = [this](const Database::NasatAircraft & data)
  {
    auto dds(fromDb(data));
    dds.simulationActive = false;  
    emit activateNasatAircraftSimulation(data.nasatId, false);
    m_nasatAircrafts[dds.id] = dds;
    m_dts->publish(dds);
  };
  m_db->select(cb);
  return true;
}

int HandlerNasatAircraft::nasatIdFromNasatAircraftId(int nasatAircraftId) const
{
  auto it = m_nasatAircrafts.find(nasatAircraftId);
  if (it == m_nasatAircrafts.end())
    return -1;
  return it.value().nasatId;
}

void HandlerNasatAircraft::simulationStatusChanged(const NasatSimulationStatus &data)
{
  flaFluSimulationChanged(data.aircraftId, data.simulationEnabled);
}

void HandlerNasatAircraft::flaFluSimulationChanged(int nasatId, bool bSimulationActive)
{
  for (NasatAircraft &na : m_nasatAircrafts)
  {
    if (na.nasatId != nasatId)
      continue;
    if (na.simulationActive == bSimulationActive)
      return;
    na.simulationActive = bSimulationActive;
    m_dts->publish(na);
    return;
  }
  WARNING_LOG(m_logger) << "Got a flaFluSimulationChanged information but aircraft with id " << nasatId << " is not available";
}

void HandlerNasatAircraft::onModifyNasatAircraftRequest(const rti::core::SampleIdentity &cookie,
                                                        const NasatAircraft &request)
{
  DEBUG_LOG(m_logger) << "onModifyNasatAircraftRequest: " << request;
  auto ret = request.id > 0 ? modifyNasatAircraftRequest(request) : createNasatAircraftRequest(request);
  if (ret.error())
    WARNING_LOG(m_logger) << ret();
  m_fts->modifyNasatAircraftReply(cookie, ret);
}

Core::FunctionReplyObject HandlerNasatAircraft::createNasatAircraftRequest(const NasatAircraft &request)
{
  
  Database::NasatAircraft naDb(toDb(request));
  naDb.id = 0;

  if (!m_db->insert(naDb))
    return Core::FunctionReplyObject(request.id, tr_lts("dds", "Can not create Aircraft information - error inserting values in database"));

  emit activateNasatAircraftSimulation(naDb.nasatId, naDb.simulationActive);

  
  const auto nasatAircraftData(fromDb(naDb));
  m_dts->publish(nasatAircraftData);
  m_nasatAircrafts[naDb.id] = nasatAircraftData;

  return Core::FunctionReplyObject(request.id);
}

Core::FunctionReplyObject HandlerNasatAircraft::modifyNasatAircraftRequest(const NasatAircraft &request)
{
  auto it = m_nasatAircrafts.find(request.id);
  if (it == m_nasatAircrafts.end())
    return Core::FunctionReplyObject(request.id, tr_lts("dds", "Can not modify Aircraft information - id %1 not found")).arg(request.id);

  if (request.nasatId == 0 && request.name.size() == 0)
  {
    
    if (!m_db->removeNasatAircraft(request.id))
      return Core::FunctionReplyObject(request.id, tr_lts("dds", "Can not remove Aircraft information - error removing values from database"));
    m_nasatAircrafts.erase(it);
    m_mainHandler->nasatAircraftParticipant()->aircraftRemoved(request.id);
    m_dts->removeNasatAircraftByKey(request.id);
    if (it.value().simulationActive)
      emit activateNasatAircraftSimulation(request.nasatId, false);
    return Core::FunctionReplyObject(request.id);
  }

  const int oldNasatId = it.value().nasatId;

  
  Database::NasatAircraft naDb(toDb(request));
  if (!m_db->update(naDb))
    return Core::FunctionReplyObject(request.id, tr_lts("dds", "Can not modify Aircraft information - error updating values in database"));

  const bool simulationChanged = it.value().simulationActive != request.simulationActive;

  
  const auto nasatAircraftData(fromDb(naDb));
  m_dts->publish(nasatAircraftData);
  it.value() = nasatAircraftData;

  if (request.nasatId != oldNasatId)
    emit nasatIdChanged(oldNasatId, naDb.nasatId);
  if (simulationChanged)
    emit activateNasatAircraftSimulation(naDb.nasatId, request.simulationActive);

  return Core::FunctionReplyObject(request.id);
}


}