/**
  * The ObjectMissionPlan class represents a ObjectMissionPlan. It holds the data and offers some conversion methods.
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Steve Kemayou, ESZS, 2025-04-08
  */

#include "object_mission_plan.h"
#include <ngldb/dbtransaction.h>

namespace ParticipantManagement
{
namespace UasHandling
{

ObjectMissionPlan::ObjectMissionPlan(const std::shared_ptr<DdsHandler> &ddsHandler,
                                     const std::shared_ptr<DatabaseInterface> &db,
                                     const ParticipantManagement::MissionPlan & missionPlan,
                                     QObject *parent)
  : QObject(parent)
  , m_ddsHandler(ddsHandler)
  , m_db(db)
  , m_missionplan(missionPlan)
  , m_logger(getLogger("ObjectMissionPlan"))
{
  DEBUG_LOG(m_logger)<<" - ctor ObjectMissionPlan: planId: "<<m_missionplan.id();

}

int32_t ObjectMissionPlan::id() const
{
  return m_missionplan.id();
}

int32_t ObjectMissionPlan::participantId() const
{
  return m_missionplan.participantId();
}

Database::PpmMissionPlan ObjectMissionPlan::toDbMissionPlan(const ModifyMissionPlanRequest &mp)
{
  Database::PpmMissionPlan result;
  result.id = mp.id();
  result.name = QString::fromStdString(mp.name());
  result.missionStart = QDateTime::fromMSecsSinceEpoch(mp.missionStart());
  result.repeat = mp.repeat();
  result.jumpToStart = mp.jumpToStart();
  result.participantId = mp.participantId();

  return result;
}


MissionPlan ObjectMissionPlan::fillMissionPlanData(const ModifyMissionPlanRequest &in)
{
  MissionPlan out;
  out.id(in.id());
  out.name(in.name());
  out.missionStart(in.missionStart());
  out.properties(in.properties());
  out.items(in.items());
  out.participantId(in.participantId());
  out.jumpToStart(in.jumpToStart());
  out.repeat(in.repeat());

  return out;
}

MissionPlan ObjectMissionPlan::getMissionPlanData() const
{
  return m_missionplan;
}

void ObjectMissionPlan::setDbMissionItems(const QMap<int, ParticipantManagement::Database::PpmMissionItem> &dbItems,
                                          const QMap<int, Database::PpmMissionAction> &dbActions)
{
  m_mapMissionItems.clear();
  m_dbMissionActions.clear();

  for (const ParticipantManagement::Database::PpmMissionItem &item : qAsConst(dbItems))
  {
    ParticipantManagement::MissionItem msi;
    msi.actions().reserve(dbActions.size());
    msi.name(item.name.toStdString());
    msi.location(Core::GeoPosition(item.location.x(), item.location.y(), item.location.z()));
    msi.itemNumber(item.elementNumber);
    std::vector<Database::PpmMissionAction> actionsVec;
    for (const auto &action : dbActions)
    {
      if (action.missionItemId == item.id)
      {
        ParticipantManagement::MissionAction msa;
        msa.actionType(action.missionActionTypeId);
        msa.duration(action.duration);
        msa.fulfilled(action.fulfilled.toMSecsSinceEpoch());
        msa.properties(action.properties.toStdString());
        msa.name(action.name.toStdString());
        msa.actionNumber(action.elementNumber);
        msa.planId(item.missionPlanId);
        msi.actions().push_back(msa);
        actionsVec.push_back(action);
      }
    }

    m_mapMissionItems.insert(item.id, msi);
    m_dbMissionActions.push_back(actionsVec);
  }

}

const MissionPlan &ObjectMissionPlan::missionPlan() const
{
  return m_missionplan;
}

Core::FunctionReplyObject ObjectMissionPlan::createMissionPlan(Database::PpmMissionPlan newMissionPlan, const std::vector<MissionItem> &missionItems)
{
  /// 1- insert in DB Mission plan
  /// 2- insert in DB Mission Items
  /// 3- insert in DB Mission Actions

  DBTransaction trans(m_db->database());
  newMissionPlan.aborted = false;
  if (!m_db->insert(newMissionPlan))
  {
    QString error = QStringLiteral("Could not insert mission plan into database");
    ERROR_LOG(m_logger)<< error;
    return Core::FunctionReplyObject(error.toStdString().c_str());
  }

  std::vector<MissionItem> itemVec = missionItems;
  m_mapMissionItems.clear();
  m_mapMissionItems.reserve(itemVec.size());
  std::vector<std::vector<Database::PpmMissionAction>>itemsVec;
  m_dbMissionActions.clear();

  for ( auto &item : itemVec)
  {
    Database::PpmMissionItem dbItem;
    dbItem.missionPlanId = newMissionPlan.id;
    dbItem.name = QString::fromStdString(item.name());
    dbItem.elementNumber = item.itemNumber();
    dbItem.location = LtsUtils::QPoint3D(item.location().lon(),item.location().lat(), item.location().z());

    if (!m_db->insert(dbItem))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Item' to database"));

    std::vector<Database::PpmMissionAction> actionsVec;
    actionsVec.reserve(item.actions().size());
    for (auto &action : item.actions())
    {
      action.planId(newMissionPlan.id);
      Database::PpmMissionAction dbAction;
      dbAction.missionActionTypeId = action.actionType();
      dbAction.missionItemId = dbItem.id;
      dbAction.duration = action.duration();
      dbAction.name = QString::fromStdString(action.name());
      dbAction.properties = QString::fromStdString(action.properties());
      dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(action.fulfilled());
      dbAction.elementNumber = action.actionNumber();
      if (!m_db->insert(dbAction))
        return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Action' to database"));

      actionsVec.push_back(dbAction);
    }//loop mission actions
    m_mapMissionItems.insert(dbItem.id, item);
    m_dbMissionActions.push_back(actionsVec); // [elNumber][actionNumber]
  }//loop mission items

  m_missionplan.id(newMissionPlan.id);
  m_missionplan.name(newMissionPlan.name.toStdString());
  m_missionplan.missionStart(newMissionPlan.missionStart.toMSecsSinceEpoch());
  m_missionplan.participantId(newMissionPlan.participantId);
  m_missionplan.jumpToStart(newMissionPlan.jumpToStart);
  m_missionplan.repeat(newMissionPlan.repeat);
  m_missionplan.items(itemVec);
  m_missionplan.fulfilled(0);
  m_missionplan.itemsFulfilled(0);

  for (auto &item : m_missionplan.items())
  {
    for (auto &action : item.actions())
      DEBUG_LOG(m_logger)<<"[CREATE] itemIdx: "<<item.itemNumber()
                         <<" act.Num: "<<action.actionNumber()<<" act.ItemNum: "<<action.itemNumber()<<" itemFul:"<<action.fulfilled();
  }
  trans.commit();
  DEBUG_LOG(m_logger)<< ">> [NEW] mission plan with id( "<<newMissionPlan.id<<" ) inserted !!";
  return Core::FunctionReplyObject(newMissionPlan.id);
}

Core::FunctionReplyObject ObjectMissionPlan::updateMissionPlan(Database::PpmMissionPlan newMissionPlan, const std::vector<MissionItem> &missionItems)
{
  if (missionItems.size() == 0)
    return Core::FunctionReplyObject(newMissionPlan.id, tr_lts("dds", "Could not modify MissionPlan without segments."));

  /// 1- update missipn plan table
  /// 2- remove items and their actions
  /// 3- insert new items and their actions
  DBTransaction trans(m_db->database());
  const auto tmpDbMissionItems = m_mapMissionItems;  
  newMissionPlan.aborted = false;

  /// update mission plan table
  if (!m_db->update(newMissionPlan))
  {
    QString error = QStringLiteral("Could not update mission plan! ");
    ERROR_LOG(m_logger)<< error;
    return Core::FunctionReplyObject(error.toStdString().c_str());
  }

  /// remove all items and their actions  from the database
  for (const auto &itemId : tmpDbMissionItems.keys())
  {
    if (!m_db->removePpmMissionItem(itemId))
    {
      QString error = QStringLiteral("Could not remove mission plan from database");
      ERROR_LOG(m_logger)<< error;
      return Core::FunctionReplyObject(0, tr_lts("dds", "Could not update mission plan into!"));
    }
  }

  /// insert new items with their actions in the data base;
  m_mapMissionItems.clear();
  m_mapMissionItems.reserve(missionItems.size());
  m_dbMissionActions.clear();

  std::vector<MissionItem> itemVec = missionItems;
  for (auto &item : itemVec)
  {
    Database::PpmMissionItem dbItem;
    dbItem.missionPlanId = newMissionPlan.id;
    dbItem.name = QString::fromStdString(item.name());
    dbItem.elementNumber = item.itemNumber();
    dbItem.location = LtsUtils::QPoint3D(item.location().lon(),item.location().lat(), item.location().z());
    if (!m_db->insert(dbItem))
      return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Item' to database"));

    std::vector<Database::PpmMissionAction> actionsVec;
    actionsVec.reserve(item.actions().size());
    for (auto &action : item.actions())
    {
      action.planId(newMissionPlan.id);
      Database::PpmMissionAction dbAction;
      dbAction.missionActionTypeId = action.actionType();
      dbAction.missionItemId = dbItem.id;
      dbAction.duration = action.duration();
      dbAction.name = QString::fromStdString(action.name());
      dbAction.properties = QString::fromStdString(action.properties());
      dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(action.fulfilled());
      dbAction.elementNumber = action.actionNumber();
      if (!m_db->insert(dbAction))
        return Core::FunctionReplyObject(0, tr_lts("dds", "Error adding 'Mission Action' to database"));

      actionsVec.push_back(dbAction);
    }//loop mission actions
    m_mapMissionItems.insert(dbItem.id, item);
    m_dbMissionActions.push_back(actionsVec); // [elNumber][actionNumber]
  }//loop mission items

  trans.commit();
  m_missionplan.id(newMissionPlan.id);
  m_missionplan.name(newMissionPlan.name.toStdString());
  m_missionplan.missionStart(newMissionPlan.missionStart.toMSecsSinceEpoch());
  m_missionplan.participantId(newMissionPlan.participantId);
  m_missionplan.jumpToStart(newMissionPlan.jumpToStart);
  m_missionplan.repeat(newMissionPlan.repeat);
  m_missionplan.items(itemVec);
  m_missionplan.itemsFulfilled(0); // on update items and action entries will be cleared
  m_missionplan.fulfilled(0);

  DEBUG_LOG(m_logger)<< ">> [UPDATE] mission plan with id( "<<m_missionplan.id()<<" ) Updated !!";

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

Core::FunctionReplyObject ObjectMissionPlan::removeMissionPlan(int id)
{
  DBTransaction trans(m_db->database());
  if (!m_db->removePpmMissionPlan(id))
  {
    QString error = QStringLiteral("Could not remove mission plan ! ");
    ERROR_LOG(m_logger)<< error;
    return Core::FunctionReplyObject(error.toStdString().c_str());
  }
  trans.commit();
  m_dbMissionActions.clear();
  m_mapMissionItems.clear();
  DEBUG_LOG(m_logger)<< ">> [REMOVE] mission Action with id( "<<id<<" ) deleted !!";
  return Core::FunctionReplyObject();
}

Core::FunctionReplyObject ObjectMissionPlan::setMissionActionFulfilled(SetMissionActionFulfilledRequest req, qint64 currentTimeMSec)
{
  //0- if actionNumb and itemNumb are -1 -> missionplan is aborted. only update missionPlan table with status aborted = true
  //1- get db mission action from actionNumber
  //2- set mission action as fulfilled
  //3- set mission action save in db
  //4- update cache data

  if (!m_db)
  {
    ERROR_LOG(m_logger) << "no init yet....";
    return Core::FunctionReplyObject("");
  }

  if (req.missionId() != m_missionplan.id())
  {
    QString error = QStringLiteral("Wrong missionPlan Object caught Request: %1 / currPlanId: %2").arg(req.missionId()).arg(m_missionplan.id());
    ERROR_LOG(m_logger)<< error;
    return Core::FunctionReplyObject(error.toStdString().c_str());
  }

  // Abort in case itemNumb=-1 && actionNumb=-1
  if (req.actionNumber() < 0 && req.itemNumber() < 0)
  {
    m_missionplan.aborted(true);
    return setMissionPlanAborted(true);
  }

  auto &dbActions  = m_dbMissionActions[req.itemNumber()]; //[elemNum][actionNum]

  if (dbActions.empty()
      || req.actionNumber() >= static_cast<int>(dbActions.size())
      || req.actionNumber() < 0
      || req.itemNumber()   < 0) // actionNumber start by 0
  {
    QString error = QStringLiteral("Could not set mission action with id: %1 ! ").arg(req.actionNumber());
    ERROR_LOG(m_logger)<< error;
    return Core::FunctionReplyObject(error.toStdString().c_str());
  }

  Database::PpmMissionAction &dbAction = dbActions[req.actionNumber()];
  dbAction.fulfilled = QDateTime::fromMSecsSinceEpoch(currentTimeMSec);

  if (!m_db->update(dbAction))
  {
    QString error = QStringLiteral("Could not update mission action! ");
    ERROR_LOG(m_logger)<< error;
    return Core::FunctionReplyObject(error.toStdString().c_str());
  }

  //update item in case actions fulfilled
  //1- actions count
  //2- number of actions fulfilled
  //3- check if action count == item.actions.size()
  //4- if yes update missioPlan & missionItem fulfilled

  MissionItem &msi    = m_mapMissionItems[dbAction.missionItemId];
  msi.fulfilled(dbAction.fulfilled.toMSecsSinceEpoch());
  msi.actionsFulfilled(msi.actionsFulfilled() + 1);
  MissionAction &msa  = m_mapMissionItems[dbAction.missionItemId].actions()[dbAction.elementNumber];
  msa.fulfilled(dbAction.fulfilled.toMSecsSinceEpoch());
  m_missionplan.items()[req.itemNumber()] = m_mapMissionItems[dbAction.missionItemId]; // item in MissionPlan updated through elementNumber

  /// update fulfilled time for items and mission plan
  /// update fulfilled items count

  int numbItemFulfilled   = 0;
  for(const auto &item : m_mapMissionItems)
  {
    if (item.actionsFulfilled() == static_cast<int>(item.actions().size()))
      numbItemFulfilled++;
  }
  m_missionplan.itemsFulfilled(numbItemFulfilled);
  m_missionplan.fulfilled(dbAction.fulfilled.toMSecsSinceEpoch());


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

Core::FunctionReplyObject ObjectMissionPlan::setMissionPlanAborted(bool state)
{
  DEBUG_LOG(m_logger)<<" -- [setMissionPlanAborted] abort mission plan: "<<m_missionplan.id();
  Database::PpmMissionPlan dbMissionPlan;
  // m_db->selectPpmMissionPlan(m_missionplan.id(),dbMissionPlan);
  dbMissionPlan.missionStart = QDateTime::fromMSecsSinceEpoch(m_missionplan.missionStart());
  dbMissionPlan.jumpToStart = m_missionplan.jumpToStart();
  dbMissionPlan.id = m_missionplan.id();
  dbMissionPlan.name = QString::fromStdString(m_missionplan.name());
  dbMissionPlan.participantId = m_missionplan.participantId();
  dbMissionPlan.repeat = m_missionplan.repeat();
  dbMissionPlan.aborted = state;


  /// update mission plan table
  if (!m_db->update(dbMissionPlan))
  {
    QString error = QStringLiteral("Could not update mission plan! ");
    ERROR_LOG(m_logger)<< error;
    return Core::FunctionReplyObject(error.toStdString().c_str());
  }

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

} // namespace UasHandling
} // namespace ParticipantManagement