#ifndef _JSCProxyClass_h
#define _JSCProxyClass_h

#include <unordered_map>
#include "JSCProxyTransfer.h"
#include "JSCProxyFunction.h"
#include "JSCProxyType.h"


namespace laya
{
    
class JSCGlobal
{
public:
    JSCGlobal(){}
    ~JSCGlobal(){
        reset();
    }
    template <typename T>
    void  addProperty( const std::string& name, T value ){
        assert( !name.empty());
        JSContextRef pCtx = __TlsData::GetInstance()->GetCurContext();
        JSStringRef pJSStrName = JSStringCreateWithUTF8CString( name.c_str() );
        JSValueRef pVal = __TransferToJs<T>::ToJs( value );
        JSObjectSetProperty( pCtx, JSContextGetGlobalObject( pCtx ), pJSStrName, pVal, kJSPropertyAttributeDontDelete|kJSPropertyAttributeReadOnly, nullptr );
        JSStringRelease( pJSStrName );
    }
    template <typename T>
    void addFunction( const std::string& name, T fun ){
        assert( !name.empty() );
        IJSCFunction* pJSCFunction = new JSCFunction<T>( fun );
        JSContextRef pCtx = __TlsData::GetInstance()->GetCurContext();
        JSStringRef pjsName = JSStringCreateWithUTF8CString( name.c_str() );
        JSObjectRef pFunc = JSObjectMakeFunctionWithCallback(pCtx, pjsName, JSObjectCallAsFunctionCallback);
        JSObjectSetProperty(pCtx, JSContextGetGlobalObject(pCtx), pjsName, pFunc, kJSPropertyAttributeDontDelete|kJSPropertyAttributeReadOnly, nullptr);
        JSStringRelease( pjsName );
        FunctionMapRes rs = m_FunctionMap.insert(FunctionMapValue((unsigned long)pFunc, pJSCFunction));
        assert( rs.second );
    }
    IJSCFunction* getFunction(unsigned long func){
        FunctionMapItr itrFun = m_FunctionMap.find( func );
        if ( itrFun != m_FunctionMap.end() ){
            return itrFun->second;
        }
        else {
            return nullptr;
        }
    }
    static JSValueRef JSObjectCallAsFunctionCallback(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception){
        IJSCFunction* pJSCFunction = JSCGlobal::getInstance()->getFunction( (unsigned long)function );
        if ( pJSCFunction == nullptr ){
            __JsThrow::Throw(exception,"JSCGlobal::JSObjectCallAsFunctionCallback can't find function");
            return nullptr;
        }
        return pJSCFunction->call(ctx, function, thisObject, argumentCount, arguments, exception);
    }
    static JSCGlobal* getInstance(){
        static JSCGlobal instance;
        return &instance;
    }
    void reset(){
        FunctionMapItr iter = m_FunctionMap.begin();
        for (; iter != m_FunctionMap.end(); iter++){
            delete iter->second;
        }
        m_FunctionMap.clear();
    }
private:
    typedef std::unordered_map<unsigned long,IJSCFunction*> FunctionMap;
    typedef FunctionMap::value_type FunctionMapValue;
    typedef FunctionMap::iterator FunctionMapItr;
    typedef std::pair<FunctionMapItr,bool> FunctionMapRes;
    FunctionMap m_FunctionMap;
};

template<typename T>
class JSCClass
{
public:
    inline unsigned int __hash_BKDR(const char *p_str){
        if( 0 == p_str )
            return 0;
        
        unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
        unsigned int hash = 0;
        
        for(;0!=*p_str;){
            hash = hash * seed + (*p_str++);
        }
        
        return (hash & 0x7FFFFFFF);
    }
    class FuncEntry
    {
        enum
        {
            Max_Arg_Size  = 12,
            Invalid_size = -1,
        };
        IJSCCallback *m_funcs[Max_Arg_Size+1];
        int m_iMaxArgSize;
        
    public:
        FuncEntry(){
            m_iMaxArgSize = Invalid_size;
            memset( m_funcs, 0, sizeof(m_funcs) );
        }
        
        ~FuncEntry(){
            reset();
        }
        
        void reset(){
            for(int i=0;i<=Max_Arg_Size;++i){
                if( 0 != m_funcs[i] ){
                    delete m_funcs[i];
                    m_funcs[i] = 0;
                }
            }
        }
        
        void add( IJSCCallback *p_fn ){
            assert(p_fn != nullptr && p_fn->getNumArgs() <= Max_Arg_Size && m_funcs[p_fn->getNumArgs()] == nullptr );
            if( m_iMaxArgSize < p_fn->getNumArgs() )
                m_iMaxArgSize = p_fn->getNumArgs();
            m_funcs[p_fn->getNumArgs()] = p_fn;
        }
        
        IJSCCallback *get( int p_iArgNum ){
            if( Invalid_size == m_iMaxArgSize ){
                return 0;
            }
            
            if( p_iArgNum > m_iMaxArgSize )
                p_iArgNum = m_iMaxArgSize;
            
            for(;p_iArgNum>=0;p_iArgNum--){
                if( 0 != m_funcs[p_iArgNum] )
                    return m_funcs[p_iArgNum];
            }
            
            return 0;
        }
    };
    enum
    {
        CallbackType_Property,
        CallbackType_Function,
    };
    struct CallbackDefine
    {
        int m_iType;
        std::string m_name;
        IJSCCallback* m_pSetter;
        IJSCCallback* m_pGetter;
        
        FuncEntry m_Method;
        JSValueRef m_pCallAsFunction;
        
        CallbackDefine(const std::string& name, IJSCCallback* setter, IJSCCallback* getter)
        :m_name(name), m_iType(CallbackType_Property), m_pSetter(setter), m_pGetter(getter),m_pCallAsFunction(nullptr){
        }
        
        CallbackDefine(const std::string& name,IJSCCallback* method)
        :m_name(name), m_iType(CallbackType_Function), m_pSetter(nullptr), m_pGetter(nullptr),m_pCallAsFunction(nullptr){
            m_Method.add(method);
        }
        
        void addMethod( IJSCCallback *p_pfn ){
            m_Method.add(p_pfn);
        }
        
        IJSCCallback *getMethod( size_t p_iArgNum ){
            return m_Method.get( (int)p_iArgNum );
        }
        ~CallbackDefine(){
            
            if (m_pGetter){
                delete m_pGetter;
                m_pGetter = nullptr;
            }
            
            if (m_pSetter){
                delete m_pSetter;
                m_pSetter = nullptr;
            }
            
            m_Method.reset();
            JSContextRef ctx = __TlsData::GetInstance()->GetCurContext();
            if (ctx != nullptr && m_pCallAsFunction != nullptr){
                JSValueUnprotect(ctx, m_pCallAsFunction);
            }
        }
        
    };
    struct FixedProperty
    {
    private:
        JSValueRef m_pszName;
        JSValueRef m_pValue;
        
    public:
        template <typename _Tp>
        explicit FixedProperty( const char *p_pszName, _Tp p_Val )
        {
            JSContextRef pCtx = __TlsData::GetInstance()->GetCurContext();
            
            JSStringRef pszName = JSStringCreateWithUTF8CString(p_pszName);
            m_pszName = JSValueMakeString(pCtx, pszName);
            JSStringRelease(pszName);
            
            m_pValue = __TransferToJs<_Tp>::ToJs(p_Val);
            
            JSValueProtect( pCtx, m_pszName );
            JSValueProtect( pCtx, m_pValue );
        }
        
        ~FixedProperty()
        {
            JSContextRef pCtx = __TlsData::GetInstance()->GetCurContext();
            if( 0 != pCtx )
            {
                if( 0 != m_pszName )
                {
                    JSValueUnprotect( pCtx, m_pszName );
                }
                if( 0 != m_pValue )
                {
                    JSValueUnprotect( pCtx, m_pValue );
                }
            }
        }
        
        JSStringRef GetName()
        {
            return JSValueToStringCopy(__TlsData::GetInstance()->GetCurContext(), m_pszName, 0);
        }
        
        JSValueRef GetValue()
        {
            return m_pValue;
        }
    };
    typedef std::vector<FixedProperty *> FixedProperties;
    typedef typename FixedProperties::iterator FixedPropertiesIter;
        
    FixedProperties m_FixedProperties;
    
    JSCClass(){
        m_bIsGlobal = false;
        m_ClassDefine = kJSClassDefinitionEmpty;
        m_ClassObject = nullptr;
        m_iTypeID = __hash_BKDR(typeid(T).name());
    }
    ~JSCClass(){
        _reset();
    }
    unsigned int getTypeID(){
        return m_iTypeID;
    }
    static JSCClass* getInstance(){
        static JSCClass<T> instance;
        return &instance;
    }
    template <typename P>
    void addFixedProperty(const std::string& name,const P& val){
        assert(!name.empty());
        m_FixedProperties.push_back(new FixedProperty(name.c_str(),val));
    }
    template <typename G,typename S>
    void addProperty( const std::string& name, G getter, S setter){
        assert( !name.empty() );
        IJSCCallback* pGetter = new JSCCallback<G>(getter);
        IJSCCallback* pSetter = nullptr;
        if (setter != nullptr){
            pSetter = new JSCCallback<S>(setter);
        }
        PropertyMapRes rs = m_PropertyMap.insert(PropertyMapValue(name,new CallbackDefine(name,pSetter,pGetter)));
        assert(rs.second && "JSCClass::addProperty name is dumplicate value");
    }
    void addConstructor( IJSCCallback* constructor ){
        m_Constructor.add(constructor);
    }
    template<typename M>
    void addMethod( const std::string& name, M method ){
        
        PropertyMapItr iter = m_PropertyMap.find(name);
        
        if ( iter != m_PropertyMap.end() ){
            assert( iter->second->m_iType == CallbackType_Function );
            iter->second->addMethod(new JSCCallback<M>(method));
            return;
        }
        CallbackDefine* pProperty = new CallbackDefine(name,new JSCCallback<M>(method));
        JSStringRef pName = JSStringCreateWithUTF8CString(name.c_str());
        JSContextRef pCtx = __TlsData::GetInstance()->GetCurContext();
        pProperty->m_pCallAsFunction = JSObjectMakeFunctionWithCallback(pCtx, pName, JSCClass<T>::callAsFunctionCallback);
        JSStringRelease(pName);
        JSValueProtect(pCtx, pProperty->m_pCallAsFunction);
        
        
        PropertyMapRes rsp = m_PropertyMap.insert(PropertyMapValue(name,pProperty));
        assert(rsp.second);
        
        FunctionMapRes rsf = m_FunctionMap.insert(FunctionMapValue((unsigned long)pProperty->m_pCallAsFunction,pProperty));
        assert(rsf.second);
        
    }
    void finish( const std::string& name ){
        m_bIsGlobal = false;
        finishImpl( name, nullptr);
    }
    void finishToGlobal( const std::string& name, T* pIns){
        assert(pIns != nullptr);
        m_bIsGlobal = false;
        finishImpl( name, pIns);
        m_bIsGlobal = true;
    }
        JSObjectRef transferObjPtrToJS( T *p_pIns ){
        assert( !m_bIsGlobal );
        JSContextRef pCtx = __TlsData::GetInstance()->GetCurContext();
        JSObjectRef pRet = JSObjectMake( pCtx, m_ClassObject, p_pIns );
        p_pIns->mpJsThis = pRet;
        JSValueRef pProperty = JSValueMakeNumber(pCtx, (double)getTypeID());
        JSStringRef pszName = JSStringCreateWithUTF8CString(__Js_class_typeid_property);
        JSObjectSetProperty(pCtx, pRet, pszName, pProperty, kJSPropertyAttributeReadOnly|kJSPropertyAttributeDontDelete, 0);
        JSStringRelease(pszName);
        
        if( m_FixedProperties.size() ){
            FixedPropertiesIter iter;
            for(iter=m_FixedProperties.begin();iter!=m_FixedProperties.end();iter++){
                JSStringRef sName = (*iter)->GetName();
                JSObjectSetProperty(pCtx, pRet, sName, (*iter)->GetValue(), kJSPropertyAttributeReadOnly/*|kJSPropertyAttributeDontDelete*/, 0);
                //kJSPropertyAttributeDontDelete 就意味着这个值不能改了 fuck
               JSStringRelease(sName);
            }
        }
        
        return pRet;
    }
    static void reset(){
        JSCClass<T>::getInstance()->_reset();
    }
private:
    static JSObjectRef newWrap(JSContextRef ctx, JSObjectRef constructor, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception){
        if( JSCClass<T>::getInstance()->m_bIsGlobal ){
            __JsThrow::Throw(exception,"can't new a global object");
            return NULL;
        }
        
        IJSCCallback *pfn = JSCClass<T>::getInstance()->m_Constructor.get( (int)argumentCount );
        
        if( 0 == pfn ){
            return JSCClass<T>::getInstance()->transferObjPtrToJS(new T);
        }
        else{
            return pfn->constructor(ctx, constructor, argumentCount, arguments, exception);
        }
    }
    
    static void destroyWrap(JSObjectRef object){
        T *p = (T *)JSObjectGetPrivate(object);
        
        delete p;
    }
    
    static bool isInstanceOf(JSContextRef ctx, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception){
        if( !JSValueIsObject(ctx, possibleInstance) ){
            return false;
        }
        
        bool bRet = __CheckClassType::IsTypeOf<T>((JSObjectRef)possibleInstance);
        
        return bRet;
    }

    
    
    static bool hasProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName){
        std::string strPropertyName = __TransferToCpp<char *>::ToCpp(propertyName);
        resetJsStrBuf();
        if( !strPropertyName.length() ){
            return false;
        }
        
        return (0 != JSCClass<T>::getInstance()->findProperty(strPropertyName.c_str()));
    }
    static JSValueRef getProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception){
        T *pThis = (T *)JSObjectGetPrivate( object );
        
        if( 0 == pThis ){
            __JsThrow::Throw(exception,"not a global object");
            return NULL;
        }
        
        std::string strPropertyName = __TransferToCpp<char *>::ToCpp(propertyName);
        resetJsStrBuf();
        if( !strPropertyName.length() ){
            __JsThrow::Throw(exception,"GetProperty PropertyName is null");
            return NULL;
        }
        
        CallbackDefine *pProperty = JSCClass<T>::getInstance()->findProperty(strPropertyName.c_str());
        
        if( 0 == pProperty ){
            __JsThrow::Throw(exception,"GetProperty can't find property");
            return NULL;
        }
        
        JSValueRef pRet = NULL;
        if( CallbackType_Property == pProperty->m_iType ){
            // is property
            pRet = pProperty->m_pGetter->call(ctx, nullptr, object, 0, nullptr, nullptr);//?????????????????????
        }
        else
        {   // is function
            pRet = pProperty->m_pCallAsFunction;
        }
        
        return pRet;
    }
    static bool setProperty(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception){
        T *pThis = (T *)JSObjectGetPrivate( object );
        
        if( 0 == pThis ){
            __JsThrow::Throw(exception,"not a global object");
            return false;
        }
        
        std::string sPropertyName = __TransferToCpp<char *>::ToCpp(propertyName);
        resetJsStrBuf();
        if( sPropertyName.empty() ){
            __JsThrow::Throw(exception,"SetProperty PropertyName is null");
            return false;
        }
        
        CallbackDefine *pProperty = JSCClass<T>::getInstance()->findProperty(sPropertyName);
        
        
        if( 0 == pProperty ){
            return false;
        }
        
    
         if( CallbackType_Property != pProperty->m_iType )
         {
         if( pProperty->m_iType == CallbackType_Function ){
         JSObjectRef _obj = JSValueToObject(ctx, value, 0);
         if( JSObjectIsFunction(ctx,_obj) ){
         getInstance()->JSDefineFunction[sPropertyName] = _obj;
         return true;
         }
         }
         __JsThrow::Throw(exception,"SetProperty property is function object");
         return false;
         }
        
        if( 0 == pProperty->m_pSetter ){
            __JsThrow::Throw(exception,"SetProperty property is read only");
            return false;
        }
        
        JSValueRef arguments[1];
        arguments[0] = value;
        pProperty->m_pSetter->call(ctx, nullptr, object, 1, arguments, nullptr);
        return true;
    }
         
    
    static JSValueRef callAsFunctionCallback(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception){
        
        T *pThis = (T *)JSObjectGetPrivate( thisObject );
        
        if( nullptr == pThis ){
            __JsThrow::Throw(exception,"CallAsFunctionCallback this is null");
            return JSValueMakeUndefined(ctx);
        }
        
        CallbackDefine *pProperty = JSCClass<T>::getInstance()->findFunction((unsigned long)function);
        
        if( pProperty != NULL ){
         JSDefineFunctionIter it = getInstance()->JSDefineFunction.find(pProperty->m_name);
         if( it != getInstance()->JSDefineFunction.end() ){
         return JSObjectCallAsFunction(ctx,it->second,thisObject,argumentCount,arguments,0);
         }
         }
        
        
        if( nullptr == pProperty ){
            __JsThrow::Throw(exception,"CallAsFunctionCallback can't find function");
            return JSValueMakeUndefined(ctx);
        }
        
        IJSCCallback *pMethod = pProperty->getMethod(argumentCount);
        if( 0 != pMethod ){
            //__JsThrow::GetInstance()->UpdateException(exception);
            return pMethod->call(ctx, function, thisObject, argumentCount, arguments, exception);
        }
        else
        {
            __JsThrow::Throw(exception,"callAsFunctionCallback can't find function");
            return JSValueMakeUndefined(ctx);
        }
        
    }
    
    
private:
    void _reset(){
        
		if( m_FixedProperties.size() ){
            FixedPropertiesIter iter;
            for(iter=m_FixedProperties.begin();iter!=m_FixedProperties.end();iter++){
                delete *iter;
            }
            m_FixedProperties.clear();
        }
			
        for (PropertyMapItr itr = m_PropertyMap.begin(); itr != m_PropertyMap.end(); itr++ ){
            delete itr->second;
        }
        m_PropertyMap.clear();
        
        m_FunctionMap.clear();
        
        m_bIsGlobal = false;
        m_ClassDefine = kJSClassDefinitionEmpty;
        
        if ( m_ClassObject != nullptr ){
            JSClassRelease(m_ClassObject);
            m_ClassObject = nullptr;
        }
        JSDefineFunction.clear();
        
        m_Constructor.reset();
    }
    void finishImpl( const std::string& name, T *p_pIns ){
        
        assert(!name.empty());
        m_ClassDefine = kJSClassDefinitionEmpty;
        m_ClassDefine.attributes = kJSClassAttributeNone;
        m_ClassDefine.className = name.c_str();
        m_ClassDefine.callAsConstructor = JSCClass<T>::newWrap;
        m_ClassDefine.finalize = JSCClass<T>::destroyWrap;
        m_ClassDefine.hasProperty = JSCClass<T>::hasProperty;
        m_ClassDefine.hasInstance = JSCClass<T>::isInstanceOf;
        m_ClassDefine.getProperty = JSCClass<T>::getProperty;
        m_ClassDefine.setProperty = JSCClass<T>::setProperty;
        m_ClassDefine.callAsFunction = JSCClass<T>::callAsFunctionCallback;
        
        m_ClassObject = JSClassCreate(&m_ClassDefine);
        JSContextRef pCtx = __TlsData::GetInstance()->GetCurContext();
        JSStringRef jsName = JSStringCreateWithUTF8CString(name.c_str());
        JSObjectRef myObject;
        if( 0 != p_pIns ){
            myObject = transferObjPtrToJS( p_pIns );
            p_pIns->mpJsThis = myObject;
        }
        else
        {
            myObject = JSObjectMake(pCtx, m_ClassObject, 0);
        }
   
        JSObjectSetProperty( pCtx, JSContextGetGlobalObject(pCtx), jsName, myObject, kJSPropertyAttributeNone, NULL );//???
        JSStringRelease(jsName);
    }
    CallbackDefine *findFunction( unsigned long p_ulObj ){
        FunctionMapItr iter = m_FunctionMap.find(p_ulObj);
        if( iter == m_FunctionMap.end() ){
            return nullptr;
        }
        else
        {
            return (*iter).second;
        }
    }
    CallbackDefine *findProperty( const std::string& name ){
        PropertyMapItr iter = m_PropertyMap.find(name);
        if( iter == m_PropertyMap.end() ){
            return nullptr;
        }
        else
        {
            return (*iter).second;
        }
    }
    
    
private:
    typedef std::unordered_map<std::string,CallbackDefine*> PropertyMap;
    typedef typename PropertyMap::value_type PropertyMapValue;
    typedef typename PropertyMap::iterator PropertyMapItr;
    typedef std::pair<PropertyMapItr,bool> PropertyMapRes;
    PropertyMap m_PropertyMap;
    
    typedef std::unordered_map<unsigned long,CallbackDefine*> FunctionMap;
    typedef typename FunctionMap::value_type FunctionMapValue;
    typedef typename FunctionMap::iterator FunctionMapItr;
    typedef std::pair<FunctionMapItr,bool> FunctionMapRes;
    FunctionMap m_FunctionMap;
    
    bool m_bIsGlobal;
    JSClassDefinition m_ClassDefine;
    JSClassRef m_ClassObject;
    typedef std::unordered_map<std::string,JSObjectRef>::iterator JSDefineFunctionIter;
    std::unordered_map<std::string, JSObjectRef> JSDefineFunction;
    unsigned int m_iTypeID;
    
    FuncEntry m_Constructor;
};
}

#endif