#import <Foundation/NSString.h>
#include "DictionaryAdapter.h"
#include "DataWrapper.h"
#include "Helpers.h"
#include "Interop.h"
#include "Caches.h"

using namespace v8;
using namespace tns;

@interface DictionaryAdapterMapKeysEnumerator : NSEnumerator

- (instancetype)initWithMap:(std::shared_ptr<Persistent<Value>>)map isolate:(Isolate*)isolate cache:(std::shared_ptr<Caches>)cache;

@end

@implementation DictionaryAdapterMapKeysEnumerator {
    Isolate* isolate_;
    uint32_t index_;
    std::shared_ptr<Persistent<Value>> map_;
    std::shared_ptr<Caches> cache_;
}

- (instancetype)initWithMap:(std::shared_ptr<Persistent<Value>>)map isolate:(Isolate*)isolate cache:(std::shared_ptr<Caches>)cache {
    if (self) {
        self->isolate_ = isolate;
        self->index_ = 0;
        self->map_ = map;
        self->cache_ = cache;
    }

    return self;
}

- (id)nextObject {
    Isolate* isolate = self->isolate_;
    v8::Locker locker(isolate);
    Isolate::Scope isolate_scope(isolate);
    HandleScope handle_scope(isolate);

    Local<Context> context = self->cache_->GetContext();
    Local<v8::Array> array = self->map_->Get(isolate).As<Map>()->AsArray();

    if (self->index_ < array->Length() - 1) {
        Local<Value> key;
        bool success = array->Get(context, self->index_).ToLocal(&key);
        tns::Assert(success, isolate);
        self->index_ += 2;
        NSString* result = tns::ToNSString(self->isolate_, key);
        return result;
    }

    return nil;
}

- (void)dealloc {
    self->isolate_ = nullptr;
    self->map_ = nil;
    self->cache_ = nil;
    
    [super dealloc];
}

@end

@interface DictionaryAdapterObjectKeysEnumerator : NSEnumerator

- (instancetype)initWithProperties:(std::shared_ptr<Persistent<Value>>)dictionary isolate:(Isolate*)isolate cache:(std::shared_ptr<Caches>)cache;
- (Local<v8::Array>)getProperties;

@end

@implementation DictionaryAdapterObjectKeysEnumerator {
    Isolate* isolate_;
    std::shared_ptr<Persistent<Value>> dictionary_;
    NSUInteger index_;
    std::shared_ptr<Caches> cache_;
}

- (instancetype)initWithProperties:(std::shared_ptr<Persistent<Value>>)dictionary isolate:(Isolate*)isolate cache:(std::shared_ptr<Caches>)cache {
    if (self) {
        self->isolate_ = isolate;
        self->dictionary_ = dictionary;
        self->index_ = 0;
        self->cache_ = cache;
    }

    return self;
}

- (Local<v8::Array>)getProperties {
    v8::Locker locker(self->isolate_);
    Isolate::Scope isolate_scope(self->isolate_);
    EscapableHandleScope handle_scope(self->isolate_);

    Local<Context> context = self->cache_->GetContext();
    Local<v8::Array> properties;
    Local<Object> dictionary = self->dictionary_->Get(self->isolate_).As<Object>();
    tns::Assert(dictionary->GetOwnPropertyNames(context).ToLocal(&properties), self->isolate_);
    return handle_scope.Escape(properties);
}

- (id)nextObject {
    Isolate* isolate = self->isolate_;
    v8::Locker locker(isolate);
    Isolate::Scope isolate_scope(isolate);
    HandleScope handle_scope(isolate);

    Local<Context> context = self->cache_->GetContext();
    Local<v8::Array> properties = [self getProperties];
    if (self->index_ < properties->Length()) {
        Local<Value> value;
        bool success = properties->Get(context, (uint)self->index_).ToLocal(&value);
        tns::Assert(success, isolate);
        self->index_++;
        std::string result = tns::ToString(self->isolate_, value);
        return [NSString stringWithUTF8String:result.c_str()];
    }

    return nil;
}

- (NSArray*)allObjects {
    Isolate* isolate = self->isolate_;
    v8::Locker locker(isolate);
    Isolate::Scope isolate_scope(isolate);
    HandleScope handle_scope(isolate);

    Local<Context> context = self->cache_->GetContext();
    NSMutableArray* array = [NSMutableArray array];
    Local<v8::Array> properties = [self getProperties];
    for (int i = 0; i < properties->Length(); i++) {
        Local<Value> value;
        bool success = properties->Get(context, i).ToLocal(&value);
        tns::Assert(success, isolate);
        std::string result = tns::ToString(self->isolate_, value);
        [array addObject:[NSString stringWithUTF8String:result.c_str()]];
    }

    return array;
}

- (void)dealloc {
    self->isolate_ = nullptr;
    self->dictionary_ = nil;
    self->cache_ = nil;
    
    [super dealloc];
}

@end

@implementation DictionaryAdapter {
    Isolate* isolate_;
    std::shared_ptr<Persistent<Value>> object_;
    std::shared_ptr<Caches> cache_;
    NSEnumerator* enumerator_;
}

- (instancetype)initWithJSObject:(Local<Object>)jsObject isolate:(Isolate*)isolate {
    if (self) {
        self->isolate_ = isolate;
        self->cache_ = Caches::Get(isolate);
        self->object_ = std::make_shared<Persistent<Value>>(isolate, jsObject);
        self->cache_->Instances.emplace(self, self->object_);
        tns::SetValue(isolate, jsObject, MakeGarbageCollected<ObjCDataWrapper>(isolate, self));
    }

    return self;
}

- (NSUInteger)count {
    v8::Locker locker(self->isolate_);
    Isolate::Scope isolate_scope(self->isolate_);
    HandleScope handle_scope(self->isolate_);

    Local<Object> obj = self->object_->Get(self->isolate_).As<Object>();

    if (obj->IsMap()) {
        return obj.As<Map>()->Size();
    }

    Local<Context> context = self->cache_->GetContext();
    Local<v8::Array> properties;
    tns::Assert(obj->GetOwnPropertyNames(context).ToLocal(&properties), self->isolate_);

    uint32_t length = properties->Length();

    return length;
}

- (id)objectForKey:(id)aKey {
    Isolate* isolate = self->isolate_;
    v8::Locker locker(isolate);
    Isolate::Scope isolate_scope(isolate);
    HandleScope handle_scope(isolate);

    Local<Context> context = self->cache_->GetContext();
    Local<Object> obj = self->object_->Get(self->isolate_).As<Object>();

    Local<Value> value;
    if ([aKey isKindOfClass:[NSNumber class]]) {
        unsigned int key = [aKey unsignedIntValue];
        bool success = obj->Get(context, key).ToLocal(&value);
        tns::Assert(success, isolate);
    } else if ([aKey isKindOfClass:[NSString class]]) {
        const char* key = [aKey UTF8String];
        Local<v8::String> keyV8Str = tns::ToV8String(isolate, key);

        if (obj->IsMap()) {
            Local<Map> map = obj.As<Map>();
            bool success = map->Get(context, keyV8Str).ToLocal(&value);
            tns::Assert(success, isolate);
        } else {
            bool success = obj->Get(context, keyV8Str).ToLocal(&value);
            tns::Assert(success, isolate);
        }
    } else {
        // TODO: unsupported key type
        tns::Assert(false, isolate);
    }

    id result = Interop::ToObject(context, value);

    return result;
}

- (NSEnumerator*)keyEnumerator {
    v8::Locker locker(self->isolate_);
    Isolate::Scope isolate_scope(self->isolate_);
    HandleScope handle_scope(self->isolate_);

    Local<Value> obj = self->object_->Get(self->isolate_);

    if (obj->IsMap()) {
        self->enumerator_ = [[[DictionaryAdapterMapKeysEnumerator alloc] initWithMap:self->object_ isolate:self->isolate_ cache:self->cache_] autorelease];
        
        return self->enumerator_;
    }

    self->enumerator_ = [[[DictionaryAdapterObjectKeysEnumerator alloc] initWithProperties:self->object_ isolate:self->isolate_ cache:self->cache_] autorelease];
    
    return self->enumerator_;
}

- (void)dealloc {
    self->cache_->Instances.erase(self);
    Local<Value> value = self->object_->Get(self->isolate_);
    BaseDataWrapper* wrapper = tns::GetValue(self->isolate_, value);
    if (wrapper != nullptr) {
        tns::DeleteValue(self->isolate_, value);
        delete wrapper;
    }
    self->object_->Reset();
    self->isolate_ = nullptr;
    self->cache_ = nil;
    self->object_ = nil;
    
    if (self->enumerator_ != nullptr) {
        // CFAutorelease(self->enumerator_);
        self->enumerator_ = nullptr;
    }
    self->cache_ = nullptr;
    self->object_ = nullptr;
    
    [super dealloc];
}

@end