attributes.hpp

#pragma once
 
#include <algorithm>
#include <stdexcept>
#include <type_traits>
 
#include "vipra/geometry/f3d.hpp"
 
#include "vipra/logging/logging.hpp"
#include "vipra/vipra_behaviors/behavior/exceptions.hpp"
#include "vipra/vipra_behaviors/definitions/behavior_context.hpp"
#include "vipra/vipra_behaviors/definitions/dsl_types.hpp"
#include "vipra/vipra_behaviors/definitions/sim_pack.hpp"
#include "vipra/vipra_behaviors/events/event.hpp"
#include "vipra/vipra_behaviors/events/event_status.hpp"
#include "vipra/vipra_behaviors/targets/target.hpp"
#include "vipra/vipra_behaviors/values/numeric_value.hpp"
 
namespace VIPRA::Behaviors {
enum class Attribute {
  INVALID = 0,
  POSITION,
  DIMENSIONS,
  VELOCITY,
  END_GOAL,
  CURR_GOAL,
  STATE,
  LOCATION,
  STATUS,
};

enum class Type {
  INVALID = 0,
  NUMBER,
  COORD,
  STATE,
  STATUS,
  LOCATION,
  TOWARDS_LOC,
  TOWARDS_ATTR,
  OBJECTIVE,
  POSITION
};

struct CAttributeValue {
  Type        type;
  void const* value;
 
  CAttributeValue(Type aType, void const* aVal) : type(aType), value(aVal) {}
 
  inline void type_check(Type check) const
  {
    if ( type != check ) DSLException::error("Invalid Type");
  }

  template <typename value_t>
  [[nodiscard]] inline auto as() const -> value_t const&
  {
    return *static_cast<value_t const*>(value);
  }

  template <typename value_t>
  [[nodiscard]] inline auto as_ptr() const -> value_t const*
  {
    return static_cast<value_t const*>(value);
  }
};

struct AttributeValue {
  Type  type;
  void* value;

  inline void type_check(Type check) const
  {
    if ( type != check ) DSLException::error("Invalid Type");
  }

  template <typename value_t>
  [[nodiscard]] inline auto as() -> value_t&
  {
    return *static_cast<value_t*>(value);
  }

  template <typename value_t>
  [[nodiscard]] inline auto as_ptr() const -> value_t*
  {
    return static_cast<value_t*>(value);
  }
};

class AttributeHandling {
 public:
  [[nodiscard]] inline static auto get_value(Target target, Attribute attr,
                                             auto pack) -> CAttributeValue
  {
    switch ( target.type ) {
      case TargetType::PEDESTRIAN:
        return get_ped_value(target, attr, pack);
      case TargetType::EVENT:
        return get_event_value(target, attr, pack);
      case TargetType::LOCATION:
        return get_location_value(target, attr, pack);
      case TargetType::INVALID:
        return {Type::INVALID, nullptr};
    }
 
    return {Type::INVALID, nullptr};
  }

  inline static void set_value(Target target, Attribute attr, Simpack pack,
                               VIPRA::State& state, CAttributeValue value)
  {
    switch ( target.type ) {
      case TargetType::PEDESTRIAN:
        set_ped_value(target, attr, pack, state, value);
        return;
      case TargetType::EVENT:
        set_event_value(target, attr, pack, value);
        return;
      case TargetType::LOCATION:
        set_location_value(target, attr, pack, value);
        return;
      case TargetType::INVALID:
        return;
    }
  }

  inline static void scale_value(Target target, Attribute attr, Simpack pack,
                                 VIPRA::State& state, CAttributeValue value)
  {
    switch ( target.type ) {
      case TargetType::PEDESTRIAN:
        scale_ped_value(target, attr, pack, state, value);
        return;
      case TargetType::EVENT:
        DSLException::error("Cannot Scale Event Value");
        return;
      case TargetType::LOCATION:
        DSLException::error("Cannot Scale Location Value");
        return;
      case TargetType::INVALID:
        return;
    }
  }

  [[nodiscard]] inline static auto is_coord_loc_compare(CAttributeValue value1,
                                                        CAttributeValue value2) -> bool
  {
    return (value1.type == Type::COORD && value2.type == Type::LOCATION) ||
           (value1.type == Type::LOCATION && value2.type == Type::COORD);
  }

  [[nodiscard]] inline static auto coord_loc_compare(CAttributeValue value1,
                                                     CAttributeValue value2,
                                                     auto            pack) -> bool
  {
    if ( value1.type == Type::COORD && value2.type == Type::LOCATION ) {
      return pack.context.locations[value2.as<VIPRA::idx>()].is_point_inside(
          value1.as<VIPRA::f3d>());
    }
 
    if ( value2.type == Type::COORD && value1.type == Type::LOCATION ) {
      return pack.context.locations[value1.as<VIPRA::idx>()].is_point_inside(
          value2.as<VIPRA::f3d>());
    }
 
    return false;
  }

  [[nodiscard]] inline static auto is_equal(CAttributeValue value1,
                                            CAttributeValue value2, auto pack) -> bool
  {
    if ( is_coord_loc_compare(value1, value2) ) {
      return coord_loc_compare(value1, value2, pack);
    }
 
    if ( value1.type != value2.type ) return false;
 
    switch ( value1.type ) {
      case Type::INVALID:
        throw std::runtime_error("Invalid Attribute Type");
        return false;
      case Type::NUMBER:
        return value1.as<VIPRA::f_pnt>() == value2.as<VIPRA::f_pnt>();
      case Type::COORD:
        return value1.as<VIPRA::f3d>().distance_to_sqrd(value2.as<VIPRA::f3d>()) <= 0.04;
      case Type::STATE:
        return value1.as<stateUID>() == value2.as<stateUID>();
      case Type::STATUS:
        return value1.as<EventStatus>() == value2.as<EventStatus>();
      case Type::LOCATION:
        return value1.as<VIPRA::idx>() == value2.as<VIPRA::idx>();
        break;
      default:
        break;
    }
 
    return false;
  }

  [[nodiscard]] inline static auto is_not_equal(CAttributeValue value1,
                                                CAttributeValue value2, auto pack) -> bool
  {
    return ! is_equal(value1, value2, pack);
  }

  template <typename value_t>
  [[nodiscard]] inline static auto store_value(Type      type,
                                               value_t&& value) -> CAttributeValue
  {
    auto& valueStore = get_value_store();
    valueStore.emplace_back(
        type, new std::remove_cvref_t<value_t>(std::forward<value_t>(value)));
    return valueStore.back();
  }
 
  inline static void cleanup()
  {
    for ( auto data : get_value_store() ) {
      // NOLINTBEGIN(cppcoreguidelines-owning-memory)
      switch ( data.type ) {
        case Type::INVALID:
          // throw std::runtime_error("Invalid Type");
          break;
        case Type::NUMBER:
          delete data.as_ptr<VIPRA::f_pnt>();
          break;
        case Type::COORD:
          delete data.as_ptr<VIPRA::f3d>();
          break;
        case Type::STATE:
          delete data.as_ptr<stateUID>();
          break;
        case Type::STATUS:
          delete data.as_ptr<EventStatus>();
          break;
        case Type::LOCATION:
          [[fallthrough]];
        case Type::TOWARDS_LOC:
          delete data.as_ptr<VIPRA::idx>();
          break;
        case Type::TOWARDS_ATTR:
          delete data.as_ptr<Attribute>();
          break;
        default:
          // throw std::runtime_error("Cleanup Error: Unknown Type");
          break;
      }
      // NOLINTEND(cppcoreguidelines-owning-memory)
    }
 
    get_value_store().clear();
  }
 
  struct DeferedCleanup {
    DeferedCleanup(DeferedCleanup const&) = default;
    DeferedCleanup(DeferedCleanup&&) = default;
    auto operator=(DeferedCleanup const&) -> DeferedCleanup& = default;
    auto operator=(DeferedCleanup&&) -> DeferedCleanup& = default;
    DeferedCleanup() = default;
    ~DeferedCleanup() { AttributeHandling::cleanup(); }
  };
 
 private:
  static const DeferedCleanup CLEANUP;
 
  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) Bug in clang-tidy (https://bugs.llvm.org/show_bug.cgi?id=48040)
  static inline auto get_value_store() -> std::vector<CAttributeValue>&
  {
    static std::vector<CAttributeValue> valueStore;
    return valueStore;
  }

  [[nodiscard]] inline static auto get_ped_value(Target target, Attribute attr,
                                                 auto pack) -> CAttributeValue
  {
    switch ( attr ) {
      case Attribute::POSITION:
        return {Type::COORD, &pack.pedset.ped_coords(target.targetIdx)};
      case Attribute::VELOCITY:
        return {Type::COORD, &pack.state.velocities[target.targetIdx]};
      case Attribute::END_GOAL:
        return {Type::COORD, &pack.goals.end_goal(target.targetIdx)};
      case Attribute::CURR_GOAL:
        return {Type::COORD, &pack.goals.current_goal(target.targetIdx)};
      case Attribute::STATE:
        return {Type::STATE, &pack.context.pedStates[target.targetIdx]};
      default:
        DSLException::error("Invalid Pedestrian Attribute");
    }
  }

  [[nodiscard]] inline static auto get_event_value(Target target, Attribute attr,
                                                   auto pack) -> CAttributeValue
  {
    switch ( attr ) {
      case Attribute::LOCATION:
        // TODO (rolland) : get this added in when event locations are done
        DSLException::error("Event Locations Not Implmented");
      case Attribute::STATUS:
        return {Type::STATUS, &pack.context.events[target.targetIdx].get_status()};
      default:
        DSLException::error("Invalid Event Attribute");
    }
  }

  [[nodiscard]] inline static auto get_location_value(Target target, Attribute attr,
                                                      auto pack) -> CAttributeValue
  {
    switch ( attr ) {
      case Attribute::POSITION:
        return {Type::COORD, &pack.context.locations[target.targetIdx].center()};
      case Attribute::DIMENSIONS:
      default:
        DSLException::error("Invalid Location Attribute");
    }
  }

  inline static void set_ped_value(Target target, Attribute attr, Simpack pack,
                                   VIPRA::State& state, CAttributeValue value)
  {
    switch ( attr ) {
      case Attribute::POSITION:
        set_position(target, state, value);
        return;
      case Attribute::VELOCITY:
        set_velocity(target, pack, state, value);
        return;
      case Attribute::END_GOAL:
        set_goal(target, pack, value);
        return;
      case Attribute::CURR_GOAL:
        DSLException::error("Unable to set Pedestrian Current Goal");
        return;
      case Attribute::STATE:
        set_state(target, pack, value);
        return;
      default:
        DSLException::error("Invalid Pedestrian Attribute");
    }
  }

  inline static void set_location_value(Target /*target*/, Attribute attr,
                                        Simpack /*pack*/, CAttributeValue /*value*/)
  {
    switch ( attr ) {
      case Attribute::POSITION:
      case Attribute::DIMENSIONS:
      default:
        DSLException::error("Invalid Location Attribute");
    }
  }

  inline static void scale_ped_value(Target target, Attribute attr, Simpack pack,
                                     VIPRA::State& state, CAttributeValue value)
  {
    switch ( attr ) {
      case Attribute::POSITION:
        DSLException::error("Cannot Scale Pedestrian Position");
        return;
      case Attribute::VELOCITY:
        scale_velocity(target, pack, state, value);
        return;
      case Attribute::CURR_GOAL:
      case Attribute::END_GOAL:
        DSLException::error("Cannot Scale Pedestrian Position");
        return;
      case Attribute::STATE:
        set_state(target, pack, value);
        return;
      case Attribute::INVALID:
      case Attribute::LOCATION:
      case Attribute::STATUS:
        DSLException::error("Invalid Pedestrian Attribute");
        break;
      case Attribute::DIMENSIONS:
        DSLException::error("Pedestrians Do Not Have Dimensions");
        break;
    }
  }

  inline static void set_event_value(Target target, Attribute attr, Simpack pack,
                                     CAttributeValue value)
  {
    switch ( attr ) {
      case Attribute::LOCATION:
        // TODO (rolland) : get this added in when event locations are done
        DSLException::error("Event Locations Not Implmented");
      case Attribute::STATUS:
        pack.context.events[target.targetIdx].set_status(
            value.as<Behaviors::EventStatus>());
        return;
      default:
        DSLException::error("Invalid Event Attribute");
    }
  }
 
  // ------------------------------------------- SETTERS ------------------------------------------------------------------------

  static inline void set_position(Target target, VIPRA::State& state,
                                  CAttributeValue value)
  {
    value.type_check(Type::COORD);
    state.positions[target.targetIdx] = value.as<VIPRA::f3d>();
  }

  static inline void set_state(Target target, Simpack pack, CAttributeValue value)
  {
    value.type_check(Type::STATE);
    pack.context.pedStates[target.targetIdx] = value.as<stateUID>();
  }

  static inline void set_goal(Target target, Simpack pack, CAttributeValue value)
  {
    auto&       goals = pack.goals;
    auto&       context = pack.context;
    auto const& pedset = pack.pedset;
 
    if ( value.type == Type::COORD ) {
      goals.change_end_goal(target.targetIdx, pedset.ped_coords(target.targetIdx),
                            value.as<VIPRA::f3d>(), context.engine);
    }
    else if ( value.type == Type::LOCATION ) {
      // TODO(rolland): this doesn't take into account two pedestrains going to the same location
      goals.change_end_goal(
          target.targetIdx, pedset.ped_coords(target.targetIdx),
          context.locations[value.as<VIPRA::idx>()].random_point(context.engine),
          context.engine);
    }
  }

  static inline void set_velocity(Target target, Simpack pack, VIPRA::State& state,
                                  CAttributeValue value)
  {
    value.type_check(Type::COORD);
 
    state.velocities[target.targetIdx] = value.as<VIPRA::f3d>();
 
    VIPRA::f3d originalPos = pack.pedset.ped_coords(target.targetIdx);
    state.positions[target.targetIdx] =
        originalPos + (state.velocities[target.targetIdx] * pack.dT);
  }
 
  // ------------------------------------------- END SETTERS ------------------------------------------------------------------------
 
  // --------------------------------------------- SCALING ------------------------------------------------------------------------

  static inline void scale_velocity(Target target, Simpack pack, VIPRA::State& state,
                                    CAttributeValue value)
  {
    value.type_check(Type::NUMBER);
 
    NumericValue const& scale = *static_cast<NumericValue const*>(value.value);
    // TODO (rolland): get magnitude, scale that then apply to the unit vector
    VIPRA::f_pnt scaleVal = scale.value(target.targetIdx);
    auto         tempvel = state.velocities[target.targetIdx];
    tempvel *= scaleVal;
    state.positions[target.targetIdx] =
        pack.pedset.ped_coords(target.targetIdx) + (tempvel * pack.dT);
  }
 
  // --------------------------------------------- END SCALING ------------------------------------------------------------------------
};
}  // namespace VIPRA::Behaviors