// ==========================================================================
// This software is subject to the provisions of the Zope Public License,
// Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
// THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
// WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
// FOR A PARTICULAR PURPOSE.
// ==========================================================================

using System;
using System.Collections;
using System.Reflection;

namespace Python.Runtime {

    //========================================================================
    // Implements a Python type that represents a CLR method. Method objects
    // support a subscript syntax [] to allow explicit overload selection.
    //========================================================================
    // TODO: ForbidPythonThreadsAttribute per method info

    internal class MethodObject : ExtensionType {

        internal MethodInfo[] info;
        internal string name;
        internal MethodBinding unbound;
        internal MethodBinder binder;
        internal bool is_static = false;
        internal IntPtr doc;

        public MethodObject(string name, MethodInfo[] info) : base() {
            _MethodObject(name, info);
        }

        public MethodObject(string name, MethodInfo[] info, bool allow_threads) : base()
        {
            _MethodObject(name, info);
            binder.allow_threads = allow_threads;
        }

        private void _MethodObject(string name, MethodInfo[] info)
        {
            this.name = name;
            this.info = info;
            binder = new MethodBinder();
            for (int i = 0; i < info.Length; i++)
            {
                MethodInfo item = (MethodInfo)info[i];
                binder.AddMethod(item);
                if (item.IsStatic)
                {
                    this.is_static = true;
                }
            }
        }

        public virtual IntPtr Invoke(IntPtr inst, IntPtr args, IntPtr kw) {
            return this.Invoke(inst, args, kw, null);
        }
 
        public virtual IntPtr Invoke(IntPtr target, IntPtr args, IntPtr kw,
                                     MethodBase info) {
            return binder.Invoke(target, args, kw, info, this.info);
        }

        //====================================================================
        // Helper to get docstrings from reflected method / param info.
        //====================================================================

        internal IntPtr GetDocString() {
            if (doc != IntPtr.Zero) {
                return doc;
            }
            string str = "";
			Type marker = typeof(DocStringAttribute);
            MethodBase[] methods = binder.GetMethods();
            foreach (MethodBase method in methods) {
                if (str.Length > 0)
                    str += Environment.NewLine;
				Attribute[] attrs = (Attribute[]) method.GetCustomAttributes(marker, false);
	            if (attrs.Length == 0) {
		                str += method.ToString();
		            }
				else {
					DocStringAttribute attr = (DocStringAttribute)attrs[0];
					str += attr.DocString;
				}
			}
            doc = Runtime.PyString_FromString(str);
            return doc;
        }


        //====================================================================
        // This is a little tricky: a class can actually have a static method
        // and instance methods all with the same name. That makes it tough
        // to support calling a method 'unbound' (passing the instance as the
        // first argument), because in this case we can't know whether to call
        // the instance method unbound or call the static method. 
        //
        // The rule we is that if there are both instance and static methods
        // with the same name, then we always call the static method. So this
        // method returns true if any of the methods that are represented by 
        // the descriptor are static methods (called by MethodBinding).
        //====================================================================

        internal bool IsStatic() {
            return this.is_static;
        }

        //====================================================================
        // Descriptor __getattribute__ implementation. 
        //====================================================================

        public static IntPtr tp_getattro(IntPtr ob, IntPtr key) {
            MethodObject self = (MethodObject)GetManagedObject(ob);

            if (!Runtime.PyString_Check(key)) {
                return Exceptions.RaiseTypeError("string expected");
            }

            string name = Runtime.GetManagedString(key);
            if (name == "__doc__") {
                IntPtr doc = self.GetDocString();
                Runtime.Incref(doc);
                return doc;
            }

            return Runtime.PyObject_GenericGetAttr(ob, key);
        }

        //====================================================================
        // Descriptor __get__ implementation. Accessing a CLR method returns
        // a "bound" method similar to a Python bound method. 
        //====================================================================

        public static IntPtr tp_descr_get(IntPtr ds, IntPtr ob, IntPtr tp) {
            MethodObject self = (MethodObject)GetManagedObject(ds);
            MethodBinding binding;

            // If the method is accessed through its type (rather than via
            // an instance) we return an 'unbound' MethodBinding that will
            // cached for future accesses through the type.

            if (ob == IntPtr.Zero) {
                if (self.unbound == null) {
                    self.unbound = new MethodBinding(self, IntPtr.Zero);
                }
                binding = self.unbound;
                Runtime.Incref(binding.pyHandle);;
                return binding.pyHandle;
            }

            if (Runtime.PyObject_IsInstance(ob, tp) < 1) {
                return Exceptions.RaiseTypeError("invalid argument");
            }

            binding = new MethodBinding(self, ob);
            return binding.pyHandle;
        }

        //====================================================================
        // Descriptor __repr__ implementation.
        //====================================================================

        public static IntPtr tp_repr(IntPtr ob) {
            MethodObject self = (MethodObject)GetManagedObject(ob);
            string s = String.Format("<method '{0}'>", self.name);
            return Runtime.PyString_FromStringAndSize(s, s.Length);
        }

        //====================================================================
        // Descriptor dealloc implementation.
        //====================================================================

        public static new void tp_dealloc(IntPtr ob) {
            MethodObject self = (MethodObject)GetManagedObject(ob);
            Runtime.Decref(self.doc);
            if (self.unbound != null) {
                Runtime.Decref(self.unbound.pyHandle);
            }
            ExtensionType.FinalizeObject(self);
        }


    }


}