/**
   A D API for dealing with Python's PyTypeObject
 */
module python.type;


import autowrap.reflection: isParameter;
import python.raw: PyObject;
import std.traits: Unqual, isArray, isIntegral, isBoolean, isFloatingPoint, isAggregateType;
import std.datetime: DateTime, Date;
import std.typecons: Tuple;
import std.range.primitives: isInputRange;
import std.meta: allSatisfy;


package enum isPhobos(T) = isDateOrDateTime!T || isTuple!T;
package enum isDateOrDateTime(T) = is(Unqual!T == DateTime) || is(Unqual!T == Date);
package enum isTuple(T) = is(T: Tuple!A, A...);
package enum isUserAggregate(T) = isAggregateType!T && !isPhobos!(T);
package enum isNonRangeUDT(T) = isUserAggregate!T && !isInputRange!T;


/**
   A wrapper for `PyTypeObject`.

   This struct does all of the necessary boilerplate to intialise
   a `PyTypeObject` for a Python extension type that mimics the D
   type `T`.
 */
struct PythonType(T) {
    import python.raw: PyTypeObject, PySequenceMethods;
    import std.traits: FieldNameTuple, Fields;
    import std.meta: Alias, staticMap;

    alias fieldNames = FieldNameTuple!T;
    alias fieldTypes = Fields!T;
    enum hasLength = is(typeof({ size_t len = T.init.length; }));

    static PyTypeObject _pyType;
    static bool failedToReady;

    static PyObject* pyObject() {
        initialise;
        return failedToReady ? null : cast(PyObject*) &_pyType;
    }

    static PyTypeObject* pyType() {
        initialise;
        return failedToReady ? null : &_pyType;
    }

    private static void initialise() {
        import python.raw: PyType_GenericNew, PyType_Ready, TypeFlags,
            PyErr_SetString, PyExc_TypeError;

        if(_pyType != _pyType.init) return;

        _pyType.tp_name = T.stringof;
        _pyType.tp_basicsize = PythonClass!T.sizeof;
        _pyType.tp_flags = TypeFlags.Default;
        _pyType.tp_new = &PyType_GenericNew;
        _pyType.tp_getset = getsetDefs;
        _pyType.tp_methods = methodDefs;
        _pyType.tp_repr = &_py_repr;
        _pyType.tp_init = &_py_init;
        _pyType.tp_new = &_py_new;

        static if(hasLength) {
            if(_pyType.tp_as_sequence is null)
                _pyType.tp_as_sequence = new PySequenceMethods;
            _pyType.tp_as_sequence.sq_length = &_py_length;
        }

        if(PyType_Ready(&_pyType) < 0) {
            PyErr_SetString(PyExc_TypeError, &"not ready"[0]);
            failedToReady = true;
        }
    }

    private static auto getsetDefs() {
        import autowrap.reflection: Properties;
        import python.raw: PyGetSetDef;
        import std.meta: staticMap, Filter, Alias;
        import std.traits: isFunction, ReturnType;

        alias AggMember(string memberName) = Alias!(__traits(getMember, T, memberName));
        alias memberNames = __traits(allMembers, T);
        enum isPublic(string memberName) =
            __traits(getProtection, __traits(getMember, T, memberName)) == "public";
        alias publicMemberNames = Filter!(isPublic, memberNames);
        alias members = staticMap!(AggMember, publicMemberNames);
        alias memberFunctions = Filter!(isFunction, members);
        alias properties = Properties!memberFunctions;

        // +1 due to the sentinel
        static PyGetSetDef[fieldNames.length + properties.length + 1] getsets;

        // don't bother if already initialised
        if(getsets != getsets.init) return &getsets[0];

        // first deal with the public fields
        static foreach(i; 0 .. fieldNames.length) {
            getsets[i].name = cast(typeof(PyGetSetDef.name)) fieldNames[i];
            static if(__traits(getProtection, __traits(getMember, T, fieldNames[i])) == "public") {
                getsets[i].get = &PythonClass!T.get!i;
                getsets[i].set = &PythonClass!T.set!i;
            }
        }

        // then deal with the property functions
        static foreach(j, property; properties) {{
            enum i = fieldNames.length + j;

            getsets[i].name = cast(typeof(PyGetSetDef.name)) __traits(identifier, property);

            static foreach(overload; __traits(getOverloads, T, __traits(identifier, property))) {
                static if(is(ReturnType!overload == void))
                    getsets[i].set = &PythonClass!T.propertySet!(overload);
                else
                    getsets[i].get = &PythonClass!T.propertyGet!(overload);
            }
        }}

        return &getsets[0];
    }

    private static auto methodDefs()() {
        import autowrap.reflection: isProperty;
        import python.raw: PyMethodDef, MethodArgs;
        import python.cooked: pyMethodDef, defaultMethodFlags;
        import std.meta: AliasSeq, Alias, staticMap, Filter, templateNot;
        import std.traits: isSomeFunction;
        import std.algorithm: startsWith;

        alias memberNames = AliasSeq!(__traits(allMembers, T));
        enum ispublic(string name) = isPublic!(T, name);
        alias publicMemberNames = Filter!(ispublic, memberNames);
        enum isRegular(string name) =
            name != "this"
            && name != "toHash"
            && name != "factory"
            && !name.startsWith("op")
            && name != "__ctor"
            ;
        alias regularMemberNames = Filter!(isRegular, publicMemberNames);
        alias Member(string name) = Alias!(__traits(getMember, T, name));
        alias members = staticMap!(Member, regularMemberNames);
        alias memberFunctions = Filter!(templateNot!isProperty, Filter!(isSomeFunction, members));

        // +1 due to sentinel
        static PyMethodDef[memberFunctions.length + 1] methods;

        if(methods != methods.init) return &methods[0];

        static foreach(i, memberFunction; memberFunctions) {{

            static if(__traits(isStaticFunction, memberFunction))
                enum flags = defaultMethodFlags | MethodArgs.Static;
            else
                enum flags = defaultMethodFlags;

            methods[i] = pyMethodDef!(__traits(identifier, memberFunction), flags)
                                     (&PythonMethod!(T, memberFunction)._py_method_impl);
        }}

        return &methods[0];
    }

    import python.raw: Py_ssize_t;
    private static extern(C) Py_ssize_t _py_length(PyObject* self_) nothrow {

        return noThrowable!({
            assert(self_ !is null);
            static if(hasLength) {
                import python.conv: to;
                return self_.to!T.length;
            } else
                return -1;
        });
    }

    private static extern(C) PyObject* _py_repr(PyObject* self_) nothrow {

        return noThrowable!({

            import python: pyUnicodeDecodeUTF8;
            import python.conv: to;
            import std.string: toStringz;
            import std.conv: text;

            assert(self_ !is null);
            auto ret = text(self_.to!T);
            return pyUnicodeDecodeUTF8(ret.ptr, ret.length, null /*errors*/);
        });
    }

    private static extern(C) int _py_init(PyObject* self_, PyObject* args, PyObject* kwargs) nothrow {
        // nothing to do
        return 0;
    }

    private static extern(C) PyObject* _py_new(PyTypeObject *type, PyObject* args, PyObject* kwargs) nothrow {
        return noThrowable!({
            import autowrap.reflection: FunctionParameters, Parameter;
            import python.conv: toPython, to;
            import python.raw: PyTuple_Size, PyTuple_GetItem;
            import std.traits: hasMember, Unqual;
            import std.meta: AliasSeq;

            const numArgs = PyTuple_Size(args);

            if(numArgs == 0) {
                return toPython(userAggregateInit!T);
            }

            static if(hasMember!(T, "__ctor"))
                alias constructors = AliasSeq!(__traits(getOverloads, T, "__ctor"));
            else
                alias constructors = AliasSeq!();

            static if(constructors.length == 0) {
                alias parameter(FieldType) = Parameter!(
                    FieldType,
                    "",
                    void,
                );
                alias parameters = staticMap!(parameter, fieldTypes);
                return pythonConstructor!(T, false /*is variadic*/, parameters)(args, kwargs);
            } else {
                import python.raw: PyErr_SetString, PyExc_TypeError;
                import std.traits: Parameters, variadicFunctionStyle, Variadic;

                static foreach(constructor; constructors) {{

                    enum isVariadic = variadicFunctionStyle!constructor == Variadic.typesafe;

                    if(Parameters!constructor.length == numArgs) {
                        return pythonConstructor!(T, isVariadic, FunctionParameters!constructor)(args, kwargs);
                    } else if(numArgs >= NumRequiredParameters!constructor
                              && numArgs <= Parameters!constructor.length)
                    {
                        return pythonConstructor!(T, isVariadic, FunctionParameters!constructor)(args, kwargs);
                    }
                }}

                PyErr_SetString(PyExc_TypeError, "Could not find a suitable constructor");
                return null;
            }

        });
    }

    // Creates a python object from the given arguments by converting them to D
    // types, calling the D constructor and converting the result to a Python
    // object.
    private static auto pythonConstructor(T, bool isVariadic, P...)(PyObject* args, PyObject* kwargs) {
        import python.conv: toPython;
        import std.traits: hasMember;

        auto dArgs = pythonArgsToDArgs!(isVariadic, P)(args, kwargs);

        static if(is(T == class)) {
            static if(hasMember!(T, "__ctor")) {
                // When immutable dmd prints an odd error message about not being
                // able to modify dobj
                static if(is(T == immutable))
                    auto dobj = new T(dArgs.expand);
                else
                    scope dobj = new T(dArgs.expand);
            } else
                T dobj;
        } else
            auto dobj = T(dArgs.expand);

        return toPython(dobj);
    }
}


private auto pythonArgsToDArgs(bool isVariadic, P...)(PyObject* args, PyObject* kwargs)
    if(allSatisfy!(isParameter, P))
{
    import python.raw: PyTuple_Size, PyTuple_GetItem, PyTuple_GetSlice, pyUnicodeDecodeUTF8, PyDict_GetItem;
    import python.conv: to;
    import std.typecons: Tuple;
    import std.meta: staticMap;
    import std.traits: Unqual;
    import std.conv: text;
    import std.exception: enforce;

    const argsLength = args is null ? 0 : PyTuple_Size(args);

    alias Type(alias Param) = Param.Type;
    alias Types = staticMap!(Type, P);

    // If one or more of the parameters is const/immutable,
    // it'll be hard to construct it as such, so we Unqual
    // the types for construction and cast to the appropriate
    // type when returning.
    alias MutableTuple = Tuple!(staticMap!(Unqual, Types));
    alias RetTuple = Tuple!(Types);

    MutableTuple dArgs;

    int pythonArgIndex = 0;
    static foreach(i; 0 .. P.length) {

        static if(i == P.length - 1 && isVariadic) {  // last parameter and it's a typesafe variadic one
            // slice the remaining arguments
            auto remainingArgs = PyTuple_GetSlice(args, i, PyTuple_Size(args));
            dArgs[i] = remainingArgs.to!(P[i].Type);
        } else static if(is(P[i].Default == void)) {
            // ith parameter is required
            enforce(i < argsLength,
                    text(__FUNCTION__, ": not enough Python arguments"));
            dArgs[i] = PyTuple_GetItem(args, i).to!(typeof(dArgs[i]));
        } else {

            if(i < argsLength) {  // regular case
                dArgs[i] = PyTuple_GetItem(args, i).to!(P[i].Type);
            } else {
                // Here it gets tricky. The user could have supplied it in
                // args positionally or via kwargs
                auto key = pyUnicodeDecodeUTF8(&P[i].identifier[0],
                                               P[i].identifier.length,
                                               null /*errors*/);
                enforce(key, "Errors converting '" ~ P[i].identifier ~ "' to Python object");
                auto val = kwargs ? PyDict_GetItem(kwargs, key) : null;
                dArgs[i] = val
                    ? val.to!(P[i].Type) // use kwargs
                    : P[i].Default; // use default value
            }
        }
    }

    return cast(RetTuple) dArgs;
}


private alias Type(alias A) = typeof(A);


/**
   The C API implementation of a Python method F of aggregate type T
 */
struct PythonMethod(T, alias F) {
    static extern(C) PyObject* _py_method_impl(PyObject* self,
                                               PyObject* args,
                                               PyObject* kwargs)
        nothrow
    {
        return noThrowable!({
            import python.raw: pyDecRef;
            import python.conv: toPython, to;
            import std.traits: Parameters, FunctionAttribute, functionAttributes, Unqual, hasFunctionAttributes;

            static if(!__traits(isStaticFunction, F))
                assert(self !is null,
                       "Cannot call PythonMethod!" ~ __traits(identifier, F) ~ " on null self");

            static if(functionAttributes!F & FunctionAttribute.const_)
                alias Aggregate = const T;
            else static if(functionAttributes!F & FunctionAttribute.immutable_)
                alias Aggregate = immutable T;
            else
                alias Aggregate = Unqual!T;

            auto dAggregate = {
                // could be null for static member functions
                return self is null ? Aggregate.init : self.to!Aggregate;
            }();

            // Not sure how else to take `dAggregate` and `F` and call the member
            // function other than a mixin
            mixin(`auto ret = callDlangFunction!((Parameters!F args) => dAggregate.`,
                  __traits(identifier, F), `(args), F)(self, args, kwargs);`);

            // The member function could have side-effects, we need to copy the changes
            // back to the Python object.
            static if(!(functionAttributes!F & FunctionAttribute.const_)) {
                auto newSelf = {
                    return self is null ? self : toPython(dAggregate);
                }();
                scope(exit) {
                    if(self !is null) pyDecRef(newSelf);
                }
                auto pyClassSelf = cast(PythonClass!T*) self;
                auto pyClassNewSelf = cast(PythonClass!T*) newSelf;

                static foreach(i; 0 .. PythonClass!T.fieldNames.length) {
                    if(self !is null)
                        pyClassSelf.set!i(self, pyClassNewSelf.get!i(newSelf));
                }
            }

            return ret;
        });
    }
}


/**
   The C API implementation that calls a D function F.
 */
struct PythonFunction(alias F) {
    static extern(C) PyObject* _py_function_impl(PyObject* self, PyObject* args, PyObject* kwargs) nothrow {
        return noThrowable!(() => callDlangFunction!F(self, args, kwargs));
    }
}


private auto noThrowable(alias F, A...)(auto ref A args) {
    import python.raw: PyErr_SetString, PyExc_RuntimeError;
    import std.string: toStringz;
    import std.traits: ReturnType;

    try {
        return F(args);
    } catch(Exception e) {
        PyErr_SetString(PyExc_RuntimeError, e.msg.toStringz);
        return ReturnType!F.init;
    } catch(Error e) {
        import std.conv: text;
        try
            PyErr_SetString(PyExc_RuntimeError, ("FATAL ERROR: " ~ e.text).toStringz);
        catch(Exception _)
            PyErr_SetString(PyExc_RuntimeError, ("FATAL ERROR: " ~ e.msg).toStringz);

        return ReturnType!F.init;
    }
}

// simple, regular version for functions
private auto callDlangFunction(alias F)
                              (PyObject* self, PyObject* args, PyObject* kwargs)
{
    return callDlangFunction!(F, F)(self, args, kwargs);
}

// Takes two functions due to how we're calling methods.
// One is the original function to reflect on, the other
// is the closure that's actually going to be called.
private auto callDlangFunction(alias callable, alias originalFunction)
                              (PyObject* self, PyObject* args, PyObject* kwargs)
{
    import autowrap.reflection: FunctionParameters;
    import python.raw: PyTuple_Size;
    import python.conv: toPython;
    import std.traits: Parameters, variadicFunctionStyle, Variadic;
    import std.conv: text;
    import std.string: toStringz;
    import std.exception: enforce;

    enum numDefaults = NumDefaultParameters!originalFunction;
    enum numRequired = NumRequiredParameters!originalFunction;
    enum isVariadic = variadicFunctionStyle!originalFunction == Variadic.typesafe;

    const numArgs = args is null ? 0 : PyTuple_Size(args);
    if(!isVariadic)
        enforce(numArgs >= numRequired
                && numArgs <= Parameters!originalFunction.length,
                text("Received ", numArgs, " parameters but ",
                     __traits(identifier, originalFunction), " takes ", Parameters!originalFunction.length));

    auto dArgs = pythonArgsToDArgs!(isVariadic, FunctionParameters!originalFunction)(args, kwargs);
    return callDlangFunction!callable(dArgs);
}


private auto callDlangFunction(alias F, A)(auto ref A argTuple) {
    import python.raw: pyIncRef, pyNone;
    import python.conv: toPython;
    import std.traits: ReturnType;

    // TODO - side-effects on parameters?
    static if(is(ReturnType!F == void)) {
        F(argTuple.expand);
        pyIncRef(pyNone);
        return pyNone;
    } else {
        auto dret = F(argTuple.expand);
        return dret.toPython;
    }
}


private template NumDefaultParameters(alias F) {
    import std.meta: Filter;
    import std.traits: ParameterDefaults;

    template notVoid(T...) if(T.length == 1) {
        enum notVoid = !is(T[0] == void);
    }

    enum NumDefaultParameters = Filter!(notVoid, ParameterDefaults!F).length;
}


private template NumRequiredParameters(alias F) {
    import std.traits: Parameters;
    enum NumRequiredParameters = Parameters!F.length - NumDefaultParameters!F;
}

/**
   Creates an instance of a Python class that is equivalent to the D type `T`.
   Return PyObject*.
 */
PyObject* pythonClass(T)(auto ref T dobj) {

    import python.conv: toPython;
    import python.raw: pyObjectNew;

    static if(is(T == class)) {
        if(dobj is null)
            throw new Exception("Cannot create Python class from null D class");
    }

    auto ret = pyObjectNew!(PythonClass!T)(PythonType!T.pyType);

    static foreach(fieldName; PythonType!T.fieldNames) {
        static if(isPublic!(T, fieldName))
            mixin(`ret.`, fieldName, ` = dobj.`, fieldName, `.toPython;`);
    }

    return cast(PyObject*) ret;
}


private template isPublic(T, string memberName) {

    static if(__traits(compiles, __traits(getProtection, __traits(getMember, T, memberName)))) {
        enum protection = __traits(getProtection, __traits(getMember, T, memberName));
        enum isPublic = protection == "public" || protection == "export";
    } else
        enum isPublic = false;
}


/**
   A Python class that mirrors the D type `T`.
   For instance, this struct:
   ----------
   struct Foo {
       int i;
       string s;
   }
   ----------

   Will generate a Python class called `Foo` with two members, and trying to
   assign anything but an integer to `Foo.i` or a string to `Foo.s` in Python
   will raise `TypeError`.
 */
struct PythonClass(T) if(isUserAggregate!T) {
    import python.raw: PyObjectHead, PyGetSetDef;
    import std.traits: Unqual;

    alias fieldNames = PythonType!(Unqual!T).fieldNames;
    alias fieldTypes = PythonType!(Unqual!T).fieldTypes;

    // Every python object must have this
    mixin PyObjectHead;

    // Field members
    // Generate a python object field for every field in T
    static foreach(fieldName; fieldNames) {
        mixin(`PyObject* `, fieldName, `;`);
    }

    // The function pointer for PyGetSetDef.get
    private static extern(C) PyObject* get(int FieldIndex)
                                          (PyObject* self_, void* closure = null)
        nothrow
        in(self_ !is null)
    {
        import python.raw: pyIncRef;

        auto self = cast(PythonClass*) self_;

        auto field = self.getField!FieldIndex;
        assert(field !is null, "Cannot increase reference count on null field");
        pyIncRef(field);

        return field;
    }

    // The function pointer for PyGetSetDef.set
    static extern(C) int set(int FieldIndex)
                            (PyObject* self_, PyObject* value, void* closure = null)
        nothrow
        in(self_ !is null)
    {
        import python.raw: pyIncRef, pyDecRef, PyErr_SetString, PyExc_TypeError;

        if(value is null) {
            enum deleteErrStr = "Cannot delete " ~ fieldNames[FieldIndex];
            PyErr_SetString(PyExc_TypeError, deleteErrStr);
            return -1;
        }

        // FIXME
        // if(!checkPythonType!(fieldTypes[FieldIndex])(value)) {
        //     return -1;
        // }

        auto self = cast(PythonClass!T*) self_;
        auto tmp = self.getField!FieldIndex;

        pyIncRef(value);
        mixin(`self.`, fieldNames[FieldIndex], ` = value;`);
        pyDecRef(tmp);

        return 0;
    }

    PyObject* getField(int FieldIndex)() {
        mixin(`return this.`, fieldNames[FieldIndex], `;`);
    }

    static extern(C) PyObject* propertyGet(alias F)
                                          (PyObject* self_, void* closure = null)
        nothrow
        in(self_ !is null)
    {
        return PythonMethod!(T, F)._py_method_impl(self_, null /*args*/, null /*kwargs*/);
    }

    static extern(C) int propertySet(alias F)
                                    (PyObject* self_, PyObject* value, void* closure = null)
        nothrow
        in(self_ !is null)
    {
        import python.raw: PyTuple_New, PyTuple_SetItem, pyDecRef;

        auto args = PyTuple_New(1);
        PyTuple_SetItem(args, 0, value);
        scope(exit) pyDecRef(args);

        PythonMethod!(T, F)._py_method_impl(self_, args, null /*kwargs*/);

        return 0;
    }
}


private bool checkPythonType(T)(PyObject* value) if(isArray!T) {
    import python.raw: pyListCheck;
    const ret = pyListCheck(value);
    if(!ret) setPyErrTypeString!"list";
    return ret;
}


private bool checkPythonType(T)(PyObject* value) if(isIntegral!T) {
    import python.raw: pyIntCheck, pyLongCheck;
    const ret = pyLongCheck(value) || pyIntCheck(value);
    if(!ret) setPyErrTypeString!"long";
    return ret;
}


private bool checkPythonType(T)(PyObject* value) if(isFloatingPoint!T) {
    import python.raw: pyFloatCheck;
    const ret = pyFloatCheck(value);
    if(!ret) setPyErrTypeString!"float";
    return ret;
}


private bool checkPythonType(T)(PyObject* value) if(is(T == DateTime)) {
    import python.raw: pyDateTimeCheck;
    const ret = pyDateTimeCheck(value);
    if(!ret) setPyErrTypeString!"DateTime";
    return ret;
}


private bool checkPythonType(T)(PyObject* value) if(is(T == Date)) {
    import python.raw: pyDateCheck;
    const ret = pyDateCheck(value);
    if(!ret) setPyErrTypeString!"Date";
    return ret;
}


private void setPyErrTypeString(string type)() @trusted @nogc nothrow {
    import python.raw: PyErr_SetString, PyExc_TypeError;
    enum str = "must be a " ~ type;
    PyErr_SetString(PyExc_TypeError, &str[0]);
}

// Generalises T.init for classes since null isn't a value we want to use
T userAggregateInit(T)() {
    static if(is(T == class)) {
        auto buffer = new void[__traits(classInstanceSize, T)];
        // this is needed for the vtable to work
        buffer[] = typeid(T).initializer[];
        return cast(T) buffer.ptr;
    } else
        return T.init;
}