//object 对象
if(!java) error("请先导入 java",2);;

namespace java;

class object{
	ctor( jvm,jvmInstancePtr ){ {
		
			if(!jvmInstancePtr) return;
			
			//保留字段必须以 $jvm 作为前缀
			this.$jvmInstancePtr = topointer(jvmInstancePtr);
			this.$jvmInvokeMethod = jvm.invokeMethod;
			this.$jvmFieldExists = jvm.fieldExists;
			this.$jvmSetFieldValue = jvm.setFieldValue;
			this.$jvmGetFieldValue = jvm.getFieldValue;
			//构造函数不要调用 Java 函数，避免 jvm.exceptionClear 里重入 java.object
			 
			this.$jvm = jvm;
			this.$jvmEnv = this.$jvm.env;
			var jvm,jniEnv = this.$jvm,this.$jvmEnv;
			
			var localInstanceRef = this.$jvmInstancePtr;
    		this.$jvmInstancePtr = this.$jvmEnv.NewGlobalRef(localInstanceRef);
    		this.$jvmEnv.DeleteLocalRef(localInstanceRef);  
    		
			this.getField = function(fname,asign){ 
			
    			if(! (asign && fname ) )error("必须指定参数:字段名,类型声明",2);
    			var jsign = convertSignature(asign); 
			
    			var jvm,jniEnv = this.$jvm,this.$jvmEnv;
    			var jClassPtr = this.$jvmEnv.GetObjectClass( this.$jvmInstancePtr );
    			if(!jClassPtr)error("查找类失败",2); 
			
    			var fid = jniEnv.GetFieldID(jClassPtr,fname,jsign); 
    			jniEnv.DeleteLocalRef(jClassPtr);
			
    			if ( jvm.exceptionClear() || (!fid) ) { 
        			error("查找字段名失败。方法名:" + fname,2); 
    			}
    			
    			var jniResultType = signatureTypeToJniType(asign); 
    			var jniGetterName = ..string.format("Get%sField",jniResultType )
    			var jniGetter = jniEnv[jniGetterName]
    			if(!jniGetter) error("查找字段调用方法" + jniGetterName + "失败,Java字段名:" + fname,2); 
    			
    			var ret = jniGetter( this.$jvmInstancePtr, fid);
    			
    			if( jniResultType = "Object" && ret ){
        			if( ..string.find(asign,"\[") ){
        			    var canonicalNonArrayResultType = signatureTypeToCanonicalType(..string.match(asign,"[^\[]+"));
        			    
            			return jvm.parseArray( canonicalNonArrayResultType ,ret );
        			}
        			else if( signatureTypeToCanonicalType(asign) == "string"){
        			    return jvm.parseString(ret);
        			}
        			
        			return ..java.object(jvm,ret);
    			}
    			
    			return ret;
			};
			
			this.getMethod = function(methodName,asign){ 

				if(!asign){
					if( type(methodName) == "string" ){
						if(..string.find(methodName,"%()")){
							error("参数 @1 应当指定函数名而不是函数签名！",2);
						}
						var r,f = callex(,this@._get,this,methodName,true);
						if(r) return f;
					}
					 
					return;	
				}
				
    			var jvm,jniEnv = this.$jvm,this.$jvmEnv;
    			
    			if(!asign)asign = "void()";	
    			if(!methodName)error("必须指定参数:字段名,类型声明",2);
			
    			var jsign = convertSignature(asign); 
    			var jClassPtr = jniEnv.GetObjectClass( this.$jvmInstancePtr );
    			if(!jClassPtr) error("查找类失败",2); 
    			
    			var method  = jniEnv.GetMethodID(jClassPtr,methodName,jsign);
    			jniEnv.DeleteLocalRef(jClassPtr);
    	
    			if ( jvm.exceptionClear() || (!method) ) {
        			error("查找方法失败。方法名:" + methodName,2);
        			return false;
    			}
    			
    			var resultType = ..string.match(asign, "\s*(.+)\s*\(");
    			var jniResultType = signatureTypeToJniType(resultType);
    			var jniCallerName  = ..string.format("Call%sMethod",jniResultType );
    			jniCallerName = jniCallerName + "A"; 
    			
    			var jCaller = jniEnv[jniCallerName]
    			if(!jCaller){ error("找不到调用函数 jniEnv."+jniCallerName+"()",2) }
    			
    			var singleArgType = ..string.match(asign,"\(\W*([\w\/\.\[]+)\W*\)");
    			var singleNonArrayArgType = singleArgType ? ..string.replace( singleArgType,"[\[\]]","");
    			var singleJValueFieldName = singleNonArrayArgType ? ( "j" + ..string.lower( signatureTypeToJniType(singleNonArrayArgType) ) );    
     			
     			/*
     			java.lang.String,java/lang/String 转为 string，
     			object,Object,java.lang.String 以及其他类型 等转为 pointer
     			*/
     			var singleCanonicalNonArrayArgType = singleNonArrayArgType ? signatureTypeToCanonicalType(singleNonArrayArgType);
     			
    			var safeRet = function(ret){
         			var errOccurred,errMessage = jvm.exceptionClear();
                    if ( errOccurred ) { error(errMessage,3) } 
                     				
         			return ret;
    			} 

    			if(resultType){
    			    
    			    //JNI 返回类型，string 也必须先返回为 Object 。
         			if( jniResultType = "Object"){
            			if(..string.find(resultType,"\[")  ){ 
                			var canonicalNonArrayResultType = signatureTypeToCanonicalType(..string.match(resultType,"[^\[]+"));
                			safeRet = function(ret){
                			    var errOccurred,errMessage = jvm.exceptionClear();
                     			if ( errOccurred ) { error(errMessage,3) } 
                     			return jvm.parseArray(canonicalNonArrayResultType,ret);
                 			}
            			}
            			else{
            				if( ..string.cmp(signatureTypeToCanonicalType(resultType),"string") == 0 ){
                 				safeRet = function(ret){ 
                    				var errOccurred,errMessage = jvm.exceptionClear();
                     				if ( errOccurred ) { error(errMessage,3) } 
                     			 	
                     				return jvm.parseString(ret);
                 				}
             				}
            				else {
                				safeRet = function(ret){
                     				var errOccurred,errMessage = jvm.exceptionClear();
                     				if ( errOccurred ) { error(errMessage,3) } 
                     				
                     				return ..java.object(jvm,ret);
                 				}
            				}
            			}
        			} 
    			}
    			
    			if( singleArgType ? ..string.find(singleArgType,"\[") ){
    			  
        			if( singleCanonicalNonArrayArgType ? ..string.cmp(singleCanonicalNonArrayArgType,"string") == 0 ){ 
            			return function(...){ 
                			return safeRet( jCaller(this,method,{ pointer jobject = jvm.stringArray(...) } ) );
            			}
        			}
        			else{ 
            			return function(...){
                			return safeRet( jCaller(this,method,{ pointer jobject = jvm.array(singleCanonicalNonArrayArgType,...) }) );
            			}
        			}
    			}
    			else{   
        			if(!singleCanonicalNonArrayArgType){
        			    if( ..string.indexOf(asign,",") ){
        			        var asignAargs = ..string.match(asign,"%()");
        			        
        			        var jvalueParamConverters = []
        			        var jvalueParams = [];
        			        
        			        for argType in ..string.gmatch(asignAargs,"[^(),]+") { 
								
            			    
            					var singleNonArrayArgType = argType ? ..string.replace( argType,"[\[\]]","");
    							var jvalueFieldName =  "j" + ..string.lower( signatureTypeToJniType(singleNonArrayArgType) );   
    							var singleCanonicalNonArrayArgType = signatureTypeToCanonicalType(singleNonArrayArgType); 
								
								if(..string.find(argType,"\[")) {
									if( singleCanonicalNonArrayArgType ? ..string.cmp(singleCanonicalNonArrayArgType,"string") == 0 ){ 
										..table.push( jvalueParamConverters,["jobject", jvm.stringArray,true]);
										
        							}
        							else{ 
        							    ..table.push( jvalueParamConverters,["jobject", lambda (...)jvm.array(singleCanonicalNonArrayArgType,...),true]);
        							}	
								}	 
								elseif(  ..string.cmp(singleCanonicalNonArrayArgType,"string") == 0 ){
									 ..table.push( jvalueParamConverters,[jvalueFieldName, jvm.string]);
									 
								}
     							elseif(  ..string.cmp(singleCanonicalNonArrayArgType,"pointer") == 0 ){
									 ..table.push( jvalueParamConverters,[jvalueFieldName, jvm.object]);
								}
								else{
									 ..table.push( jvalueParamConverters,[jvalueFieldName]); 
								} 
								
								..table.push(jvalueParams,jvalue());
        					} 
        					
        					var paramsLength = #jvalueParams;
        			
        					return function(...){ 
        					    var args = {...}
        					    var argsLength = #args;
        						if(!argsLength) error("参数不能为空",2);
        					    
        					    for(i,argNameConvert in jvalueParamConverters){
        							var field,convert = argNameConvert[1],argNameConvert[2];
        					    		
        							if(!convert){
        					    		jvalueParams[i].v[field] = args[i]
        							}
        							else{
        					    		if( i < paramsLength 
        					        		|| argsLength <= paramsLength
        					        		|| !argNameConvert[3]){
        					    			jvalueParams[i].v[field] = convert(args[i])
        					    		}
        					    		else{ 
        					    			jvalueParams[i].v[field] = convert(..table.unpack(args,i) )
        					    		}
        							}
        						}
        					     
                				return safeRet( jCaller(this,method,{ struct args[] = jvalueParams }) );
            				}
        				}
        			
            			return function(){
                			return safeRet( jCaller(this,method,{} ) );
            			}
        			}
        			elseif(  ..string.cmp(singleCanonicalNonArrayArgType,"string") == 0 ){
            			return function(arg){
                			var jv = jvalue();
                			jv.v[singleJValueFieldName] = jvm.string(arg);
                			return safeRet( jCaller(this,method,jv) );
            			}
        			}
        			elseif(  ..string.cmp(singleCanonicalNonArrayArgType,"pointer") == 0 ){
            			return function(arg){
                			var jv = jvalue();
                			jv.v[singleJValueFieldName] = jvm.object(arg);
                			return safeRet( jCaller(this,method,jv) );
            			}
        			}
        			else{ 
            			return function(arg){ 
                			jarg = jvalue();
                			jarg.v[singleJValueFieldName] = arg;  
                			return safeRet( jCaller(this,method,jarg) );
            			}
        			}
    			}
			};
			
			this._jvm_deleteDeleteGlobalRef = function(){
				if( this.$jvmInstancePtr ){
					jniEnv.DeleteGlobalRef(this.$jvmInstancePtr); 
					this.$jvmInstancePtr = null;
				}
			}

			..table.gc(this,this._jvm_deleteDeleteGlobalRef) 
	} };


	@_meta; 
}

namespace object{
	
	_defauntFunctions = {
		toString = "string()";
		equals = "bool(pointer)";
		hashCode = "INT()";
		getClass = "java.lang.Class()";
		clone = "object()";
		iterator = "java.util.Iterator()"; 
		parseValue = function(){
			
			//调用程序请不要使用 $jvmTypeCode，后续可能会变更
			var t = owner[["$jvmTypeCode"]];
			if(t===null){
				t = owner.$jvm.objectTypecode(owner);
				owner[["$jvmTypeCode"]] = t;
			}
			
			if(t == 8/*Map*/){
				var tab = {};
				for k,v in owner.each(){
					if( is(v) ) v = v.parseValue(); 
					
					tab[k] = v; 
				}
				
				return tab;
			}
			
			if(t == 9/*Collection*/){
				var arr = [];
				var i = 1;
				for v in owner.each(){
					if( is(v) ) v = v.parseValue(); 
					
					arr[i] = v;
					i++;
				}
				
				return arr;
			}
			
			//因为有自动转换，需要执行下面代码的情况较少见
			if( t == 1 ) return owner.$jvm.object2String(obj);
			if( t == 2 ) return owner.$jvm.object2Number(obj); 
			if( t == 3 ) return owner.$jvm.object2StringArray(obj); 
			if( t == 4 ) return owner.$jvm.object2NumberArray(obj);
			if( t == 5 ) return owner.$jvm.parseBuffer(obj);
			if( t == 6 ) return owner.$jvm.object2Boolean(obj);
			if( t == 7 ) return ..time( (obj.getTime()/1000) );	
		}
		invocable = function(thiz){
 			if(type(thiz)=="string"){
 				thiz = owner.get(thiz)
 				if(!thiz) return;
 			}

			if(thiz){
				var this = owner;
				var invokeMethod = owner[["invokeMethod"]]
				if(!invokeMethod) {
					owner[["invokeMethod"]] = owner.getMethod("invokeMethod","object(object,string,object[])")
					owner[["invokeFunction"]] = owner.getMethod("invokeFunction","object(string,object[])")
					invokeMethod = owner[["invokeMethod"]]
				}
			 
				return {
					@ {
						_type = "object";
						_get = function(k,ownerCall){ 
							if(k!=="_struct") return function(...){ 
								return invokeMethod(thiz,k,...)
							};
						}  
					}
				} 
			} 
			else{
				var this = owner;
				var invokeFunction = owner[["invokeFunction"]]
				if(!invokeFunction) {
					owner[["get"]] = owner.getMethod("get","object(string)")
					owner[["put"]] = owner.getMethod("put","void(string,object)")
					owner[["invokeFunction"]] = owner.getMethod("invokeFunction","object(string,object[])")
					owner[["invokeMethod"]] = owner.getMethod("invokeMethod","object(object,string,object[])")
					invokeFunction = owner[["invokeFunction"]]
				}

				return {
					@{
						_type = "object";
						_get = function(k,ownerCall){
							if(ownerCall){
								return function(...){
									return invokeFunction(k,...)
								};	
							} 
							
							if(k!=="_struct") return this.get(k);
						};
						_set = function(k,v,ownerAttr){
							if(k!=="_struct") this.put(k,v);
						};
					}
				}
			}
			
		} 
	}
	
	is = function(v){
		return v@ === _meta;
	}
	
	_meta = { 
		_type = "java.object";
		_topointer = function(){
			return owner.$jvmInstancePtr;
		}
		_tostring = function(){
			return owner.toString();
		}
		_json = function(){
			var v = owner.parseValue();
			if(v!==null) return v;

			return owner.toString(); 
		}
		_eq = function(b){
			return owner.equals( b );
		}
		_set = function(k,v,ownerAttr){
			var kType = type(k);
			if(!ownerAttr){
				if(kType=="number"){
					
					if(!owner[["set"]]){
						owner[["set"]] = owner.getMethod("set","object(int,object)");	
					}
					owner.set(k,v);
					return; 
				}
			}
			
			if(kType!="string" || k=='_struct' || type(v) == "function") {
				 
				owner[[k]] = v;
				return;
			}
			owner.$jvmSetFieldValue(owner,k,v);
		}
		_get = function(k,ownerCall){
			var kType = type(k);
			if(ownerCall === null){
				if(kType=="number"){
					if(!owner[["get"]]){
						owner[["get"]] = owner.getMethod("get","object(int)");
					}
					
					return owner.get(k); 
				}
			}
			
			if(kType!="string" || k=='_struct') {
				//调用程序请不要使用 $jvmTypeCode，后续可能会变更
				var t = owner[["$jvmTypeCode"]];
				if(t===null){
					t = owner.$jvm.objectTypecode(owner);
					owner[["$jvmTypeCode"]] = t;
				}
				
				return owner[[k]];
			}
			 
			var defauntFunction = _defauntFunctions[k];
			if(defauntFunction){
				owner[[k]] = type(defauntFunction) == "function" ? defauntFunction : owner.getMethod(k,defauntFunction); 
				return owner[[k]];
			}
			
			if(k==="each"){
				
				//调用程序请不要使用 $jvmTypeCode，后续可能会变更
				var t = owner[["$jvmTypeCode"]];
				if(t===null){
					t = owner.$jvm.objectTypecode(owner);
					owner[["$jvmTypeCode"]] = t;
				}
			
			 	if(t == 8/*Map*/){
			 		owner[["each"]] = function(){ 
						var iter = owner.entrySet().iterator();
						
						return function(){
							if(iter.hasNext()){
								var entry = iter.next();
								return entry.getKey(),entry.getValue();
							}
						}; 
					}; 	
			 	}
			 	else{
					owner[["each"]] = function(){ 
						var iter = owner.iterator();
						
						return function(){
							if(iter.hasNext()){
								return iter.next();
							}
						}; 
					}; 
				}
				return owner[["each"]];
			}
			
			if( (!ownerCall) && ( owner.$jvmFieldExists(owner,k)) ){
				return owner.$jvmGetFieldValue(owner,k);
			}
			
			var this = owner;
			owner[[k]] = function(...){
				var r,errMsg = this.$jvmInvokeMethod(this,k,...);
				if(errMsg && (r === null)) error(errMsg,2);
				return  r; 
			}
			
			return owner[[k]];
		}
	}  
	
	jvalue =  ..java.jvalue;
	convertSignature =  ..java.convertSignature;
	signatureTypeToCanonicalType = ..java.signatureTypeToCanonicalType;
	signatureTypeToJniType = ..java.signatureTypeToJniType;
}

/*****intellisense()
java.object.is(__) = 判断一个对象是否 java.object 。\n只能由 java 扩展库自动创建 java.object，\n不应当手动调用 java.object 构造函数。
end intellisense*****/