//===------ CLIJitMeta.cpp - CLI class/method/field operators -------------===//
//
//                              N3
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include <stdarg.h>

#include "llvm/ExecutionEngine/GenericValue.h"
#include "llvm/GlobalVariable.h"
#include "llvm/LLVMContext.h"

#include "types.h"

#include "mvm/JIT.h"

#include "CLIAccess.h"
#include "CLIJit.h"
#include "CLIString.h"
#include "N3.h"
#include "VMClass.h"
#include "VMObject.h"
#include "VMThread.h"

using namespace n3;
using namespace llvm;

// TODO: MUST CHECK the type!
//		if (llvm::isa<check>(signature->naturalType)) {									 
//		if (signature->naturalType == Type::getFloatTy(getGlobalContext())) {

#define IMPLEMENTS_VMFIELD_ASSESSORS(name, type, do_root)								\
	void VMField::set##name(VMObject* obj, type val) {										\
		llvm_gcroot(obj, 0);																								\
		do_root(val, 0);																										\
																																				\
		if (classDef->status < ready)																				\
			classDef->resolveType(true, true, NULL);													\
																																				\
		*(type*)((char *)obj + ptrOffset) = val;														\
																																				\
		return;																															\
	}																																			\
																																				\
	type VMField::get##name(VMObject* obj) {															\
		llvm_gcroot(obj, 0);																								\
		if (classDef->status < ready)																				\
			classDef->resolveType(true, true, NULL);													\
																																				\
		type res;																														\
		do_root(res, 0);																										\
		res = *(type *)((char *)obj + ptrOffset);														\
		return res;																													\
	}

ON_TYPES(IMPLEMENTS_VMFIELD_ASSESSORS, _F_NTR)

#undef IMPLEMENTS_VMFIELD_ASSESSORS

GenericValue VMMethod::invokeGeneric(std::vector<llvm::GenericValue>& args) {																		
	// at this step, we must not launch the gc because objects arguments are somewhere in the stack a copying collector
	// can not know where they are
	assert(code);									// compiling a method can trigger a gc
	return mvm::MvmModule::executionEngine->runFunction(methPtr, args);
}

GenericValue VMMethod::invokeGeneric(va_list ap) {																		
	Function* func = methPtr;																						
	std::vector<GenericValue> args;																			
	for (Function::arg_iterator i = func->arg_begin(), e = func->arg_end();	
			 i != e; ++i) {																									
		const Type* cur = i->getType();																		
		if (cur == Type::getInt8Ty(getGlobalContext())) {									
			GenericValue gv;																								
			gv.IntVal = APInt(8, va_arg(ap, int));													
			args.push_back(gv);																							
		} else if (cur == Type::getInt16Ty(getGlobalContext())) {					
			GenericValue gv;																								
			gv.IntVal = APInt(16, va_arg(ap, int));													
			args.push_back(gv);																							
		} else if (cur == Type::getInt32Ty(getGlobalContext())) {					
			GenericValue gv;																								
			gv.IntVal = APInt(32, va_arg(ap, int));													
			args.push_back(gv);																							
		} else if (cur == Type::getInt64Ty(getGlobalContext())) {					
			GenericValue gv1;																								
			gv1.IntVal = APInt(64, va_arg(ap, uint64));											
			args.push_back(gv1);																						
		} else if (cur == Type::getDoubleTy(getGlobalContext())) {				
			GenericValue gv1;																								
			gv1.DoubleVal = va_arg(ap, double);															
			args.push_back(gv1);																						
		} else if (cur == Type::getFloatTy(getGlobalContext())) {					
			GenericValue gv;																								
			gv.FloatVal = (float)(va_arg(ap, double));											
			args.push_back(gv);																							
		} else {																													
			GenericValue gv(va_arg(ap, VMObject*));													
			args.push_back(gv);																							
		}																																	
	}																																		
	
	return invokeGeneric(args);
}

GenericValue VMMethod::invokeGeneric(...) {
	va_list ap;
	va_start(ap, this);
	GenericValue res = invokeGeneric(ap);
	va_end(ap);
	return res;
}

#define DEFINE_INVOKE(name, type, extractor)														\
	type VMMethod::invoke##name(...) {																		\
		va_list ap;																													\
		va_start(ap, this);																									\
		GenericValue res = invokeGeneric(ap);																\
		va_end(ap);																													\
		return (type)res.extractor;																					\
	}

ON_TYPES(DEFINE_INVOKE, _F_NTE)

#undef DEFINE_INVOKE

#define DEFINE_INVOKE_VOID(name, type, extractor)	\
	type VMMethod::invoke##name(...) {																		\
		va_list ap;																													\
		va_start(ap, this);																									\
		invokeGeneric(ap);																									\
		va_end(ap);																													\
	}

ON_VOID(DEFINE_INVOKE_VOID, _F_NTE)

#undef DEFINE_INVOKE_VOID


// // mettre en param un Function *
// // materializeFunction avant
// GenericValue VMMethod::operator()(va_list ap) {
  
//   if (classDef->status < ready) 
//     classDef->resolveType(true, true, NULL);
  
//   Function* func = compiledPtr(NULL);
  
//   std::vector<GenericValue> args;
//   for (Function::arg_iterator i = func->arg_begin(), e = func->arg_end();
//        i != e; ++i) {
//     const Type* type = i->getType();
//     if (type == Type::getInt8Ty(getGlobalContext())) {
//       GenericValue gv;
//       gv.IntVal = APInt(8, va_arg(ap, int));
//       args.push_back(gv);
//     } else if (type == Type::getInt16Ty(getGlobalContext())) {
//       GenericValue gv;
//       gv.IntVal = APInt(16, va_arg(ap, int));
//       args.push_back(gv);
//     } else if (type == Type::getInt32Ty(getGlobalContext())) {
//       GenericValue gv;
//       gv.IntVal = APInt(32, va_arg(ap, int));
//       args.push_back(gv);
//     } else if (type == Type::getInt64Ty(getGlobalContext())) {
//       GenericValue gv1;
//       gv1.IntVal = APInt(64, va_arg(ap, uint64));
//       args.push_back(gv1);
//     } else if (type == Type::getDoubleTy(getGlobalContext())) { 
//       GenericValue gv1;
//       gv1.DoubleVal = va_arg(ap, double);
//       args.push_back(gv1);
//     } else if (type == Type::getFloatTy(getGlobalContext())) {
//       GenericValue gv;
//       gv.FloatVal = (float)(va_arg(ap, double));
//       args.push_back(gv);
//     } else {
//       GenericValue gv(va_arg(ap, VMObject*));
//       args.push_back(gv);
//     }
//   }
  
//   return mvm::MvmModule::executionEngine->runFunction(func, args);
// }

// GenericValue VMMethod::operator()(VMObject* obj, va_list ap) {
  
//   if (classDef->status < ready) 
//     classDef->resolveType(true, true, NULL);
  
//   Function* func = compiledPtr(NULL);
  
//   std::vector<GenericValue> args;
//   GenericValue object(obj);
//   args.push_back(object);

//   for (Function::arg_iterator i = ++(func->arg_begin()), e = func->arg_end();
//        i != e; ++i) {
//     const Type* type = i->getType();
//     if (type == Type::getInt8Ty(getGlobalContext())) {
//       GenericValue gv;
//       gv.IntVal = APInt(8, va_arg(ap, int));
//       args.push_back(gv);
//     } else if (type == Type::getInt16Ty(getGlobalContext())) {
//       GenericValue gv;
//       gv.IntVal = APInt(16, va_arg(ap, int));
//       args.push_back(gv);
//     } else if (type == Type::getInt32Ty(getGlobalContext())) {
//       GenericValue gv;
//       gv.IntVal = APInt(32, va_arg(ap, int));
//       args.push_back(gv);
//     } else if (type == Type::getInt64Ty(getGlobalContext())) {
//       GenericValue gv1;
//       gv1.IntVal = APInt(64, va_arg(ap, uint64));
//       args.push_back(gv1);
//     } else if (type == Type::getDoubleTy(getGlobalContext())) { 
//       GenericValue gv1;
//       gv1.DoubleVal = va_arg(ap, double);
//       args.push_back(gv1);
//     } else if (type == Type::getFloatTy(getGlobalContext())) {
//       GenericValue gv;
//       gv.FloatVal = (float)(va_arg(ap, double));
//       args.push_back(gv);
//     } else {
//       GenericValue gv(va_arg(ap, VMObject*));
//       args.push_back(gv);
//     }
//   }
      
//   return mvm::MvmModule::executionEngine->runFunction(func, args);
// }


// GenericValue VMMethod::operator()(...) {
//   va_list ap;
//   va_start(ap, this);
//   GenericValue ret = (*this)(ap);
//   va_end(ap);
//   return  ret;
// }

// GenericValue VMMethod::run(...) {
//   va_list ap;
//   va_start(ap, this);
//   GenericValue ret = (*this)(ap);
//   va_end(ap);
//   return  ret;
// }

// GenericValue VMMethod::operator()(std::vector<GenericValue>& args) {
  
//   if (classDef->status < ready) 
//     classDef->resolveType(true, true, NULL);
  
//   Function* func = compiledPtr(NULL);
//   return mvm::MvmModule::executionEngine->runFunction(func, args);
// }

GlobalVariable* VMCommonClass::llvmVar() {
  if (!_llvmVar) {
    aquire();
    if (!_llvmVar) {
      Module* Mod = vm->getLLVMModule();
      const Type* pty = PointerType::getUnqual(Type::getInt8Ty(getGlobalContext()));
      Constant* cons = 
        ConstantExpr::getIntToPtr(ConstantInt::get(Type::getInt64Ty(getGlobalContext()), uint64_t (this)),
                                    pty);

      _llvmVar = new GlobalVariable(*Mod, pty, true,
                                    GlobalValue::ExternalLinkage,
                                    cons, "");
    
    }
    release();
  }
  return _llvmVar;
}

GlobalVariable* VMField::llvmVar() {
  if (!_llvmVar) {
    classDef->aquire();
    if (!_llvmVar) {
      const Type* pty = PointerType::getUnqual(Type::getInt8Ty(getGlobalContext()));
      Module* Mod = classDef->vm->getLLVMModule();
      Constant* cons = 
        ConstantExpr::getIntToPtr(ConstantInt::get(Type::getInt64Ty(getGlobalContext()), uint64_t (this)),
                                  pty);

      _llvmVar = new GlobalVariable(*Mod, pty, true,
                                    GlobalValue::ExternalLinkage,
                                    cons, "");
    }
    classDef->release();
  }
  return _llvmVar;
}

GlobalVariable* VMMethod::llvmVar() {
  if (!_llvmVar) {
    classDef->aquire();
    if (!_llvmVar) {
      Module* Mod = classDef->vm->getLLVMModule();
      const Type* pty = PointerType::getUnqual(Type::getInt8Ty(getGlobalContext()));
      Constant* cons = 
        ConstantExpr::getIntToPtr(ConstantInt::get(Type::getInt64Ty(getGlobalContext()), uint64_t (this)),
                                  pty);

      _llvmVar = new GlobalVariable(*Mod, pty, true,
                                    GlobalValue::ExternalLinkage,
                                    cons, "");
    
    }
    classDef->release();
  }
  return _llvmVar;
}

Constant* VMObject::classOffset() {
  return VMThread::get()->getVM()->module->constantOne;
}