/*
 * Copyright (c), 2009 Sigbjorn Finne <sof@forkIO.com>
 *
 * The HsBinder class is a basic, custom implementation of the 
 * method/field Binder class, guiding method resolution.
 * 
 */
using System;
using System.Runtime.InteropServices;
using System.Reflection;
using System.Reflection.Emit;
using System.Globalization;


namespace HsInvoker {

//
// Class: HsBinder
//
// See the System.Reflection.Binder type for detailed documentation
// of the methods we override here.
//
[ComVisible(false)]
public class HsBinder : Binder {
   private int[] m_arg_types;
   private int   m_result_ty;


   public HsBinder(int[] a,int r) { 
     m_arg_types = a; 
     m_result_ty = r;
   }

   public override FieldInfo BindToField( BindingFlags bindingAttr,
				 FieldInfo[] match,
				 object val,
				 CultureInfo culture ) {
      return Type.DefaultBinder.BindToField(bindingAttr,match,val,culture);
    }

   public override MethodBase BindToMethod( BindingFlags bindingAttr,
				   MethodBase[] match,
				   ref object[] args,
                                   ParameterModifier[] modifiers,
				   CultureInfo culture,
				   String[]    names,
			           out object  state ) {
     int current_match = 0;
     
     //      Console.WriteLine("BindToMethod.len: {0}", match.Length);
     
     state = null;
     if (match.Length < 2) {
       return match[current_match];
     }
     //
     // Walk through the candidate matches left-to-right, being
     // guided by the type descriptors for each argument passed
     // in on 'the other side'
     //
     for (int i=0;i<match.Length;i++) {
       ParameterInfo[] ps = match[i].GetParameters();
       // I would hope the Invoke layer has weeded
       // out different arity methods already, but just in case..
       if ( ps.Length != m_arg_types.Length ) {
	 i++; continue;
       }
       bool matched = true;
       for (int j=0;j<m_arg_types.Length+1; j++) {
	 Type eltTy;
	 int  elt_ty;

	 if ( j < m_arg_types.Length ) {
	   eltTy  = ps[j].ParameterType;
	   elt_ty = m_arg_types[j];
	 } else {
	   eltTy  = ((MethodInfo)(match[i])).ReturnType;
	   elt_ty = m_result_ty;
	 }
	 bool is_array = (elt_ty < 0);
	 if ( is_array ) { elt_ty = -elt_ty; }
	 
	 //Console::WriteLine("BindToMethod: {0}-{1} {2} {3} {4}", elt_ty, is_array, eltTy, i, j);
	 bool flg = true;
	 if ( is_array ) {
	   if ( eltTy.IsArray ||
		Type.GetType("System.Array").IsAssignableFrom(eltTy) ) {
	     eltTy = eltTy.GetElementType();

	     //Console::WriteLine("BindToMethod: {0} {1}",eltTy, eltTy == Type::GetType("System.Byte"));
	   } else { 
	     flg = false;
	   }
	 }
	 if (flg) {
	   switch ((DotnetType)elt_ty) {
	   case DotnetType.Dotnet_Byte:    flg = (eltTy == Type.GetType("System.Byte")); break;
	   case DotnetType.Dotnet_Boolean: flg = (eltTy == Type.GetType("System.Boolean")); break;
	   case DotnetType.Dotnet_Char:    flg = (eltTy == Type.GetType("System.Char")); break;
	   case DotnetType.Dotnet_Double:  flg = (eltTy == Type.GetType("System.Double")); break;
	   case DotnetType.Dotnet_Float:   flg = (eltTy == Type.GetType("System.Float")); break;
	   case DotnetType.Dotnet_Int:     flg = (eltTy == Type.GetType("System.Int32")); break;
	   case DotnetType.Dotnet_Int8:    flg = (eltTy == Type.GetType("System.SByte")); break;
	   case DotnetType.Dotnet_Int16:   flg = (eltTy == Type.GetType("System.Int16")); break;
	   case DotnetType.Dotnet_Int32:   flg = (eltTy == Type.GetType("System.Int32")); break;
	   case DotnetType.Dotnet_Int64:   flg = (eltTy == Type.GetType("System.Int64")); break;
	   case DotnetType.Dotnet_Word8:   flg = (eltTy == Type.GetType("System.Byte")); break;
	   case DotnetType.Dotnet_Word16:  flg = (eltTy == Type.GetType("System.UInt16")); break;
	   case DotnetType.Dotnet_Word32:  flg = (eltTy == Type.GetType("System.UInt32")); break;
	   case DotnetType.Dotnet_Word64:  flg = (eltTy == Type.GetType("System.UInt64")); break;
	   case DotnetType.Dotnet_Ptr:     flg = (eltTy.IsPointer); break;
	   case DotnetType.Dotnet_Unit:    flg = (eltTy == Type.GetType("System.Void")); break;
	   case DotnetType.Dotnet_String:  flg = (eltTy == Type.GetType("System.String")); break;
	   case DotnetType.Dotnet_Object:  flg = (!eltTy.IsValueType); break;
	   default: flg = false;break;
	   }
	 }
	 // Failed to match for current param, give up.
	 if (!flg) {
	   //Console.WriteLine("Failed: {0} {1}",i,j);
	   matched = false; break;
	 } else {
	   //Console.WriteLine("arg ok: {0} {1}",i,j);
	   ;
	 }
       }
       // if we withstood that pass through the arguments, declare success and
       // go home..
       if ( matched ) {
	 //Console.WriteLine("BindToMethod.nm: {0} {1}", match[i].Name, i);
	 return match[i];
       }
     }
     return match[0];
   }

   public override object ChangeType(object value,
			    Type myChangeType,
			    CultureInfo culture ) {
     if ( value.GetType() == myChangeType ) {
       return value;
     } else {
       if ( myChangeType.IsArray ) {
	 System.Array x = System.Array.CreateInstance(myChangeType.GetElementType(),1);
	 x.SetValue(value,0);
	 return x;
       } else {
	 return value;
       }
     }
   }
   
   public override void ReorderArgumentArray ( ref object[] args,
					       object state) {
     Type.DefaultBinder.ReorderArgumentArray(ref args,state);
   }
   
   public override MethodBase SelectMethod( BindingFlags bindingAttr,
				   MethodBase[] match,
				   Type[] types,
				   ParameterModifier[] modifiers) {
     //      Console.WriteLine("select method: {0}", bindingAttr);
     return Type.DefaultBinder.SelectMethod(bindingAttr,match,types,modifiers);
   }
   
   public override PropertyInfo SelectProperty( BindingFlags   bindingAttr,
				       PropertyInfo[] match,
				       Type           returnType,
				       Type[]         indexes,
				       ParameterModifier[] modifiers ) {
     return Type.DefaultBinder.SelectProperty(bindingAttr,match,returnType,indexes,modifiers);
   }
   
  };
}