/*
 * Copyright (c), 2009 Sigbjorn Finne <sof@forkIO.com>
 *
 * The HsDelegateGen class handles the creation of wrapper types 
 * for native function pointers (hiding pure Haskell code..honest!)
 * 
 * Uses System.Reflection.Emit
 *
 */
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;

// type synonym, C# style.
using  TypePair = Pair<System.Type,System.Type>;

namespace HsInvoker {

[ComVisible(false)]
public class HsDelegateGen {
 private static ModuleBuilder    m_moduleBuilder;
 private static AssemblyBuilder  m_aBuilder;
 private static int m_uniq;
 private static String    m_dynName = "HsNetBridgeDynAssembly";
 private static String    m_modName = "HsNetBridgeDynModule";
 private static String    m_typeName = "DynDelegator";
 private static String    m_dllName;

 private static Dictionary<String,TypePair> m_tyMap;

 static HsDelegateGen() { 
   m_uniq = 0; 
   m_moduleBuilder=null; 
   m_aBuilder = null;
   m_dllName = null;
   // enable when debugging generated IL:
   // m_dllName = "DynNetBridgeDbg.dll";
 }
 
 
  //
  // Method: LookupDelegateType(String) 
  //
  // By maintaining a map from the type signature of the
  // delegate types generated, to their actual implementation,
  // sharing is straightforward to implement.
  //
  // LookupDelegateType() takes the signature string as argument and returns
  // the corresponding TypePair, if any.
  //
 public static TypePair LookupDelegateType(String s) {
   if ( m_tyMap==null ) {
      m_tyMap = new Dictionary<String,TypePair>();
   }
   if ( m_tyMap.ContainsKey(s) ) {
     return m_tyMap[s];
   } else {
     return null;
   }
 }
 
  //
  // Method: AddDelegateType(String,TypePair)
  //
  // For a newly generated delegator type, extend the map
  // associating its method/type signature with the new types.
  //
 public static void AddDelegateType(String s, TypePair p) {
   if ( m_tyMap==null ) {
      m_tyMap = new Dictionary<String,TypePair>();
   }
   m_tyMap[s] = p;
 } 
 
 //
 // Define a new unique dynamic type for a delegate, reusing
 // types already generated if at all possible. 
 //
 // Called by the interop layer when wrapping up Haskell function values.
 // 
 public static Object DefineDelegate(Type   delType,
				     String methodName,
				     IntPtr ffiPtr) {

#if false
   if ( delType.IsSubclassOf( typeof(System.MulticastDelegate) ) {
     try {
       Object nDel = Marshal.GetDelegateForFunctionPointer(ffiPtr, delType);
       return nDel;
     } catch (Exception e) {
       Console.WriteLine("DefineDelegate: {0}", e);
       return e;
     }
   }
#endif
   /* Set up dynamic assembly, so as to have a place to emit the new type into */
   CreateDynAssembly();

   String theTypeName = m_typeName;
   String tyStr= "";
   Type resTy = null;
   ParameterInfo[] ps = GetParamTypes(delType, ref resTy);

   Type[] ts = new Type[ps.Length];
   int i = 0;
   Type delTy;
   Type dTy;
   TypePair genPair;

   /* Construct a signature string, <res_ty>=[arg]+, which is used
    * to have isomorphic delegators (i.e., same function-pointer signature)
    * share the underlying, dynamic class. Essential to make this
    * dynamic-delegate story of practical use.
    */
   if ( resTy!=null ) {
     tyStr = resTy.ToString() + "=";
   }
    
   for(i=0;i<ps.Length;i++) {
     ts[i] = ps[i].ParameterType;
     tyStr = tyStr + ts[i].ToString();
   }
    
   // check if we can reuse an already generated type...
   if ( (genPair = LookupDelegateType(tyStr)) != null ) {
      // delTy: the type of the inner delegate type that wraps the native
      // function pointer.
      // dTy: main delegate type, constructor is parameterized over
      // the wrapped native function pointer.
      // 
     delTy = genPair.Fst;
     dTy   = genPair.Snd;
   } else {
       // create the new MulticastDelegate-derived type + fill it
       // in with constructor + method implementations (all taken
       // care of by the GenerateDelWrapper() below.)
     TypeBuilder typeBuilder = GenType(theTypeName,TypeAttributes.Public);
     delTy = GenerateDelWrapper(typeBuilder,"InnerDelegator", "InvokeMe", ts, resTy);

       // All ready, instantiate it
     dTy   = typeBuilder.CreateType();
     AddDelegateType(tyStr,new TypePair(delTy,dTy));
     PersistAssembly();
   }
   try {
     //Console.WriteLine("DefineDelegate::DelTy {0} {1} {2}",ffiPtr.ToString("X"), delTy, dTy);
     Object delIt = Marshal.GetDelegateForFunctionPointer(ffiPtr,delTy);
     Object wrObj = System.Activator.CreateInstance(dTy,new Object[]{delIt});

#if false
     // debugging generically typed delegates..
     ts    = dTy.GetGenericArguments();
     for(i=0;i<ts.Length;i++) {
       Console.WriteLine("gen arg {0} {1}", i, ts[i]);
     }
     ts = delTy.GetGenericArguments();
     for(i=0;i<ts.Length;i++) {
       Console.WriteLine("gen-arg {0} {1}", i, ts[i]);
     }
#endif
      // ..and with all that taken care of, create the delegate
      // to the InvokeMe() method for the 'wrObj' instance.
     MethodInfo mi1 = wrObj.GetType().GetMethod("InvokeMe", BindingFlags.Public | BindingFlags.Instance);
     return Delegate.CreateDelegate(delType,wrObj,mi1,false);
   } catch (Exception e) {
     Logger.Debug("DefineDelegate::CreateInstance: exception raised - {0}",e);
     throw(e);
   }
 }

  //
  // Method: GenerateDelWrapper()
  //
  // Handles the creation of the delegate types needed to wrap
  // up the native function pointer. One additional wrinkle is
  // that the native function pointer may also take arguments
  // to .NET objects. To correctly handle those we need to
  // inject custom attributes to force the interop layer to
  // unwrap those arguments prior to calling the function pointer.
  //
 private static Type GenerateDelWrapper( TypeBuilder typeBuilder
				       , String typeName
				       , String methodName
				       , Type[] paramTypes
				       , Type   resTy
				       ) {

  Type[] paramTypesInner;
  int i=0;
  
  TypeAttributes tAttrs = 
    TypeAttributes.Class  | 
    TypeAttributes.Sealed |
    TypeAttributes.NestedAssembly |
    TypeAttributes.AnsiClass |  
    TypeAttributes.AutoClass;

  TypeBuilder typeBuilderDel = 
    typeBuilder.DefineNestedType( typeName
				, tAttrs
				, typeof(System.MulticastDelegate)
				);

   ConstructorBuilder constructorBuilder = 
      typeBuilderDel.DefineConstructor( MethodAttributes.RTSpecialName | 
					MethodAttributes.HideBySig |
					MethodAttributes.Public
				      , CallingConventions.Standard
				      , new Type[]{typeof(System.Object), typeof(System.IntPtr)}
				      );
   constructorBuilder.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);

   paramTypesInner = new Type[paramTypes.Length + 1];
   paramTypesInner[0] = typeof(System.Object);
   for (i=0;i<paramTypes.Length;i++) {
       if ( !paramTypes[i].IsPrimitive ) {
	 paramTypesInner[i+1] = typeof(System.Object);
       } else {
	 paramTypesInner[i+1] = paramTypes[i];
       }
   }

   MethodBuilder methodBuilder = 
      typeBuilderDel.DefineMethod("Invoke", 
				  MethodAttributes.Public | 
				  MethodAttributes.HideBySig | 
				  MethodAttributes.NewSlot | 
				  MethodAttributes.Virtual,
				  resTy, paramTypesInner);
   methodBuilder.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);
   
   for(i=0;i<paramTypesInner.Length+1;i++) {
      /* param 0 is the result */
     Type pTy = ( (i == 0) ? resTy : paramTypesInner[i-1]);
     if ( !pTy.IsPrimitive ) {
       ParameterBuilder pb = methodBuilder.DefineParameter(i, ParameterAttributes.None, null);
       ConstructorInfo ci  = typeof(MarshalAsAttribute).GetConstructor(new Type[]{ typeof(UnmanagedType) });
       UnmanagedType uv = UnmanagedType.IUnknown;
       if ( pTy == typeof(System.String) ) {
	 uv = UnmanagedType.LPStr;
       }
       CustomAttributeBuilder cb = new CustomAttributeBuilder(ci,new Object[]{uv});
       pb.SetCustomAttribute(cb);
     }
   }

   Type delTy = typeBuilderDel.CreateType();
   FieldBuilder fieldBuilderCB = typeBuilder.DefineField(String.Concat("m_cb"),typeBuilderDel,FieldAttributes.Private);

   constructorBuilder = 
     typeBuilder.DefineConstructor(MethodAttributes.Public,
				   CallingConventions.Standard,
				   new Type[]{typeBuilderDel});
   ILGenerator ilGenerator = constructorBuilder.GetILGenerator();
   // Call the base constructor -- required?
   ilGenerator.Emit(OpCodes.Ldarg_0);
   Type[] ctor_args = new Type[0];
   ilGenerator.Emit(OpCodes.Call,
		    typeof(System.Object).GetConstructor(ctor_args));
   ilGenerator.Emit(OpCodes.Ldarg_0);
   ilGenerator.Emit(OpCodes.Ldarg_1);
   ilGenerator.Emit(OpCodes.Stfld, fieldBuilderCB);
   ilGenerator.Emit(OpCodes.Ret);

   // Build the delegator method which calls back into Haskell.
   MethodBuilder delegator =
     typeBuilder.DefineMethod(methodName,
			      MethodAttributes.Public,
			      CallingConventions.Standard,
			      resTy,
			      paramTypes);
   ILGenerator delIl = delegator.GetILGenerator();
   Type[] ts = new Type[]{ typeof(System.String), typeof(System.Object)};

#if false
   MethodInfo mi = typeof(System.Console).GetMethod("WriteLine",ts);
   delIl.Emit(OpCodes.Ldstr,"XX: {0}");
   delIl.Emit(OpCodes.Ldarg_0);
   delIl.EmitCall(OpCodes.Call,mi,ts);
#endif

   delIl.Emit(OpCodes.Ldarg_0);
   delIl.Emit(OpCodes.Ldfld,fieldBuilderCB);
   delIl.Emit(OpCodes.Ldarg_0);
   for(i=0; i < paramTypes.Length; i++) {
     delIl.Emit(OpCodes.Ldarg,(short)i+1);
   }
   delIl.Emit(OpCodes.Callvirt,methodBuilder);
   delIl.Emit(OpCodes.Ret);

   return delTy;
 }

 private static void PersistAssembly() {
     if ( m_dllName!=null && m_dllName != "" ) {
       Console.WriteLine("Saving: {0}", m_dllName);
       try {
	 m_aBuilder.Save(m_dllName);
       } catch (Exception e) {
	 Console.WriteLine("Failed to save {0}..ignoring", m_dllName);
	 Console.WriteLine("{0}", e);
       }
     }
 }

 private static void CreateDynAssembly() {
   if ( m_tyMap==null ) {
      m_tyMap = new Dictionary<String,Pair<Type,Type>>();
   }
   if ( m_aBuilder==null ) {
     InitDynAssembly();
   }
 }
 
 private static void InitDynAssembly() {
   AssemblyName aName = new AssemblyName();
   aName.Name         = m_dynName;
   AppDomain aDom     = System.Threading.Thread.GetDomain();
   bool saveDll       = m_dllName!=null && m_dllName != "";
   
   m_aBuilder = aDom.DefineDynamicAssembly(aName,( saveDll ? AssemblyBuilderAccess.RunAndSave : AssemblyBuilderAccess.Run));
   if ( saveDll ) {     
     m_moduleBuilder = m_aBuilder.DefineDynamicModule(m_modName, m_dllName, true);
   } else {
     m_moduleBuilder = m_aBuilder.DefineDynamicModule(m_modName);
   }
 }

 private static void ResetGenAssembly(String dllName) {
    if ( m_dllName!=null ) {
	m_aBuilder.Save(m_dllName);
    }
    m_dllName = dllName;
    m_aBuilder=null;
 }

 private static TypeBuilder GenType(String ty, TypeAttributes attrs) {
   TypeBuilder typeBuilder;
   String theTypeName = ty;

   while (true) {
     try {
       //       Console.WriteLine("Attempting to create type {0}..",theTypeName);
       typeBuilder = m_moduleBuilder.DefineType(theTypeName, attrs);
       break;
     } catch (ArgumentException) {
       m_uniq++;
       theTypeName = String.Format("{0}{1}",m_typeName,m_uniq);
     }
   }
   //   Console.WriteLine("Succeeded creating {0} type", theTypeName);
   return typeBuilder;
 }

 private static ParameterInfo[] GetParamTypes(Type delTy, ref Type resTy) {
  if ( delTy.IsSubclassOf(typeof(System.Delegate)) ) {
     MethodInfo mi = delTy.GetMethod("Invoke");
     resTy = mi.ReturnType;
     return mi.GetParameters();
  } else {
     resTy = null;
     return new ParameterInfo[0];
  }
 
 }

};

} /* namespace */