﻿import json
import sys
import operator
from functools import reduce

structlist = {}
typedeflist = {}
enumlist = {}

# These are not exported to the json, so we just maintain the small subset here by hand for now.
structparents = {
	'VRTextureWithPose_t' : 'Texture_t',
	'VRTextureWithDepth_t' : 'Texture_t',
	'VRTextureWithPoseAndDepth_t' : 'VRTextureWithPose_t' }

structindices = {}

def loadfile(filename, ns):
	with open(filename) as data_file:
		data = json.load(data_file)

	i = 0
	for struct in data['structs']:
		if(len(struct) > 0 and len(struct['struct'])):
			structname = struct['struct']
			structlist[structname] = 'struct'
			structindices[getclasswithoutnamespace(structname)] = i
		i += 1

	for typedef in data['typedefs']:
		if(len(typedef) > 0 and len(typedef['typedef'])):
			typedeflist[typedef['typedef']] = typedef['type']
	for enum in data['enums']:
		enumname = enum['enumname']
		namespace = getnamespace(enumname)
		if(len(enum) > 0 and len(enum['enumname'])):
			enumlist[enum['enumname'].replace('::','_')] = enum['enumname']
	return data


def paramshavelength(params, paramname):
	checkname = paramname[1:]
	for param in params:
		name = param['paramname']
		name = name[3:len(name)-4]
		sys.stdout.write ('// ' + name + ' ' + checkname + '\n');
		if(name == checkname):
			return True
	return False

def calculateinteropmethodname(classname, methodname):
	return classname.replace('vr::', 'VR::').replace('::', '_') + '_' + methodname

def unmanagedtype(thetype):
	if(thetype == 'float'):
		return 'R4'
	if(thetype == 'double'):
		return 'R8'
	if(thetype == 'char'):
		return 'I1'
	if(thetype == 'byte'):
		return 'U1'
	if(thetype == 'ulong'):
		return 'U8'
	if(thetype == 'uint'):
		return 'U4'
	if(thetype == 'CSteamID'):	# Special case for CSteamID which is a complex C def but is 64-bits.
		return 'U8'
	return 'Struct'

def ctype(thetype):
	thetype = thetype.replace('vr::','')
	if(thetype[0:6] == 'const '):
		thetype = thetype[6:]
	if(thetype[0:6] == 'class '): # for C replaces classes by pointers
		thetype = 'intptr_t'
	if(thetype == 'ulong'):
		return 'unsigned long long'
	if(thetype == 'uint'):
		return 'unsigned long'
	return thetype

def striparraysuffix(thetype):
	if(thetype[len(thetype) - 1] == ']'):
		thetype = thetype[0:thetype.find('[')-1]
	if(thetype == '_Bool'):
		thetype = 'bool'
	return thetype

def converttype(thetype):
	if(thetype[0:11] == 'struct vr::'):
		thetype = thetype[11:]
	if(thetype[0:17] == 'const struct vr::'):
		thetype = thetype[17:]
	if(thetype[0:10] == 'class vr::'):
		thetype = thetype[10:]
	if(thetype == 'const char *const'):
		thetype = 'string'
	#thetype = thetype.replace('::', '_')
	thetypewithnamespace = thetype
	thetype = getclasswithoutnamespace(thetype)
	if(thetype[0:6] == 'const '):
		thetype = thetype[6:]
	if(thetype == 'class CSteamID'):
		thetype = 'ulong'
	if(thetype == 'uint8'):
		thetype = 'byte'
	if(thetype == 'uint8_t'):
		thetype = 'byte'
	if(thetype == 'unsigned short'):
		thetype = 'ushort'
	if(thetype == 'unsigned char'):
		thetype = 'byte'
	#if(thetype == 'unsigned int'):
	#	thetype = 'uint'
	if(thetype == 'uint16'):
		thetype = 'ushort'
	if(thetype == 'uint16_t'):
		thetype = 'ushort'
	if(thetype == 'uint32'):
		thetype = 'uint'
	if(thetype == 'uint32_t'):
		thetype = 'uint'
	if(thetype == 'uint64'):
		thetype = 'ulong'
	if(thetype == 'short'):
		thetype = 'short'
	if(thetype == 'int32'):
		thetype = 'int'
	if(thetype == 'int32_t'):
		thetype = 'int'
	if(thetype == 'int64'):
		thetype = 'long'
	if(thetype == 'uint64_t'):
		thetype = 'ulong'
	if(thetype == '_Bool'):
		thetype = 'bool'
	if(thetype == 'char *'):
		thetype = 'string'
	if(thetype == 'char **'):
		thetype = 'string'
	if(thetype == 'void *'):
		thetype = 'IntPtr'
	if(thetype == 'byte *'):
		thetype = 'IntPtr'
	if(thetype == 'uint8 *'):
		thetype = 'IntPtr'
	if(thetype == 'T *'):
		thetype = 'IntPtr'
	if(thetype == 'func_t'):
		thetype = 'IntPtr'
	if(thetype == 'RenderModel_t *'):
		thetype = 'IntPtr'
	if(thetype == 'RenderModel_TextureMap_t *'):
		thetype = 'IntPtr'
	if(thetype == 'struct VkPhysicalDevice_T *'):
		thetype = 'IntPtr'
	if(thetype == 'struct VkInstance_T *'):
		thetype = 'IntPtr'
	if(thetype == 'SteamLeaderboard_t'):
		thetype = 'ulong'
	if(thetype == 'SteamLeaderboardEntries_t'):
		thetype = 'ulong'
	if(thetype == 'ScreenshotHandle'):
		thetype = 'uint'
	if(thetype == 'AudioPlayback_Status'):
		thetype = 'int'
	if(thetype == 'FriendsGroupID_t'):
		thetype = 'char'
	if(thetype == 'EOverlayToStoreFlag'):
		thetype = 'char'
	if(thetype == 'ESteamAPICallFailure'):
		thetype = 'int'
	if(thetype == 'EGamepadTextInputMode'):
		thetype = 'int'
	if(thetype == 'EGamepadTextInputLineMode'):
		thetype = 'int'
	if(thetype == 'EUniverse'):
		thetype = 'int'
	if(thetype == 'ISteamHTMLSurface::EHTMLMouseButton'):
		thetype = 'int'
	if(thetype == 'ISteamHTMLSurface::EHTMLKeyModifiers'):
		thetype = 'int'
	if(thetype == 'SteamInventoryResult_t'):
		thetype = 'int'
	if(thetype == 'RTime32'):
		thetype = 'ulong'
	if(thetype == 'AccountID_t'):
		thetype = 'uint'
	if(thetype == 'AppId_t'):
		thetype = 'uint'
	if(thetype == 'VRComponentProperties'):
		thetype = 'uint'
	if(thetype == 'SteamAPICall_t'):
		thetype = 'ulong'
	if(thetype == 'UGCQueryHandle_t'):
		thetype = 'ulong'
	if(thetype == 'UGCUpdateHandle_t'):
		thetype = 'ulong'
	if(thetype == 'ClientUnifiedMessageHandle'):
		thetype = 'ulong'
	if(thetype == 'UGCFileWriteStreamHandle_t'):
		thetype = 'ulong'
	if(thetype == 'PublishedFileUpdateHandle_t'):
		thetype = 'ulong'
	if(thetype == 'SteamAPIWarningMessageHook_t'):
		thetype = 'IntPtr'
	if(thetype == 'SteamAPI_PostAPIResultInProcess_t'):
		thetype = 'IntPtr'
	if(thetype == 'SteamAPI_CheckCallbackRegistered_t'):
		thetype = 'IntPtr'
	if(thetype == 'class CGameID'):
		thetype = 'ulong'
	if(thetype == 'PublishedFileId_t'):
		thetype = 'ulong'
	if(thetype == 'UGCHandle_t'):
		thetype = 'ulong'
	if(thetype == 'SNetListenSocket_t'):
		thetype = 'uint'
	if(thetype == 'SNetSocket_t'):
		thetype = 'uint'
	if(thetype == 'TrackedDeviceIndex_t'):
		thetype = 'uint'
	if(thetype == 'VROverlayHandle_t'):
		thetype = 'ulong'
	if(thetype == 'PropertyTypeTag_t'):
		thetype = 'uint'
	if(thetype == 'PropertyContainerHandle_t'):
		thetype = 'ulong'
	if(thetype == 'SpatialAnchorHandle_t'):
		thetype = 'uint'
	if(thetype == 'DriverHandle_t'):
		thetype = 'ulong'
	if(thetype == 'VRActionHandle_t'):
		thetype = 'ulong'
	if(thetype == 'VRActionSetHandle_t'):
		thetype = 'ulong'
	if(thetype == 'VRInputValueHandle_t'):
		thetype = 'ulong'
	if(thetype == 'VRInputComponentHandle_t'):
		thetype = 'ulong'
	if(thetype == 'VRInputOriginHandle_t'):
		thetype = 'ulong'
	if(thetype == 'PathHandle_t'):
		thetype = 'ulong'
	if(thetype == 'VRNotificationId'):
		thetype = 'uint'
	if(thetype == 'TextureID_t'):
		thetype = 'int'
	if(thetype == 'WebConsoleHandle_t'):
		thetype = 'ulong'
	if(thetype == 'vrshared_double'):
		thetype = 'double'
	if(thetype == 'vrshared_uint64_t'):
		thetype = 'ulong'

	if(thetype[0:7] == 'struct '):
		thetype = thetype[7:]
	if(thetype[0:6] == 'class '):
		thetype = thetype[6:]
	if(thetype[0:6] == 'union '):
		thetype = thetype[6:]
	if(thetype[0] == 'H' and thetype[0:3] != "Hmd" and thetype[0:16] != "HiddenAreaMesh_t"):
		thetype = 'uint'
	if(thetype[0:5] == 'enum '):
		thetype = thetype[5:]
	if(thetype[len(thetype) - 1] == '*' and thetype[len(thetype) - 2] == '*'):
		thetype = 'IntPtr'
	if(thetype[len(thetype) - 1] == '*'):
		if("VRControllerState_t" not in thetype):
			thetype = converttype(thetypewithnamespace[:len(thetypewithnamespace)-2])
		else:
			thetype = converttype(thetype[:len(thetype)-2])
#		thetype = 'IntPtr'
	if(thetype[len(thetype) - 1] == '&'):
		thetype = 'IntPtr'
	if(thetype[len(thetype) - 1] == ']'):
		thetype = thetype[0:thetype.find('[')-1]
	if(thetype in typedeflist):
		thetype = converttype(typedeflist[thetype])
	if(thetypewithnamespace in typedeflist):
		thetype = converttype(typedeflist[thetypewithnamespace])
	return thetype

def getnamespace(classname):
	if(classname.find('::') != -1):
		return classname[:classname.find('::')]
	else:
		return ''

def getclasswithoutnamespace(classname):
	if(classname.rfind('::') != -1):
		return classname[classname.rfind('::')+2:]
	else:
		return classname

def outputenums(namespace, data):
	for enum in data['enums']:
		if(len(enum) > 0 and len(enum['enumname'])):
			ns = getnamespace(enum['enumname'])
			enumname = getclasswithoutnamespace(enum['enumname'])
			if(ns == namespace or (namespace == '' and ns[:1] == 'I')):
				print('public enum '+enumname+'\n{')
				enumNameWithoutE = enumname
				if( enumname.startswith( "E" ) ):
					enumNameWithoutE = enumname[1:]
				for enumvalue in enum['values']:
					entry = enumvalue['name']
					if(entry.startswith(enumname)): entry = entry[len(enumname):] # strip off enum name
					if(entry.startswith(enumNameWithoutE)): entry = entry[len(enumNameWithoutE):] # strip off enum name
					if(entry.startswith('_')): entry = entry[1:] # strip off leading underscore
					print('\t'+entry+' = '+enumvalue['value']+',')
				print('}')

def outputstructfields(struct, data):

	# recursively add base class fields first
	basename = getclasswithoutnamespace(struct['struct'])
	if basename in structparents:
		parentname = structparents[basename]
		i = structindices[parentname];
		outputstructfields(data['structs'][i], data)

	for enumvalue in struct['fields']:
		fieldtype = enumvalue['fieldtype']
		otype = converttype(fieldtype)
		lastchar = fieldtype[len(fieldtype) - 1]
		if(lastchar == ']'):
			#print('\tpublic fixed '+otype+' '+enumvalue['fieldname']+ fieldtype[fieldtype.find('['):]+';')
			dims = map(int, fieldtype[fieldtype.find('[')+1:-1].split(']['))
			size = reduce(operator.mul, dims, 1)
			utype = unmanagedtype(otype)
			if(otype == 'char'):
				#print('\t[MarshalAs(UnmanagedType.ByValTStr, SizeConst = '+str(size)+')]')
				sys.stdout.write('public byte '+enumvalue['fieldname']+'0')
				for i in range(1, size):
					sys.stdout.write(',' + enumvalue['fieldname'] + str(i))
				print(';')
				
				
				print('public string ' + enumvalue['fieldname'] + '\n{')
				print('get\n{')
				print('return new string(new char[] {')
				for i in range(0, size-1):
					print('(char)' + enumvalue['fieldname'] + str(i) + ',')
				print('(char)' + enumvalue['fieldname'] + str(size-1) + '}).TrimEnd(\'\\0\');')
				print('}')
				print('}')
			else:
				#print('\t[MarshalAs(UnmanagedType.ByValArray, SizeConst = '+str(size)+', ArraySubType = UnmanagedType.'+utype+')]')
				for i in range(size):
					print('\tpublic '+otype+' '+enumvalue['fieldname']+str(i)+';'+(' //'+otype+fieldtype[fieldtype.find('['):] if(i==0) else ''))
		else:
			if(otype == 'bool'): print('\t[MarshalAs(UnmanagedType.I1)]')
			if(lastchar == '*'):
				print('\tpublic IntPtr '+enumvalue['fieldname']+';'+' // '+fieldtype)
			else:
				print('\tpublic '+otype+' '+enumvalue['fieldname']+';')

def outputstructs(namespace, data):
	for struct in data['structs']:
		if(len(struct) > 0 and len(struct['struct'])):
			structname = struct['struct']
			#print('//'+structname)
			ns = getnamespace(structname)
			basename = getclasswithoutnamespace(structname)
			if(basename != '(anonymous)' and (ns == namespace or (namespace == '' and ns[:1] == 'I') or (namespace == '' and ns[:1] == 'C'))):
				for key, value in typedeflist.items():
					if(converttype(value) == basename):
						basename = getclasswithoutnamespace(key)
						break
						
				print('[StructLayout(LayoutKind.Sequential)] public struct '+basename+'\n{')
				outputstructfields(struct, data)

				if (basename == 'HmdMatrix34_t'):
					print('#if UNITY_5_3_OR_NEWER')
					print('\n\tpublic Vector3 GetPosition()')
					print('\t{')
					print('\t\treturn new Vector3(m3, m7, -m11);')
					print('\t}')

					print('\n\tpublic bool IsRotationValid()')
					print('\t{')
					print('\t\treturn ((m2 != 0 || m6 != 0 || m10 != 0) && (m1 != 0 || m5 != 0 || m9 != 0));')
					print('\t}')

					print('\n\tpublic Quaternion GetRotation()')
					print('\t{')
					print('\t\tif (IsRotationValid())')
					print('\t\t{')
					print('\t\t\tfloat w = Mathf.Sqrt(Mathf.Max(0, 1 + m0 + m5 + m10)) / 2;')
					print('\t\t\tfloat x = Mathf.Sqrt(Mathf.Max(0, 1 + m0 - m5 - m10)) / 2;')
					print('\t\t\tfloat y = Mathf.Sqrt(Mathf.Max(0, 1 - m0 + m5 - m10)) / 2;')
					print('\t\t\tfloat z = Mathf.Sqrt(Mathf.Max(0, 1 - m0 - m5 + m10)) / 2;')

					print('\n\t\t\t_copysign(ref x, -m9 - -m6);')
					print('\t\t\t_copysign(ref y, -m2 - -m8);')
					print('\t\t\t_copysign(ref z, m4 - m1);')

					print('\n\t\t\treturn new Quaternion(x, y, z, w);')
					print('\t\t}')

					print('\t\treturn Quaternion.identity;')
					print('\t}')

					print('\n\tprivate static void _copysign(ref float sizeval, float signval)')
					print('\t{')
					print('\t\tif (signval > 0 != sizeval > 0)')
					print('\t\t\tsizeval = -sizeval;')
					print('\t}')
					
					print('#endif')
					print('}')
				else:
					print('}')

					# The following structures were originally compiled with pack(4) on Linux & OSX by mistake. Generate
					# a packed version of the structure so we can workaround this in the C# interop code
					if ((basename == 'RenderModel_t') or 
						(basename == 'VRControllerState_t') or 
						(basename == 'RenderModel_TextureMap_t') or
						(basename == 'VREvent_t')):
						print('// This structure is for backwards binary compatibility on Linux and OSX only')
						print('[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct '+basename+'_Packed\n{')
						outputstructfields(struct, data)
						print('\tpublic '+basename+'_Packed('+basename+' unpacked)');
						print('\t{')
						for enumvalue in struct['fields']:
							fieldtype = enumvalue['fieldtype']
							otype = converttype(fieldtype)
							if fieldtype[-1] == ']':
								dims = map(int, fieldtype[fieldtype.find('[')+1:-1].split(']['))
								size = reduce(operator.mul, dims, 1)
								utype = unmanagedtype(otype)
								for i in range(size):
									print('\t\tthis.'+enumvalue['fieldname']+str(i)+' = unpacked.'+enumvalue['fieldname']+str(i)+';')

							else:
								print('\t\tthis.'+enumvalue['fieldname']+' = unpacked.'+enumvalue['fieldname']+';')
						print('\t}')

						print('\tpublic void Unpack(ref '+basename+' unpacked)');
						print('\t{')
						for enumvalue in struct['fields']:
							fieldtype = enumvalue['fieldtype']
							otype = converttype(fieldtype)
							if fieldtype[-1] == ']':
								dims = map(int, fieldtype[fieldtype.find('[')+1:-1].split(']['))
								size = reduce(operator.mul, dims, 1)
								utype = unmanagedtype(otype)
								for i in range(size):
									print('\t\tunpacked.'+enumvalue['fieldname']+str(i)+' = this.'+enumvalue['fieldname']+str(i)+';')

							else:
								print('\t\tunpacked.'+enumvalue['fieldname']+' = this.'+enumvalue['fieldname']+';')
						print('\t}')
						print('}')


def outputinterfaces(namespace, data):
	lastclass = ''
	lastmethod = ''
	for method in data['methods']:
		if (len(method) > 0):
			returntype = converttype(method['returntype'])
			if(method['returntype'][len(method['returntype']) - 1] == '*'):
				# Native methods which return pointers are cast to IntPtr
				returntype = 'IntPtr'

			methodname = method['methodname']
			if(methodname == lastmethod):
				methodname = methodname + repr(count)
				count = count + 1
			else:
				count = 0
			lastmethod = method['methodname']

			classname = method['classname']

			if(namespace != getnamespace(classname)):
				continue

			classname = getclasswithoutnamespace(classname)
			if(classname != lastclass):
				if(lastclass != ''):
					print("\t}\n");

				print("\t[StructLayout(LayoutKind.Sequential)]")
				print("\tpublic struct " + classname + "\n\t{")
				lastclass = classname


			paramlist = []
			if('params' in method):
				for param in method['params']:
					paramtype = converttype(param['paramtype'])
					if(param['paramtype'][len(param['paramtype']) - 1] == '*' and param['paramtype'][len(param['paramtype']) - 2] == '*'):
						paramlist.append('ref ' + paramtype + ' ' + param['paramname'])
					elif(param['paramtype'][len(param['paramtype']) - 1] == '*'):
						if('out_array_count' in param) or ('array_call' in param) or ('array_count' in param) or ('out_array_call' in param):
							paramlist.append('[In, Out] ' + paramtype + '[] ' + param['paramname'])
						elif('out_string_count' in param):
							paramlist.append('System.Text.StringBuilder ' + param['paramname'])
						elif('out_struct' in param):
							paramlist.append('ref '+ paramtype +' ' + param['paramname'])
						elif('out_string' in param):
							paramlist.append('System.Text.StringBuilder ' + param['paramname'])
#						elif(structlist.has_key(paramtype)):
#							paramlist.append(paramtype+' ' + param['paramname'])
#						elif(paramtype[0:1] == 'I' and paramtype != 'IntPtr'):
#							paramlist.append('IntPtr ' + param['paramname'])
						elif (paramtype == 'uint' or paramtype == 'int' or paramtype == 'char' or paramtype == 'bool'):
							# Output params for ints,uints,char
							paramlist.append('ref ' + paramtype + ' ' + param['paramname'])
						elif (paramtype == 'string' and param['paramtype'] == 'const char *'):
							# Managed strings on Windows need to be converted to Utf8 native ptrs
							paramlist.append('IntPtr ' + param['paramname'])
						elif (paramtype == 'string' or paramtype == 'IntPtr'):
							# Strings and IntPtrs are just straight
							paramlist.append(paramtype + ' ' + param['paramname'])
						else:
#							paramlist.append('ref ' + converttype(paramtype) + ' ' + param['paramname'])
							paramlist.append('ref ' + paramtype + ' ' + param['paramname'])
					else:
						paramlist.append(paramtype + ' ' + param['paramname'])
					if(paramtype == 'bool'):
						paramlist[-1] = '[MarshalAs(UnmanagedType.I1)] ' + paramlist[-1];

			print("\t\t[UnmanagedFunctionPointer(CallingConvention.StdCall)]")
			if(returntype == 'bool'):
				print("\t\t[return: MarshalAs(UnmanagedType.I1)]")
			print("\t\tinternal delegate "+returntype+" _"+methodname+"("+", ".join(paramlist)+");")
			print("\t\t[MarshalAs(UnmanagedType.FunctionPtr)]")
			print("\t\tinternal _"+methodname+" "+methodname+";\n")
	print("\t}\n\n");


def outputfntables(namespace, data):
	lastclass = ''
	lastmethod = ''
	for method in data['methods']:
		if (len(method) > 0):
			returntype = method['returntype']
			if(returntype == 'class CSteamID'):
				returntype = 'uint64'
			methodname = method['methodname']
			if(methodname == lastmethod):
				methodname = methodname + repr(count)
				count = count + 1
			else:
				count = 0
			lastmethod = method['methodname']

			classname = method['classname']

			if(namespace != getnamespace(classname)):
				continue

			classname = getclasswithoutnamespace(classname)
			if(classname != lastclass):
				if(lastclass != ''):
					print("};\n");

				fntablename = method['classname'].replace('vr::', 'VR::').replace('::', '_') + '_FnTable'
				print("struct " + fntablename + "\n{")
				lastclass = classname

			sys.stdout.write ('\t'+ ctype(returntype) + ' (OPENVR_FNTABLE_CALLTYPE *' + methodname + ')')

			paramlist = []
			if('params' in method):
				for param in method['params']:
					paramlist.append(ctype(param['paramtype']) + ' ' + param['paramname'])

			print('('+", ".join(paramlist)+");")

	print("};\n");

def outputfntabledecls(namespace, data):
	lastclass = ''
	lastmethod = ''
	fntablename = ''
	for method in data['methods']:
		if (len(method) > 0):
			returntype = method['returntype']
			if(returntype == 'class CSteamID'):
				returntype = 'uint64'
			methodname = method['methodname']
			if(methodname == lastmethod):
				methodname = methodname + repr(count)
				count = count + 1
			else:
				count = 0
			lastmethod = method['methodname']

			classname = method['classname']

			if(namespace != getnamespace(classname)):
				continue

			# Skip over destructors, we don't use any aside from dummy ones, and
			# destroying our interfaces would be broken anyway.
			if(methodname[:8] == 'Destruct'):
				continue

			classname = getclasswithoutnamespace(classname)
			if(classname != lastclass):
				if(lastclass != ''):
					print("};\n\n");

				fntablename = method['classname'].replace('vr::', 'VR::').replace('::', '_') + '_FnTable'
				print("static " + fntablename + " g_" + fntablename + " =\n{")
				lastclass = classname

			print('\t&' + fntablename + '_' + methodname + ',')

	print("};\n\n");

def outputfntableinit(namespace, data):
	print("extern void *FindInterface( const char *pchInterfaceName );\n")
	print("void InitializeInterfaceFnTables()\n{")
	lastclass = ''
	for method in data['methods']:
		if (len(method) > 0):
			classname = method['classname']

			if(namespace != getnamespace(classname)):
				continue

			classname = getclasswithoutnamespace(classname)
			if(classname != lastclass):
				instancename = 'g_p' + classname
				print("\t" + instancename + " = ( " + namespace + "::" + classname + " * )FindInterface( " + namespace + "::" + classname + "_Version );")
				lastclass = classname
	print("}\n")

def outputfntableaccess(namespace, data):
	lastclass = ''
	for method in data['methods']:
		if (len(method) > 0):
			classname = method['classname']

			if(namespace != getnamespace(classname)):
				continue

			classname = getclasswithoutnamespace(classname)
			if(classname != lastclass):
				fntablename = method['classname'].replace('vr::', 'VR::').replace('::', '_') + '_FnTable'
				print('FnTableRegistration autoreg_'+fntablename+'( '+classname+'_Version, &g_'+fntablename+' );')
				lastclass = classname

def outputfntablefuncs(namespace, data):
	lastclass = ''
	lastmethod = ''
	instancename = ''
	for method in data['methods']:
		if (len(method) > 0):
			returntype = method['returntype']
			if(returntype == 'class CSteamID'):
				returntype = 'uint64'
			methodname = method['methodname']
			if(methodname == lastmethod):
				methodname = methodname + repr(count)
				count = count + 1
			else:
				count = 0
			lastmethod = method['methodname']

			classname = method['classname']

			if(namespace != getnamespace(classname)):
				continue

			# Skip over destructors, we don't use any aside from dummy ones, and
			# destroying our interfaces would be broken anyway.
			if(method['methodname'][:8] == 'Destruct'):
				continue

			classname = getclasswithoutnamespace(classname)
			if(classname != lastclass):
				if(lastclass != ''):
					print("\n\n");

				instancename = 'g_p' + classname
				print("/** " + classname + " FnTable functions */\n")
				print("static " + namespace + "::" + classname + " *" + instancename + " = nullptr;\n")
				lastclass = classname

			creturntype = ctype(returntype)
			sys.stdout.write ('static '+ creturntype + ' OPENVR_FNTABLE_CALLTYPE '+method['classname'].replace('vr::', 'VR::').replace('::', '_') + '_FnTable_' + methodname)
			paramlist = []
			if('params' in method):
				for param in method['params']:
					paramlist.append(ctype(param['paramtype'])+' '+param['paramname'])

			print('('+", ".join(paramlist)+")\n{")

			paramlist = []
			if('params' in method):
				for param in method['params']:
					paramtype = param['paramtype']
					cparamtype = ctype(paramtype)
					if paramtype != cparamtype:
						if paramtype.startswith('struct'):
							paramlist.append('*('+paramtype+'*)&'+param['paramname'])
						else:
							paramlist.append('('+paramtype+')'+param['paramname'])
					else:
						paramlist.append(param['paramname'])

			# if the method is a destructor
			if(method['methodname'][:8] == 'Destruct'):
				sys.stdout.write ('delete instance;')
			# void returntype does not return
			elif (returntype == 'void'):
				sys.stdout.write (instancename+'->'+method['methodname']+'(')
				if('params' in method):
					sys.stdout.write(", ".join(paramlist))
				sys.stdout.write (');')
			elif (creturntype.startswith('struct') and creturntype != returntype):
				sys.stdout.write (returntype+' result = '+instancename+'->'+method['methodname']+'(')
				if('params' in method):
					sys.stdout.write(", ".join(paramlist))
				sys.stdout.write (');\n')
				sys.stdout.write ('return *('+creturntype+'*)&result;')
			else:
				if creturntype != returntype:
					sys.stdout.write ('return ('+creturntype+')'+instancename+'->'+method['methodname']+'(')
				else:
					sys.stdout.write ('return '+instancename+'->'+method['methodname']+'(')
				if('params' in method):
					sys.stdout.write(", ".join(paramlist))
				sys.stdout.write (');')
			sys.stdout.write ('\n}\n');


###############################
# OUTPUT CLASSES
###############################

def isparamptr(paramname, paramlist):
	for param in paramlist:
		if(param['paramname'] == paramname):
			return param['paramtype'][len(param['paramtype']) - 1] == '*'
	

def outputclasses(namespace, data):

	print("""public class Utils
	{
		public static IntPtr ToUtf8(string managedString)
		{
			if (managedString == null)
			{
				return IntPtr.Zero;
			}

			int size = System.Text.Encoding.UTF8.GetByteCount(managedString) + 1;
			if (buffer.Length < size) buffer = new byte[size];
			int written = System.Text.Encoding.UTF8.GetBytes(managedString, 0, managedString.Length, buffer, 0);
			buffer[written] = 0x00; // null terminate
			IntPtr nativeUtf8 = Marshal.AllocHGlobal(written+1);
			Marshal.Copy(buffer, 0, nativeUtf8, written+1);
			return nativeUtf8;
		}
		private static byte[] buffer = new byte[1024];
	}
	""")

	# the following methods take a mispacked VRControllerState_t on Linux and OSX so we generate
	# a special hacky method to account for that on those platforms.
	controller_packed_methods = ['GetControllerState', 'GetControllerStateWithPose', 'GetComponentState']
	event_packed_methods      = ['PollNextEvent', 'PollNextEventWithPose', 'PollNextOverlayEvent', 'PollNextOverlayEventForAny']
	if(namespace == ''):
		namespaceextra = ''
	elif(namespace == 'vr'):
		namespaceextra = 'VR_'
	else:
		namespaceextra = namespace+'_'
	lastclass = ''
	lastmethod = ''
	for method in data['methods']:
		if (len(method) > 0):
			returntype = converttype(method['returntype'])

			interfacename = method['classname']

			if(namespace != getnamespace(interfacename)):
				continue

			interfacename = getclasswithoutnamespace(interfacename)
			methodname = method['methodname']
			if(methodname == lastmethod):
				methodname = methodname + repr(count)
				count = count + 1
			else:
				count = 0
			lastmethod = method['methodname']

			if(interfacename != lastclass):
				if(lastclass != ''):
					print("}\n\n");
				classname = 'C' + interfacename[1:]
				classshort = interfacename[1:]
				print("public class " + classname+"\n{")
				print(interfacename+" FnTable;")
				print("internal " + classname + "(IntPtr pInterface)")
				print("{")
				print("\tFnTable = ("+interfacename+")Marshal.PtrToStructure(pInterface, typeof("+interfacename+"));")
				print("}")

				lastclass = interfacename

			paramlist = []
			# Native params are always ref and include count params
			nativeparamlist = []
			skipparam = ''
			outarray = 0
			outstruct = 0
			twocalls = 0
			skipref = 0
			arraytype = ''
			arrayname = ''
			arrayreplace = ''
			skipcount = ''
			skiptype = ''
			paramtypelist = []
			if('params' in method):
				for param in method['params']:
					paramtype = converttype(param['paramtype'])
					if(param['paramname'] != skipparam):
						if('out_array_count' in param):
							paramlist.append(param['paramname'])
							paramtypelist.append('out ' + paramtype + ' [] ' + param['paramname'])
							nativeparamlist.append(param['paramname'])
							skipparam = param['out_array_count']
							arraytype = paramtype
							arrayname = param['paramname']
							arrayreplace = 'null'
							twocalls = 1
							outarray = 1
							skipref = 1
						elif('out_string_count' in param):
							paramlist.append(param['paramname'])
							paramtypelist.append('out string ' + param['paramname'])
							nativeparamlist.append('pStrBuffer')
							skipparam = param['out_string_count']
							arraytype = paramtype
							arrayname = 'pStrBuffer'
							arrayreplace = 'null'
							twocalls = 1
							skipref = 1
						elif('out_array_call' in param):
							paramlist.append(param['paramname'])
							paramtypelist.append('out ' + paramtype + ' [] ' + param['paramname'])
							nativeparamlist.append(param['paramname'])
							skipparam = param['out_array_call'].split(',')[0]
							arraytype = paramtype
							arrayname = param['paramname']
							arrayreplace = 'null'
							outarray = 1
							skipref = 0
						elif('out_string_count' in param):
							paramlist.append(param['paramname'])
							paramtypelist.append('out ' + paramtype + ' ' + param['paramname'])
							nativeparamlist.append('ref ' + param['paramname'])
							skipparam = param['out_string_count']
						elif('out_struct' in param):
							paramlist.append(param['paramname'])
							paramtypelist.append('out ' + paramtype + ' ' + param['paramname'])
							nativeparamlist.append('ref ' + param['paramname'])
						elif('array_count' in param):
							paramlist.append(param['paramname'])
							paramtypelist.append(paramtype + ' [] ' + param['paramname'])
							nativeparamlist.append(param['paramname'])
							skipparam = param['array_count']
							skipcount = param['paramname']
#						elif(paramtype[0:1] == 'I' and paramtype != 'IntPtr' and not enumlist.has_key(paramtype)):
#							#print("//" + paramtype)
#							paramlist.append(param['paramname'])
#							paramtypelist.append(paramtype + ' ' + param['paramname'])
#							#nativeparamlist.append('ptr')
#							nativeparamlist.append(param['paramname'] + '.GetIntPtr()')
#						elif (structlist.has_key(paramtype)):
#							paramlist.append(' ' + param['paramname'])
#							paramtypelist.append(' ' + paramtype + ' ' + param['paramname'])
#							nativeparamlist.append(' ' + param['paramname'])
						elif (param['paramtype'][len(param['paramtype']) - 1] == '*' and param['paramtype'][len(param['paramtype']) - 2] == '*'):
							paramlist.append('ref ' + param['paramname'])
							paramtypelist.append('ref ' + paramtype + ' ' + param['paramname'])
							nativeparamlist.append('ref ' + param['paramname'])
							if(paramtype != 'uint' and paramtype != 'int' and paramtype != 'char' and paramtype != 'bool'):
								outstruct = 1
								arraytype = paramtype
								arrayname = param['paramname']
								arrayreplace = 'null'
						elif (param['paramtype'][len(param['paramtype']) - 1] == '*' and paramtype != 'string' and paramtype != 'IntPtr'):
							paramlist.append('ref ' + param['paramname'])
							paramtypelist.append('ref ' + paramtype + ' ' + param['paramname'])
							nativeparamlist.append('ref ' + param['paramname'])
							if(paramtype != 'uint' and paramtype != 'int' and paramtype != 'char' and paramtype != 'bool'):
								outstruct = 1
								arraytype = paramtype
								arrayname = param['paramname']
								arrayreplace = 'null'
						elif ('out_string' in param):
							paramlist.append(param['paramname'])
							paramtypelist.append('System.Text.StringBuilder ' + param['paramname'])
							nativeparamlist.append(param['paramname'])
						elif (paramtype == 'string' and param['paramtype'] == 'const char *'):
							paramlist.append(param['paramname'])
							paramtypelist.append(paramtype + ' ' + param['paramname'])
							nativeparamlist.append(param['paramname']+'Utf8')
						else:
							paramlist.append(param['paramname'])
							paramtypelist.append(paramtype + ' ' + param['paramname'])
							nativeparamlist.append(param['paramname'])
					else:
						skiptype = paramtype
						if(skipref):
							nativeparamlist.append('ref ' + param['paramname'])
						elif(skipcount != ''):
							nativeparamlist.append("(" + paramtype +") " + skipcount + ".Length" )
						else:
							nativeparamlist.append(param['paramname'])
						skipparam = 0
			if methodname in controller_packed_methods or methodname in event_packed_methods:
				if methodname in controller_packed_methods:
					packedlist=[w.replace('VRControllerState_t','VRControllerState_t_Packed').replace('string', 'IntPtr') for w in paramtypelist]
				else:
					packedlist=[w.replace('VREvent_t','VREvent_t_Packed') for w in paramtypelist]
				print('// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were ')
				print('// originally mis-compiled with the wrong packing for Linux and OSX.')
				print('[UnmanagedFunctionPointer(CallingConvention.StdCall)]')				
				print('internal delegate '+returntype+' _'+methodname+'Packed('+','.join(packedlist)+');')
				print('[StructLayout(LayoutKind.Explicit)]')
				print('struct '+methodname+'Union\n{')
				print('\t[FieldOffset(0)]\n\tpublic '+interfacename+'._'+methodname+' p'+methodname+';')
				print('\t[FieldOffset(0)]\n\tpublic _'+methodname+'Packed p'+methodname+'Packed;\n}')

			sys.stdout.write ('public '+returntype+' '+methodname+'('+','.join(paramtypelist)+')\n{\n')
	# PROCESS THE STUFF BEFORE THE API CALLS
			if('params' in method):
				for param in method['params']:
					if(skipparam != param['paramname']):
						paramtype = converttype(param['paramtype'])
						if('out_array_count' in param and skipparam != param['out_array_count']):
							skipparam = param['out_array_count']
							sys.stdout.write( '\t'+skiptype+' '+skipparam+' = 0;\n' )
						elif('out_string_count' in param and skipparam != param['out_string_count']):
							skipparam = param['out_string_count']
							#if(isparamptr(skipparam, param)):
							sys.stdout.write( '\t'+skiptype+' '+skipparam+' = 0;\n' )
						elif('out_array_call' in param):
							vals = param['out_array_call'].split(',')
							sys.stdout.write( '\tint '+vals[0]+' = '+vals[1]+' ('+vals[2]+');\n' )
							sys.stdout.write( '\t'+param['paramname']+' = new '+paramtype+'['+vals[0]+'];\n' )
						elif('out_struct' in param):
							sys.stdout.write( '\t'+param['paramname']+' = new '+paramtype+'();\n' )
						elif (param['paramtype'][len(param['paramtype']) - 1] == '*' and (paramtype == 'int' or paramtype == 'uint' or paramtype == 'float' or paramtype == 'long' or paramtype == 'ulong' or paramtype == 'double') and not 'array_count' in param):
							# Out parameters need to be initialized to zero
							sys.stdout.write( '\t'+param['paramname']+' = 0;\n' )
						elif (param['paramtype'][len(param['paramtype']) - 2:] == '**' and (paramtype == 'string')):
							# Out parameters need to be initialized to zero
							sys.stdout.write( '\t'+param['paramname']+' = "";\n' )
						elif (param['paramtype'][len(param['paramtype']) - 1] == '*' and (paramtype == 'char')):
							# Out parameters need to be initialized to zero
							sys.stdout.write( '\t'+param['paramname']+' = (char) 0;\n' )
						elif (param['paramtype'][len(param['paramtype']) - 1] == '*' and (paramtype == 'bool')):
							# Out parameters need to be initialized to zero
							sys.stdout.write( '\t'+param['paramname']+' = false;\n' )
						elif (paramtype == 'string' and param['paramtype'] == 'const char *'):
							# In strings need to be converted to UTF-8
							sys.stdout.write( '\tIntPtr '+param['paramname']+'Utf8 = Utils.ToUtf8('+param['paramname']+');\n')
						#elif(paramtype[0:1] == 'I' and paramtype != 'IntPtr' and not enumlist.has_key(paramtype)):
							# Returning an interface ptr needs ptr defined
							# sys.stdout.write( '\tIntPtr ptr = IntPtr.Zero;\n' )
					

	# PROCESS THE FIRST OPTIONAL API CALL
			if(twocalls):
				paramsnull = ','.join(map((lambda x: (arrayreplace if (x==arrayname) else x)),nativeparamlist))
				sys.stdout.write ('\t'+('' if (returntype=='void') else (returntype+' result = '))+'FnTable.'+methodname+'('+paramsnull+');\n')

	# PROCESS IN BETWEEN THE API CALLS
	# Allocate the array or buffer
			if('params' in method):
				for param in method['params']:
					if('out_array_count' in param):
						sys.stdout.write( '\t'+param['paramname']+'= new ' + converttype(param['paramtype']) + '['+param['out_array_count']+'];\n' )
					if('out_string_count' in param):
						sys.stdout.write( '\tSystem.Text.StringBuilder pStrBuffer = new System.Text.StringBuilder((int)'+skipparam+');\n' )


	# PROCESS THE FINAL API CALL
			if methodname in controller_packed_methods:
				packedparamlist = [w.replace('pControllerState','state_packed')
								    .replace('unControllerStateSize','(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t_Packed))')
									for w in nativeparamlist]

				print('#if !UNITY_METRO')
				print('\tif ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) ||')
				print('\t    (System.Environment.OSVersion.Platform == System.PlatformID.Unix))')
				print('\t{')
				print('\t\t'+methodname+'Union u;')
				print('\t\tVRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState);')
				print('\t\tu.p'+methodname+'Packed = null;')
				print('\t\tu.p'+methodname+' = FnTable.'+methodname+';')
				print('\t\t'+returntype+' packed_result = u.p'+methodname+'Packed('+','.join(packedparamlist)+');\n')
				print('\t\tstate_packed.Unpack(ref pControllerState);')
				print('\t\treturn packed_result;')
				print('\t}')
				print('#endif')
			if methodname in event_packed_methods:
				packedparamlist = [w.replace('pEvent','event_packed')
									.replace('uncbVREvent','(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t_Packed))')
									for w in nativeparamlist]

				print('#if !UNITY_METRO')
				print('\tif ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) ||')
				print('\t    (System.Environment.OSVersion.Platform == System.PlatformID.Unix))')
				print('\t{')
				print('\t\t'+methodname+'Union u;')
				print('\t\tVREvent_t_Packed event_packed = new VREvent_t_Packed();')
				print('\t\tu.p'+methodname+'Packed = null;')
				print('\t\tu.p'+methodname+' = FnTable.'+methodname+';')
				print('\t\t'+returntype+' packed_result = u.p'+methodname+'Packed('+','.join(packedparamlist)+');\n')
				print('\t\tevent_packed.Unpack(ref pEvent);')
				print('\t\treturn packed_result;')
				print('\t}')
				print('#endif')


			savereturn = returntype
			if(method['returntype'][len(method['returntype']) - 1] == '*'):
				returntype = 'IntPtr'
			if(returntype == 'void'):
				if(len(nativeparamlist) > 0):
					sys.stdout.write ('\tFnTable.'+methodname+'('+','.join(nativeparamlist)+');\n')
				else:
					sys.stdout.write ('\tFnTable.'+methodname+'();\n')
			else:
				if(len(nativeparamlist) > 0):
					#if(returntype[0:1] == 'I' and returntype != 'IntPtr'):
					#	sys.stdout.write ('\tC'+returntype[1:]+' result = new C'+returntype[1:]+'(FnTable.'+methodname+'('+','.join(nativeparamlist)+'));\n')
					if(returntype == 'string'):
						sys.stdout.write ('\tstring result = Marshal.PtrToStringAuto(FnTable.'+methodname+'('+','.join(nativeparamlist)+'));\n')
					else:
						sys.stdout.write ('\t'+('' if twocalls else returntype)+' result = FnTable.'+methodname+'('+','.join(nativeparamlist)+');\n')
				else:
					if(returntype == 'string'):
						sys.stdout.write ('\tstring result = Marshal.PtrToStringAuto(FnTable.'+methodname+'());\n')
					else:
						sys.stdout.write ('\t'+('' if twocalls else returntype)+' result = FnTable.'+methodname+'();\n')


	# PROCESS AFTER THE API CALL
			if('params' in method):
				for param in method['params']:
					paramtype = converttype(param['paramtype'])
					if('out_string_count' in param):
						sys.stdout.write( '\t'+param['paramname']+'  = pStrBuffer.ToString();\n' )
					elif (paramtype == 'string' and param['paramtype'] == 'const char *'):
						sys.stdout.write( '\tMarshal.FreeHGlobal('+param['paramname']+'Utf8);\n')
					#elif(paramtype[0:1] == 'I' and paramtype != 'IntPtr' and not enumlist.has_key(paramtype)):
						# Interface. Need to construct a class wrapper
						#sys.stdout.write( '\t'+param['paramname']+'= new C' + paramtype[1:] + '(ptr);\n' )
		
			if(method['returntype'][len(method['returntype']) - 1] == '*'):
				if(savereturn == 'string'):
					sys.stdout.write ('\treturn Marshal.PtrToStringAnsi(result);\n')
				else:
					sys.stdout.write ('\treturn ('+savereturn+') Marshal.PtrToStructure(result, typeof('+savereturn+'));\n')
			elif(returntype != 'void'):
				sys.stdout.write ('\treturn result;\n')
			sys.stdout.write ('}\n')