#pragma once

#include "../gamedef.h"

#if IS_EDITOR
#include <math.h>
#include "../util/string.h"

#define EPROP( _type, name, value, display ) \
  _type name = value; \
  EDITOR_PROP name##_prop{ .pdata = &name, .type = eprop_type<_type>(), .displayname = display, .parent = this };

#define EPROP_RANGED( _type, name, value, display, _min, _max ) \
  _type name{ value }; \
  EDITOR_PROP{ \
    .pdata = &name, \
    .type = eprop_type<_type>(), \
    .displayname = display, \
    .parent = this, \
    .min = _min, \
    .max = _max \
  }

enum EditorPropType_t {
  EPROP_INVALID = 0,
  EPROP_U8 = 1,
  EPROP_U16,
  EPROP_U32,
  EPROP_U64,
  EPROP_I8,
  EPROP_I16,
  EPROP_I32,
  EPROP_I64,
  EPROP_F32,
  EPROP_F64,
  EPROP_STRING,
  EPROP_OBJ,
  EPROP_LIST,
  EPROP_TEXTURE_LIST,
};

// editor map object
struct EOBJECT {
  LIST<struct EDITOR_PROP*> eprops{};
};

// editor object property
struct EDITOR_PROP {
  void* pdata;
  U8 type;
  STR displayname;
  F64 min{ -INFINITY };
  F64 max{ INFINITY };
  struct EOBJECT* parent;


  template <typename T> struct __eprop_type {
    static const U8 type = EPROP_INVALID;
  };
  template <> struct __eprop_type<U8>                              { static const U8 type = EPROP_U8;           };
  template <> struct __eprop_type<U16>                             { static const U8 type = EPROP_U16;          };
  template <> struct __eprop_type<U32>                             { static const U8 type = EPROP_U32;          };
  template <> struct __eprop_type<U64>                             { static const U8 type = EPROP_U64;          };
  template <> struct __eprop_type<I8>                              { static const U8 type = EPROP_I8;           };
  template <> struct __eprop_type<I16>                             { static const U8 type = EPROP_I16;          };
  template <> struct __eprop_type<I32>                             { static const U8 type = EPROP_I32;          };
  template <> struct __eprop_type<I64>                             { static const U8 type = EPROP_I64;          };
  template <> struct __eprop_type<F32>                             { static const U8 type = EPROP_F32;          };
  template <> struct __eprop_type<F64>                             { static const U8 type = EPROP_F64;          };
  template <> struct __eprop_type<STR>                             { static const U8 type = EPROP_STRING;       };
  template <> struct __eprop_type<EOBJECT>                         { static const U8 type = EPROP_OBJ;          };
  template <typename LT> struct __eprop_type<LIST<LT>>             { static const U8 type = EPROP_LIST;         };
  template <> struct __eprop_type<LIST<struct MAP_TEXTURE_ENTRY*>> { static const U8 type = EPROP_TEXTURE_LIST; };
};

template <typename T>
const U8 eprop_type() {
  if constexpr( __is_base_of( EOBJECT, T ) )
    return EPROP_OBJ;

  return EDITOR_PROP::__eprop_type<T>::type;
}
#else
struct EOBJECT {};

#define EPROP( type, name, value, displayname ) \
  type name{ value };
#endif