#include <hxcpp.h>

#include <math.h>

#include <hxMath.h>

#include <stdio.h>

using namespace hx;

@implementation NSHaxeWrapperClass

- (id)init:( hx::Object * ) inHaxe {

self = [super init];

haxeObject = inHaxe;

hx::GCAddRoot(&haxeObject);

if (self!=nil) {

}

return self;

}

- (void)dealloc {

GCRemoveRoot(&haxeObject);

#ifndef OBJC_ARC

[super dealloc];

#endif

}

@end

id _hx_value_to_objc(Dynamic d)

{

if (!d.mPtr)

return nil;

switch(d->__GetType())

{

case vtNull:

case vtUnknown:

return nil;

case vtInt:

case vtBool:

return [ NSNumber numberWithInt: (int)d ];

case vtInt64:

return [ NSNumber numberWithLongLong: (cpp::Int64)d ];

case vtFloat:

return [ NSNumber numberWithDouble: (double)d ];

case vtString:

return (NSString *)String(d);

case vtObject:

return _hx_obj_to_nsdictionary(d);

case vtArray:

{

Array_obj<unsigned char> *bytes = dynamic_cast< Array_obj<unsigned char> * >(d.mPtr);

if (bytes)

{

if (!bytes->length)

return [NSData alloc];

else

return [NSData dataWithBytes:bytes->GetBase() length:bytes->length];

}

else

{

cpp::VirtualArray varray = d;

int len = varray->get_length();

NSMutableArray *array = [NSMutableArray arrayWithCapacity:len];

for(int i=0;i<len;i++)

array[i] = _hx_value_to_objc( varray->__get(i) );

return array;

}

}

case vtClass:

if (d->__GetClass()->mName==HX_CSTRING("haxe.io.Bytes"))

{

return _hx_value_to_objc( d->__Field( HX_CSTRING("b"), hx::paccDynamic ) );

}

// else fallthough...

case vtFunction:

case vtEnum:

case vtAbstractBase:

{

return (NSString *)d->toString();

}

}

return nil;

}

NSDictionary<NSString *, id> *_hx_obj_to_nsdictionary(Dynamic d)

{

if (d==null())

return nil;

Array<String> fields = Array_obj<String>::__new();

d->__GetFields(fields);

NSMutableArray *objects = [[NSMutableArray alloc] initWithCapacity:fields->length ];

NSMutableArray *keys = [[NSMutableArray alloc] initWithCapacity:fields->length ];

for(int i=0; i <fields->length; i++)

{

objects[i] = _hx_value_to_objc( d->__Field(fields[i], hx::paccDynamic ) );

keys[i] = (NSString *)fields[i];

}

NSDictionary *result = [NSDictionary<NSString *,id> dictionaryWithObjects:objects forKeys:keys];

return result;

}

Array<unsigned char> _hx_objc_to_bytes(id value)

{

NSData *data = value;

return Array_obj<unsigned char>::fromData((const unsigned char *)data.bytes, data.length);

}

hx::Val _hx_objc_to_value(id value)

{

if (value==nil)

return null();

else if ([value isKindOfClass:[NSNumber class]])

return [value floatValue];

else if ([value isKindOfClass:[NSString class]])

return String( (NSString *)value );

else if ([value isKindOfClass:[NSDictionary class]])

return _hx_nsdictionary_to_obj( (NSDictionary *) value);

else if ([value isKindOfClass:[NSArray class]])

{

NSArray *array = value;

cpp::VirtualArray varray = cpp::VirtualArray_obj::__new();

for(id object in array)

varray->push( _hx_objc_to_value(object) );

return varray;

}

else if ([value isKindOfClass:[NSData class]])

{

return _hx_objc_to_bytes(value);

}

else

return String( [value stringValue] );

}

Dynamic _hx_nsdictionary_to_obj(NSDictionary<NSString *, id> *inDictionary)

{

if (!inDictionary)

return null();

hx::Anon obj = new hx::Anon_obj();

for (NSString *key in inDictionary)

{

id value = inDictionary[key];

obj->__SetField( String(key), _hx_objc_to_value(value), hx::paccDynamic);

}

return obj;

}

Dynamic _hx_objc_to_dynamic(id inValue)

{

return _hx_objc_to_value(inValue);

}

namespace hx {

extern hx::Class __ObjcClass;

class ObjcData : public hx::Object

{

public:

inline void *operator new( size_t inSize, hx::NewObjectType inAlloc=NewObjAlloc,const char *inName="objc.BoxedType")

{ return hx::Object::operator new(inSize,inAlloc,inName); }

ObjcData(const id inValue) : mValue(inValue)

{

#ifndef OBJC_ARC

[ inValue retain ];

#endif

mFinalizer = new hx::InternalFinalizer(this,clean);

};

static void clean(hx::Object *inObj)

{

ObjcData *m = dynamic_cast<ObjcData *>(inObj);

if (m)

{

#ifndef OBJC_ARC

[m->mValue release];

#else

m->mValue = nil;

#endif

}

}

#ifdef HXCPP_VISIT_ALLOCS

void __Visit(hx::VisitContext *__inCtx) { mFinalizer->Visit(__inCtx); }

#endif

hx::Class __GetClass() const { return hx::__ObjcClass; }

#if (HXCPP_API_LEVEL<331)

bool __Is(hx::Object *inClass) const { return dynamic_cast< ObjcData *>(inClass); }

#endif

// k_cpp_objc

int __GetType() const { return vtAbstractBase + 4; }

#ifdef OBJC_ARC

void * __GetHandle() const { return (__bridge void *) mValue; }

#else

void * __GetHandle() const { return (void *) mValue; }

#endif

String toString()

{

return String(!mValue ? "null" : [[mValue description] UTF8String]);

}

String __ToString() const { return String(!mValue ? "null" : [[mValue description] UTF8String]); }

int __Compare(const hx::Object *inRHS) const

{

if (!inRHS)

return mValue == 0 ? 0 : 1;

const ObjcData *data = dynamic_cast< const ObjcData *>(inRHS);

if (data)

{

return [data->mValue isEqual:mValue] ? 0 : mValue < data->mValue ? -1 : 1;

}

else

{

void *r = inRHS->__GetHandle();

#ifdef OBJC_ARC

void * ptr = (__bridge void *) mValue;

#else

void * ptr = (void *) mValue;

#endif

return ptr < r ? -1 : ptr==r ? 0 : 1;

}

}

#ifdef OBJC_ARC

id mValue;

#else

const id mValue;

#endif

hx::InternalFinalizer *mFinalizer;

};

}

Dynamic::Dynamic(const id inVal)

{

mPtr = inVal ? (hx::Object *)new ObjcData(inVal) : 0;

}