// 
// Copyright (c), 2009 Sigbjorn Finne <sof@forkIO.com>
//
// Class:   InvokeBridge
// 
// Purpose: Collection of (static) methods for dynamically creating
//          objects and accessing methods/fields on them. 
//
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
using System.Globalization;

[assembly:AssemblyVersion("0.4.0.0")]
[assembly:AssemblyCulture("")]
namespace HsInvoker {


//
// NOTE: if you change the method signatures and/or add
// to the interface, the IID of the interface will change
// when exporting its COM interface. This will have to be
// accounted for in InvokerClient.h, or you will scratch your
// head for quite a while..
[ClassInterface(ClassInterfaceType.AutoDual),
GuidAttribute("39D497D9-60E0-3525-B7F2-7BC096D3A2A3"),
ComVisible(true)
]
public class HsInvokeBridge2 {

  protected Dictionary<String,AssemblyName> m_assemblies;
  protected Dictionary<String,ArrayList> m_assemblyNames;

  public HsInvokeBridge2() {
    m_assemblies    = new Dictionary<String,AssemblyName>();
    m_assemblyNames = new Dictionary<String,ArrayList>();
    Assembly corAss = Assembly.Load("mscorlib.dll"); 
    
    m_assemblies.Add(corAss.Location,corAss.GetName());
    AddAssemblyMapping("System", corAss.GetName());
  }
  
  //
  // Method: CreateObject(String* assemName, String* objSpec, Object* args[])
  //
  // Purpose: Given a fully qualified name of a class/type, try
  //          to create an instance of it. Make sure the fresh instance
   //         isn't unboxed or otherwise transformed by fixing its PInvoke type
  //          to an interface pointer.
  [return:MarshalAs( UnmanagedType.Interface ) ]
  public object CreateObject(String assemName,
		             String objSpec,
		             object[] args) {

    Object instance = null;
    // Unravel the name of the class/type.
    TypeName typeName = TypeName.ParseType(objSpec);
  
    if (assemName != null && assemName.Length > 0) {
       typeName.m_assembly = assemName;
    }

    // Try creating the instance..
    try {
	instance = CreateInstance(typeName,args);
    } catch (Exception e) {
      Logger.Debug("Unable to create instance '{0}' {1} {2} {3}", objSpec, e,typeName,args.Length);
      throw(e);
    }
    if ( instance == null ) {
      Logger.Debug("Unable to create instance '{0}' {1} {2}", objSpec,typeName,args.Length);
    }
    return instance;
  }
  

   //
   // Method: FindMethod
   //
   // Reliably resolve a type's method by name and argument types + 
   // the types the (generic) method is parameterized over.
   //
   public static MethodInfo FindMethod(Type type,
				       String methName,
				       BindingFlags flgs,
				       Binder bndr,
				       Type[] typeArgs,
				       Type[] paramTypes) {
     MethodInfo mi = null;

     if ( paramTypes == null ) {
       mi = type.GetMethod(methName, flgs);
       if ( mi != null && typeArgs != null && typeArgs.Length > 0 ) {
	 return mi.MakeGenericMethod(typeArgs);
       } else if ( mi != null ) {
	 return mi;
       }
     }
     mi = type.GetMethod(methName, flgs, bndr, paramTypes, null);
     if ( mi != null ) {
       return mi;
     }

      /* Don't give up just yet..it might be overloaded and generic..spin through methods ourselves.. */
     foreach(MethodInfo mmi in type.GetMethods(flgs)) { // int i=0;i<ms.Length;i++) {
       if (mmi.Name != methName) { continue; }
       try {
	// Instantiate the open generic method
       MethodInfo closedMethod = mmi;
       if ( typeArgs != null && typeArgs.Length > 0 ) {
	 Type[] ts = closedMethod.GetGenericArguments();
//	 Console.WriteLine("Instant: {0} {1} {2} {3} {4}", closedMethod, ( ts != null ? 0 : ts.Length), typeArgs.Length, type.ContainsGenericParameters, closedMethod.ContainsGenericParameters);
	 try {
  	 closedMethod = closedMethod.MakeGenericMethod(typeArgs);
	 } catch(Exception) {
//	   Console.WriteLine("MakeGen: {0}", e);
	   continue;
	 }
       }
       ParameterInfo[] ps = closedMethod.GetParameters();
	// left-to-right matching, should reuse the HsBinder method here. ToDo.
       if (ps.Length == paramTypes.Length) {
         bool doneFor = true;
	 for (int p = 0; p < ps.Length; p++) {
	   if ( !ps[p].ParameterType.IsAssignableFrom(paramTypes[p]) ) {
	     doneFor=false;
	     break; // this is not the method we're looking for
	   }
	 }
	 if (doneFor) {
	   // if we're here, we got the right method
	   return closedMethod;
	 }
       }
       } catch (Exception) {
          continue;
       }
     }
     return null;
   }

  //
  // Method:  InvokeMethod
  // 
  // Purpose: Given a pointer to an already created object, look up
  //          one of its method. If found, invoke the method passing it
  //          'args' as arguments.
  //
  // Comments: the format of the method-spec is "methodName(type1,..,typeN)" [N>=0]
  //
  public Object InvokeMethod(Object   obj, 
			     String   methName,
			     String   genericTypeArgs,
			     Object[] args,
			     int arg_len,
			     [MarshalAs(UnmanagedType.LPArray,SizeParamIndex=4)]int[] arg_tys,
			     int        res_ty) {
     // Get the methods from the type
    MethodInfo[] methods = obj.GetType().GetMethods();

    if ( methods==null ) {
      Logger.Debug("InvokeMethod: No matching types found");
      return null;
    }
			
    BindingFlags flgs =
      (BindingFlags.Public       |
       BindingFlags.NonPublic    |
       BindingFlags.Instance     |
       BindingFlags.Static       |
       BindingFlags.InvokeMethod);
    
     /* Caller is assumed to catch any exceptions raised. */
    try {
      Type ty = obj.GetType();
      int idx;
       //Console.WriteLine("Calling-method \"{0}\" {1} {2} {3}", methName, ty.ContainsGenericParameters, res_ty, ty);
      Type[] methTyArgs = new Type[0];
      Type[] typeArgs; 
	  
       /* Both types and methods can be parameterized over types. We need
	* to keep the two binding sites apart. For the type's parameters we
	* need to separately instantiate those before getting on to the method's
	*
	* Somewhat hackily, we pass along a single type-param string from Haskell,
	* separating the type's instantiated types from the method's by the _;;_
	* delimiter. 
	*/
      if ( genericTypeArgs!=null && (idx = genericTypeArgs.IndexOf("_;;_")) >= 0 ) {
	methTyArgs = fromTypeArgString(genericTypeArgs.Substring(idx+4));
	typeArgs   = fromTypeArgString(genericTypeArgs.Substring(0,idx));
      } else {
	typeArgs   = fromTypeArgString(genericTypeArgs);
      }
      
       /* If the underlying type is generic, instantiate it now with the above type arguments */
      if ( ty.ContainsGenericParameters ) {
	ty = ty.MakeGenericType(typeArgs);
      }
      
      Type[] paramTys = new Type[args.Length];
      for(int i=0;i<paramTys.Length;i++) {
	paramTys[i]=args[i].GetType();
      }
      MethodInfo mi = FindMethod(ty,
				 methName,
				 flgs,
				 new HsBinder(arg_tys,res_ty),
				 methTyArgs,
				 paramTys);
      Object o= mi.Invoke(obj,args);
      //Console.WriteLine("return type: {0} {1} {2}", methName, ( o!=null ? o.GetType() : null), ( o!=null ? o.ToString() : "null"));
      return o;
    } catch (Exception e) {
      Logger.Debug("Unable to call \"{0}\" {1}", methName, e);
      throw(e);
    }
  }
  
  [return:MarshalAs( UnmanagedType.Interface ) ]
  public Object InvokeMethodBoxed(Object   obj, 
				  String   methName,
				  String   genericTypeArgs,
				  Object[] args,
				  int arg_len,
				  [MarshalAs(UnmanagedType.LPArray,SizeParamIndex=4)]int[] arg_tys,
				  int res_ty) {
    return InvokeMethod(obj,methName,genericTypeArgs,args,arg_len,arg_tys,res_ty);
  }
			      
  //
  // Method:  InvokeStaticMethod
  // 
  // Purpose: Invoke a static method, given the fully qualified name
  //          of the method (and its arguments). If found, invoke the
  //          method passing it 'args' as arguments.
  //
  // Comments: the format of the method-spec is 
  //              "T1.T2.<..>.Tn.methodName(type1,..,typeN)" [N>=0]
  //
  public Object InvokeStaticMethod(String   assemName,
				   String   typeAndMethName,
				   String   genericTypeArgs,
				   Object[] args,
				   int      arg_len,
				   [MarshalAs(UnmanagedType.LPArray,SizeParamIndex=4)]int[] arg_tys,
				   int res_ty) {
    String className = "";
    String methName  = typeAndMethName;
    Type t;

    int lastDot = typeAndMethName.LastIndexOf('.');
    if (lastDot > (-1) ) {
      className = typeAndMethName.Substring(0,lastDot);
      methName  = typeAndMethName.Substring(lastDot+1);
    }

     // Unravel the name of the class/type.
    TypeName typeName = TypeName.ParseType(className);
  
    if (assemName != null && assemName.Length > 0) {
      typeName.m_assembly = assemName;
    }
  
    try {
      t = GetType(typeName.m_class);
      if ( t==null ) {
	try {
	  Assembly localA = Assembly.LoadFrom(typeName.m_assembly);
	  t = localA.GetType(typeName.m_class);
	} catch (Exception) {
	  ;
	}
      }
      
      if ( t==null ) {
	Logger.Debug("InvokeStaticMethod: Type '{0}' not found", className);
	return null;
      }
    } catch (Exception e) {
      Logger.Debug("InvokeStaticMethod: Type {0} not found", className);
      throw(e);
    }

    BindingFlags flgs 
      = ( BindingFlags.Public |
	  BindingFlags.NonPublic |
	  BindingFlags.FlattenHierarchy |
	  BindingFlags.Static |
	  BindingFlags.InvokeMethod);
    
    //Console.WriteLine("Calling \"{0}\" {1} {2}", methName, t.ContainsGenericParameters, res_ty);
    try {
      int idx;
      Type[] methTyArgs = new Type[0];
      Type[] typeArgs; 

      //Console.WriteLine("generic: {0}", genericTypeArgs);
      if ( genericTypeArgs != null && (idx = genericTypeArgs.IndexOf("_;;_")) >= 0 ) {
	methTyArgs = fromTypeArgString(genericTypeArgs.Substring(idx+4));
	typeArgs   = fromTypeArgString(genericTypeArgs.Substring(0,idx));
      } else {
	typeArgs   = fromTypeArgString(genericTypeArgs);
      }
     
      if ( t.ContainsGenericParameters ) {
	 t = t.MakeGenericType(typeArgs);
      }

      Type[] paramTys = new Type[args.Length];
      for(int i=0;i<paramTys.Length;i++) {
	paramTys[i]=args[i].GetType();
//	if (methName == "Any") {
//	  Console.WriteLine("PT: {1} '{0}' {2} {3}", paramTys[i], i, arg_len, arg_tys[i]);
//	}
      }
      MethodInfo mi = FindMethod(t,
				 methName,
				 flgs,
				 new HsBinder(arg_tys,res_ty),
				 methTyArgs,
				 paramTys);
      //     Console.WriteLine("mi: {1} {0} {2}", methName, mi, t);
     return mi.Invoke(null,args);
    } catch (Exception e) {
      Logger.Debug("Unable to call \"{0}\" {1}", methName, e);
      throw(e);
    }
  }
			      
  [return:MarshalAs( UnmanagedType.Interface ) ]
  public Object InvokeStaticMethodBoxed(String   assemName,
					String   typeAndMethName,
					String   genericTypeArgs,
					Object[] args,
					int arg_len,
					[MarshalAs(UnmanagedType.LPArray,SizeParamIndex=4)]int[] arg_tys,
					int res_ty) {
    return InvokeStaticMethod(assemName,typeAndMethName,genericTypeArgs,args,arg_len,arg_tys,res_ty);
  }
   //
   // Method:  GetField
   //
   // Purpose: Fetch the (boxed) value of named field of a given object.
   //
  public Object GetField(Object   obj,
			 Object[] args,
			 String   fieldName,
			 int arg_len,
			 [MarshalAs(UnmanagedType.LPArray,SizeParamIndex=3)]int[] arg_tys,
			 int res_ty) {
    Type ty = obj.GetType();
    BindingFlags flgs 
      = (BindingFlags.Public       |
	 BindingFlags.NonPublic    |
	 BindingFlags.Static       |
	 BindingFlags.GetField     |
	 BindingFlags.GetProperty  |
	 BindingFlags.Instance);

    FieldInfo fInfo = ty.GetField(fieldName,flgs);
    Type[] paramTys = new Type[arg_tys.Length];
    for(int i=0;i<paramTys.Length;i++) {
      paramTys[i]=TypeName.GetDotnetType(arg_tys[i]);
    }

    if ( fInfo == null ) {
      PropertyInfo pInfo = null;
      try {
	pInfo = ty.GetProperty(fieldName,flgs);
      } catch (Exception) {
	;
      }
      if ( pInfo == null ) {
	pInfo = ty.GetProperty(fieldName,
			       flgs,
			       new HsBinder(arg_tys,res_ty),
			       TypeName.GetDotnetType(res_ty),
			       paramTys,
			       null);
      }
      if ( pInfo!=null ) {
	return pInfo.GetValue(obj,args);
      }
       // ToDo: have a friendlier way to bubble up an Exception to
       // COM interop layer!
      Object x = null;
      return x.ToString();
    } else {
      return fInfo.GetValue(obj);
    }
		  
  }

  [return:MarshalAs( UnmanagedType.Interface ) ]
  public Object GetFieldBoxed(Object   obj,
			      Object[] args,
			      String   fieldName,
			      int arg_len,
			      [MarshalAs(UnmanagedType.LPArray,SizeParamIndex=3)]int[] arg_tys,
			      int res_ty) {
    return GetField(obj,args,fieldName,arg_len,arg_tys,res_ty);
  }

  //
  // Method:  GetStaticField
  //
  // Purpose: Fetch the (boxed) value of named static field.
  //
  public Object GetStaticField(String clsName, 
			       String fieldName) {
    Type ty = GetType(clsName);
    BindingFlags static_field_flgs 
      = (BindingFlags.Public       |
	 BindingFlags.NonPublic    |
	 BindingFlags.FlattenHierarchy |
	 BindingFlags.GetField     |
	 BindingFlags.GetProperty  |
	 BindingFlags.Static);

    FieldInfo fInfo = ty.GetField(fieldName, static_field_flgs);

    if ( fInfo == null ) {
      PropertyInfo pInfo = ty.GetProperty(fieldName,static_field_flgs);
      if ( pInfo!=null ) {
	return pInfo.GetValue(null,null);
      }
      Object x = null;
      return x.ToString();
    } else {
      return fInfo.GetValue(null); // according to doc, ok to pass any val here.
    }
  }

  [return:MarshalAs( UnmanagedType.Interface ) ]
  public Object GetStaticFieldBoxed(String clsName, 
				    String fieldName) {
    return GetStaticField(clsName,fieldName);
  }
  //
  // Method:  SetField
  //
  // Purpose: Replace the (boxed) value of named field of a given object.
  //
  public void SetField(Object obj,
		       String fieldName,
		       Object val) {
    FieldInfo fInfo = obj.GetType().GetField(fieldName);
    fInfo.SetValue(obj,val);
    return;
  }
	    
  //
  // Method:  SetStaticField
  //
  // Purpose: Replace the (boxed) value of named field of a given object.
  //
  public void SetStaticField(String clsName,
			     String fieldName,
			     Object val) {
    Type ty = GetType(clsName);
    BindingFlags static_field_flgs 
      = (BindingFlags.Public       |
	 BindingFlags.NonPublic    |
	 BindingFlags.FlattenHierarchy |
	 BindingFlags.Static);
  
    FieldInfo fInfo = ty.GetField(fieldName,static_field_flgs);
    fInfo.SetValue(null,val);
    return;
  }

  // 
  // Method:  NewString
  // 
  // Purpose: construct a System.String object copy in a manner that avoids
  //          COM Interop from deconstructing it to a BSTR.
  //
  [return:MarshalAs( UnmanagedType.Interface ) ]
  public Object NewString( String s) {
    String c = String.Copy(s);
    return c;
  }

   //
   // Method:  NewVector
   //
   // Purpose: create a new vector of value types.
   //
  public Array NewVector(int ty, int sz) {
     /* Could have used TypeCode here...probably should...but 
      * stuck with DotnetType on the Haskell side.
      */
    switch ( (DotnetType)ty ) {
    case DotnetType.Dotnet_Byte:
      return Array.CreateInstance(typeof(Object), sz); 
    case DotnetType.Dotnet_Boolean:
      return Array.CreateInstance(typeof(bool), sz); 
    case DotnetType.Dotnet_Char:
      return Array.CreateInstance(typeof(char), sz); 
    case DotnetType.Dotnet_Int8:
      return Array.CreateInstance(typeof(SByte), sz); 
    case DotnetType.Dotnet_Word8:
      return Array.CreateInstance(typeof(Byte), sz); 
    case DotnetType.Dotnet_Int16:
      return Array.CreateInstance(typeof(Int16), sz); 
    case DotnetType.Dotnet_Word16:
      return Array.CreateInstance(typeof(UInt16), sz); 
    case DotnetType.Dotnet_Word32:
      return Array.CreateInstance(typeof(UInt32), sz); 
    case DotnetType.Dotnet_Int:

    case DotnetType.Dotnet_Int32:
      return Array.CreateInstance(typeof(Int32), sz); 
    case DotnetType.Dotnet_Word64:
      return Array.CreateInstance(typeof(UInt64), sz); 
    case DotnetType.Dotnet_Int64:
      return Array.CreateInstance(typeof(Int64), sz); 
    case DotnetType.Dotnet_Float:
      return Array.CreateInstance(typeof(Single), sz); 
    case DotnetType.Dotnet_Double:
      return Array.CreateInstance(typeof(Double), sz); 
/*
  case TypeCode.Decimal:
  return Array.CreateInstance(Decimal, sz); 
  case TypeCode.DateTime:
  return Array.CreateInstance(DateTime, sz); 
 */
    case DotnetType.Dotnet_String:
      return Array.CreateInstance(typeof(String), sz); 
    default:
      return Array.CreateInstance(typeof(Object), sz); 
    }
  
  }
  
  //
  // Method:  NewArgArray
  //
  // Purpose: create a new array for holding (boxed) arguments to constructors/
  //          methods.
  //
  public Array NewArgArray(int sz) {
    return Array.CreateInstance(typeof(Object), sz); 
  
  }
  
  //
  // Method: SetArg
  //
  // Purpose: set an entry in the argument vector.
  //
  public void SetArg(Object[] arr,
		     Object   val,
		     int idx) {
    arr.SetValue(val,idx);
  }

  //
  // Method: GetArg
  //
  // Purpose: get an entry in the argument vector.
  //
  public Object GetArg(Object[] arr, int idx) {
    return arr.GetValue(idx);
  }

  // Method: GetType(String* typeName);
  // 
  // Purpose: Assembly-savvy version of Type.GetType()
  //
  public Type GetType(String typeName) {
    int idx;
    String asName = typeName;

     // Simple stuff first, resolve it via std Type.GetType()..
    try {
      Type t = Type.GetType(typeName);
      if ( t!=null ) return t;
    } catch (Exception) {
      ;
    }

    int tyParamIdx = 0;
    String baseTypeName = typeName;
    ArrayList tyArgs = new ArrayList();

    tyParamIdx = typeName.IndexOf("`");
    if ( tyParamIdx > 0 ) {
      int i = tyParamIdx;
      while ( i < typeName.Length ) {
	i++;
	if ( typeName[i] < '0' || typeName[i] > '9' ) {
	  break;
	}
      }
       // Upto and including the arity -- System.Action`2
      baseTypeName = typeName.Substring(0,i);
      TypeName.ParseTypeArgs(typeName,i,ref tyArgs);
    }

    if ( (idx = baseTypeName.LastIndexOf(".")) > 0 ) {
      String cName  = baseTypeName.Substring(idx+1);
      asName = typeName.Substring(0,idx);
      AssemblyName assemName = LocateAssembly(asName,baseTypeName);
//     Console.WriteLine("ty: {0} {1} {2} {3}", baseTypeName, typeName, assemName, asName);
      if ( assemName != null ) {
	try {
	  String stuff = String.Format("{0},{1}", baseTypeName, assemName.FullName);
//	   Console.WriteLine("st: {0}", stuff);
	   Type t = Type.GetType(stuff);
//	   Console.WriteLine("st: {0} %{1}%", stuff,t);
	   if ( t!=null ) { 
	     // save away the mapping for next time..
	     AddAssemblyMapping(asName,assemName);
	     return InstantiateGeneric(t,tyArgs);
           }
           Assembly localA = Assembly.Load(assemName.FullName);
           t = localA.GetType(baseTypeName);
//	   Console.WriteLine("st: {0} {1} %{2}%", stuff,localA, t);
           if ( t!=null ) { 
	     // save away the mapping for next time..
	     AddAssemblyMapping(asName,assemName);
	     return InstantiateGeneric(t,tyArgs);
	   }
         } catch (Exception) {
	  ;
         }
     }
    }

  foreach(KeyValuePair<String,ArrayList> kv in m_assemblyNames) {
    try {
      ArrayList al = (ArrayList)kv.Value; 
      for(int jx=0;jx<al.Count;jx++) {
	AssemblyName aName = (AssemblyName)(al[jx]);
	String fName = aName.FullName;
	String stuff = String.Format("{0},{1}",baseTypeName, fName);
	Type t = Type.GetType(stuff);
	if (t!=null) { 
	  AddAssemblyMapping(asName,aName);
	  return InstantiateGeneric(t,tyArgs);
	}
	Assembly localA = Assembly.Load(fName);
	t = localA.GetType(baseTypeName);
	if ( t!=null ) { 
	  AddAssemblyMapping(asName,aName);
	  return InstantiateGeneric(t,tyArgs);
	}
	 // I think is pointless..qualified name doesn't appear to be wanted by
	 // Assembly.GetType()..
	t = localA.GetType(stuff);
	if ( t!=null ) {
	  AddAssemblyMapping(asName,aName);
	  return InstantiateGeneric(t,tyArgs);
	}
      }
    } catch (Exception) {
      continue;
    }
  }

  try {
    Assembly asm   = Assembly.LoadWithPartialName(asName);
    if ( asm != null ) {
      AssemblyName aName = asm.GetName();
      if ( !m_assemblies.ContainsKey(asm.Location) ) {
	m_assemblies.Add(asm.Location,aName);
      }
      AddAssemblyMapping(asm.FullName,aName);
      Type t = asm.GetType(baseTypeName);
      if ( t!=null ) {
        AddAssemblyMapping(asName,aName);
	return InstantiateGeneric(t,tyArgs);
      }
      Type[] ts = asm.GetTypes();
      for(int v=0;v<ts.Length;v++) {
	if (ts[v].ToString() == baseTypeName) {
	  AddAssemblyMapping(asName,aName);
	  return InstantiateGeneric(ts[v],tyArgs);
	}
      }
    }
  } catch (Exception) {
    ;
  }
  return null;
  
  }

  public Object DefineDelegator(String tyStr,
				IntPtr funPtr) {
    Type ty = GetType(tyStr);
    if ( ty == null ) {
      Logger.Debug("DefineDelegator: unable to locate requested type '{0}'", tyStr);
    }
    try {
      return HsDelegateGen.DefineDelegate(ty,"InvokeMe", funPtr);
    } catch (Exception e) {
      Console.WriteLine("DefineDelegator: {0}", e);
      return e;
    }
  }

  public void SetDumpExceptionsFlag(bool flg) {
    Logger.DebugMode = flg;
  }
  
  [ComVisible(false)]
  private AssemblyName LocateAssembly(String asName,    // the short name (just X.Y of X.Y.Z, really.)
				      String tyName) {  // (fully qualified) type being looked for.

    if ( m_assemblyNames.ContainsKey(asName) ) {
      int i;
      ArrayList al = (ArrayList)m_assemblyNames[asName];
      for(i=0;i<al.Count;i++) {
	AssemblyName aName = (AssemblyName)al[i];
	String tySpec = String.Format("{0},{1}",tyName, aName);
	Type   t = Type.GetType(tySpec);
	if ( t!= null ) {
	  return aName;
	}
      }
    }
    System.GACManagedAccess.AssemblyCacheEnum enu = new System.GACManagedAccess.AssemblyCacheEnum(null);
    try { 
      String asCand=enu.GetNextAssembly();
      while (asCand!=null) {
	try {
	  Assembly tAss      = Assembly.Load(asCand);
	  AssemblyName aName = tAss.GetName();
	  AddAssemblyMapping(aName.FullName,aName);
	  
	  String tySpec = String.Format("{0},{1}",tyName,aName.FullName);
	  Type   t = Type.GetType(tySpec);
	  if (t != null ) {
	    AddAssemblyMapping(asName,aName);
	    return aName;
	  }
	} catch (Exception e) {
	  Logger.Debug("{0}",e);
	}
	asCand=enu.GetNextAssembly();
      }
    } catch(Exception e) {
      Logger.Debug("{0}",e);
    }
    return null;
  }

   //
   // Function: InstantiateGeneric()
   // 
   // Given an open generic type and a bunch of type name parameters,
   // create the argument types and close the generic type by supplying
   // the resulting arg types to Type.MakeGenericType()
   //
   // The reason we need it here is that GetType() work over open generic 
   // types, so the closed type string passed into HsInvokeBridge.GetType()
   // needs to be unravelled and manual type application performed via
   // InstantiateGeneric(). 
   //  
  [ComVisible(false)]
  private Type InstantiateGeneric(Type t, ArrayList al) {
    int i;

    if ( al.Count == 0 || ! t.IsGenericType ) {
      return t;
    }
    Type[] tyArgs = new Type[al.Count];

    for(i=0;i<al.Count;i++) {
      tyArgs[i] = GetType((String)(al[i]));
    }
    return t.MakeGenericType(tyArgs);
  }

   [ComVisible(false)]
   private void AddAssemblyMapping(String nsName, AssemblyName aName) {
     if ( m_assemblyNames == null ) {
       m_assemblyNames = new Dictionary<String,ArrayList>();
     }
     if ( m_assemblyNames.ContainsKey(nsName) ) {
       ArrayList al = m_assemblyNames[nsName];
       if ( !al.Contains(aName) ) {
	 al.Add(aName);
       }
	// (basic!) Q: do we need to update the hashtable with new a-list or is it not a copy?
     } else {
       ArrayList al = new ArrayList();
       al.Add(aName);
       m_assemblyNames.Add(nsName,al);
     }
   }

  [ComVisible(false)]
   private Type[] fromTypeArgString(String genericTypeArgs) {
    int tyArgs = 0;
    int idx = 0;
    int i = 0;
    int nidx = 0;
    Type[] typeArgs;
    

     /* Count them... */
    if ( genericTypeArgs != null && genericTypeArgs.Length > 0 ) {
      tyArgs++;
    }
    while ( idx < genericTypeArgs.Length ) {
      if ( (idx=genericTypeArgs.IndexOf(';',idx)) > 0 ) {
	tyArgs++;
	idx++;
      } else {
	break;
      }
    }
//    Console.WriteLine("xx: '{0}'", tyArgs);
    
     /* Create array to hold the args.. */
    typeArgs = new Type[tyArgs];
    idx = 0;
    while ( tyArgs > 0 ) {
      String arg;
      tyArgs--;
      if ( (nidx=genericTypeArgs.IndexOf(';',idx)) > 0 ) {
	arg = genericTypeArgs.Substring(idx,nidx-idx);
      } else {
	arg = genericTypeArgs.Substring(idx);
      }

       // Unravel the name of the class/type.
      TypeName argTypeName = TypeName.ParseType(arg);
      Type   aty = null;
      
      idx = nidx+1;
      try {
	aty = GetType(argTypeName.m_class);
	if ( aty != null ) {
	    try {
		Assembly localA = Assembly.LoadFrom(argTypeName.m_assembly);
		aty = localA.GetType(argTypeName.m_class);
	    } catch (Exception) {
	      ;
	    }
	}
    } catch (Exception){
	;
      }
    typeArgs[i]=aty;
    i++;
    }
    return typeArgs;
  }

  protected Object CreateInstance(TypeName typeName,
				  Object[] args) {
    Type   t = GetType(typeName.m_class);
    if ( t!=null ) {
      try {
	Assembly localA = Assembly.LoadFrom(typeName.m_assembly);
	t = localA.GetType(typeName.m_class);
      } catch (Exception) {
	;
      }
    }
    
    if ( t!=null ) {
      if ( t.IsSubclassOf(typeof(System.ValueType)) ) {
	if ( args.Length == 1 ) {
	  return Convert.ChangeType(args[0],t);
	}
      }
      try {
	BindingFlags flgs 
	  =(BindingFlags.Public       |
	    BindingFlags.NonPublic    |
	    BindingFlags.Instance     |
	    BindingFlags.CreateInstance);
	  
	Object o =Activator.CreateInstance(t, 
					   flgs,
					   null,
					   args,
					   null);
	return o;
      } catch (Exception e) {
	Logger.Debug("Constructor failure: {0}", e);
	return null;
      }
    }
    return null;
  }
};
}