"""The builtin object type implementation"""

from pypy.interpreter.baseobjspace import W_Root
from pypy.interpreter.error import OperationError, oefmt
from pypy.interpreter.gateway import applevel, interp2app, unwrap_spec
from pypy.interpreter.typedef import (
    GetSetProperty, TypeDef, default_identity_hash)
from pypy.objspace.descroperation import Object
from pypy.interpreter.function import StaticMethod

from rpython.rlib.objectmodel import specialize


app = applevel(r'''
import sys

def _abstract_method_error(typ):
    methods = ", ".join(sorted(typ.__abstractmethods__))
    method_s = 's' if len(typ.__abstractmethods__) > 1 else ''
    err = "Can't instantiate abstract class %s with abstract method%s %s"
    raise TypeError(err % (typ.__name__, method_s, methods))

def reduce_1(obj, proto):
    import copyreg
    return copyreg._reduce_ex(obj, proto)

def reduce_2(obj, proto, args, kwargs):
    cls = obj.__class__

    if not hasattr(type(obj), "__new__"):
        raise TypeError("can't pickle %s objects" % type(obj).__name__)

    try:
        copyreg = sys.modules['copyreg']
    except KeyError:
        import copyreg

    if not isinstance(args, tuple):
        raise TypeError("__getnewargs__ should return a tuple")
    if not kwargs:
       newobj = copyreg.__newobj__
       args2 = (cls,) + args
    else:
       newobj = copyreg.__newobj_ex__
       args2 = (cls, args, kwargs)
    state = obj.__getstate__()
    listitems = iter(obj) if isinstance(obj, list) else None
    dictitems = iter(obj.items()) if isinstance(obj, dict) else None

    return newobj, args2, state, listitems, dictitems


def get_slotvalues(obj):
    names = slotnames(obj.__class__)
    if not names:
        return None
    slots = {}
    for name in names:
        try:
            value = getattr(obj, name)
        except AttributeError:
            pass
        else:
            slots[name] =  value
    return slots


def slotnames(cls):
    if not isinstance(cls, type):
        return None

    try:
        return cls.__dict__["__slotnames__"]
    except KeyError:
        pass

    try:
        copyreg = sys.modules['copyreg']
    except KeyError:
        import copyreg
    slotnames = copyreg._slotnames(cls)
    if not isinstance(slotnames, list) and slotnames is not None:
        raise TypeError("copyreg._slotnames didn't return a list or None")
    return slotnames
''', filename=__file__)

_abstract_method_error = app.interphook("_abstract_method_error")
reduce_1 = app.interphook('reduce_1')
reduce_2 = app.interphook('reduce_2')
get_slotvalues = app.interphook('get_slotvalues')


class W_ObjectObject(W_Root):
    """Instances of this class are what the user can directly see with an
    'object()' call."""


def _excess_args(__args__):
    return bool(__args__.arguments_w) or bool(__args__.keyword_names_w)

@specialize.memo()
def _object_new(space):
    "Utility that returns the function object.__new__."
    w_x = space.lookup_in_type(space.w_object, '__new__')
    assert isinstance(w_x, StaticMethod)
    return w_x.w_function

@specialize.memo()
def _object_init(space):
    "Utility that returns the function object.__init__."
    return space.lookup_in_type(space.w_object, '__init__')

def _same_static_method(space, w_x, w_y):
    # pff pff pff
    if isinstance(w_x, StaticMethod): w_x = w_x.w_function
    return space.is_w(w_x, w_y)

def descr__new__(space, w_type, __args__):
    from pypy.objspace.std.typeobject import _precheck_for_new
    w_type = _precheck_for_new(space, w_type)

    if _excess_args(__args__):
        tp_new = space.lookup_in_type(w_type, '__new__')
        tp_init = space.lookup_in_type(w_type, '__init__')
        if not _same_static_method(space, tp_new, _object_new(space)):
            raise oefmt(space.w_TypeError,
                    "object.__new__() takes exactly one argument (the type to instantiate)")
        if space.is_w(tp_init, _object_init(space)):
            raise oefmt(space.w_TypeError,
                        "%s() takes no arguments", w_type.name)
    if w_type.is_abstract():
        _abstract_method_error(space, w_type)
    return space.allocate_instance(W_ObjectObject, w_type)


def descr___subclasshook__(space, __args__):
    return space.w_NotImplemented

def descr___init_subclass__(space, w_cls):
    return space.w_None

def descr__init__(space, w_obj, __args__):
    if _excess_args(__args__):
        w_type = space.type(w_obj)
        tp_new = space.lookup_in_type(w_type, '__new__')
        tp_init = space.lookup_in_type(w_type, '__init__')
        if not space.is_w(tp_init, _object_init(space)):
            raise oefmt(space.w_TypeError,
                        "object.__init__() takes exactly one argument (the instance to initialize)")
        elif _same_static_method(space, tp_new, _object_new(space)):
            raise oefmt(space.w_TypeError,
                        "%T.__init__() takes exactly one argument (the instance to initialize)",
                        w_obj)


def descr_get___class__(space, w_obj):
    return space.type(w_obj)


def descr_set___class__(space, w_obj, w_newcls):
    from pypy.objspace.std.typeobject import W_TypeObject
    from pypy.interpreter.module import Module
    #
    if not isinstance(w_newcls, W_TypeObject):
        raise oefmt(space.w_TypeError,
                    "__class__ must be set to a class, not '%T' "
                    "object", w_newcls)
    if not (w_newcls.is_heaptype() or
            w_newcls is space.gettypeobject(Module.typedef)):
        raise oefmt(space.w_TypeError,
                    "__class__ assignment only supported for heap types "
                    "or ModuleType subclasses")
    w_oldcls = space.type(w_obj)
    assert isinstance(w_oldcls, W_TypeObject)
    if (w_oldcls.get_full_instance_layout() ==
        w_newcls.get_full_instance_layout()):
        w_obj.setclass(space, w_newcls)
    else:
        raise oefmt(space.w_TypeError,
                    "__class__ assignment: '%N' object layout differs from "
                    "'%N'", w_oldcls, w_newcls)


def descr__repr__(space, w_obj):
    classname = space.getfulltypename(w_obj)
    return w_obj.getrepr(space, '%s object' % (classname,))


def descr__str__(space, w_obj):
    w_type = space.type(w_obj)
    w_impl = w_type.lookup("__repr__")
    if w_impl is None:
        # can it really occur?
        raise oefmt(space.w_TypeError, "operand does not support unary str")
    return space.get_and_call_function(w_impl, w_obj)


def _getnewargs(space, w_obj):
    w_descr = space.lookup(w_obj, '__getnewargs_ex__')
    hasargs = True
    if w_descr is not None:
        w_result = space.get_and_call_function(w_descr, w_obj)
        if not space.isinstance_w(w_result, space.w_tuple):
            raise oefmt(space.w_TypeError,
                "__getnewargs_ex__ should return a tuple, not '%T'", w_result)
        n = space.len_w(w_result)
        if n != 2:
            raise oefmt(space.w_ValueError,
                "__getnewargs_ex__ should return a tuple of length 2, not %d",
                n)
        w_args, w_kwargs = space.fixedview(w_result, 2)
        if not space.isinstance_w(w_args, space.w_tuple):
            raise oefmt(space.w_TypeError,
                "first item of the tuple returned by __getnewargs_ex__ must "
                "be a tuple, not '%T'", w_args)
        if not space.isinstance_w(w_kwargs, space.w_dict):
            raise oefmt(space.w_TypeError,
                "second item of the tuple returned by __getnewargs_ex__ must "
                "be a dict, not '%T'", w_kwargs)
    else:
        w_descr = space.lookup(w_obj, '__getnewargs__')
        if w_descr is not None:
            w_args = space.get_and_call_function(w_descr, w_obj)
            if not space.isinstance_w(w_args, space.w_tuple):
                raise oefmt(space.w_TypeError,
                    "__getnewargs__ should return a tuple, not '%T'", w_args)
        else:
            hasargs = False
            w_args = space.newtuple([])
        w_kwargs = space.w_None
    return hasargs, w_args, w_kwargs

def descr__getstate__(space, w_obj):
    """Helper for pickle"""
    return object_getstate_default(space, w_obj, 0)

def descr__reduce__(space, w_obj):
    """Helper for pickle"""
    w_proto = space.newint(0)
    return reduce_1(space, w_obj, w_proto)

def object_getstate_default(space, w_obj, required):
    w_obj_type = space.type(w_obj)
    if required and w_obj_type.layout.typedef.variable_sized:
        # never reached, required is always 0?
        raise oefmt(space.w_TypeError, "cannot pickle %N objects", w_obj)
    w_objdict = space.findattr(w_obj, space.newtext("__dict__"))
    if w_objdict and space.len_w(w_objdict) > 0:
        w_ret = space.call_method(w_objdict, 'copy')
    else:
        w_ret = space.w_None
    w_slots = get_slotvalues(space, w_obj)
    if w_slots is not space.w_None:
        w_ret = space.newtuple([w_ret, w_slots])
    return w_ret

@unwrap_spec(proto=int)
def descr__reduce_ex__(space, w_obj, proto):
    """Helper for pickle"""
    w_st_reduce = space.newtext('__reduce__')
    w_reduce = space.findattr(w_obj, w_st_reduce)
    if w_reduce is not None:
        # Check if __reduce__ has been overridden:
        # "type(obj).__reduce__ is not object.__reduce__"
        w_cls_reduce = space.getattr(space.type(w_obj), w_st_reduce)
        w_obj_reduce = space.getattr(space.w_object, w_st_reduce)
        override = not space.is_w(w_cls_reduce, w_obj_reduce)
        if override:
            return space.call_function(w_reduce)
    w_proto = space.newint(proto)
    if proto >= 2:
        hasargs, w_args, w_kwargs = _getnewargs(space, w_obj)
        w_getstate = space.lookup(w_obj, '__get_state__')
        if w_getstate is None:
            required = (not hasargs and
                not space.isinstance_w(w_obj, space.w_list) and
                not space.isinstance_w(w_obj, space.w_dict))
            w_obj_type = space.type(w_obj)
            if required and w_obj_type.layout.typedef.variable_sized:
                raise oefmt(
                    space.w_TypeError, "cannot pickle %N objects", w_obj_type)
        return reduce_2(space, w_obj, w_proto, w_args, w_kwargs)
    return reduce_1(space, w_obj, w_proto)

def descr___format__(space, w_obj, w_format_spec):
    if space.isinstance_w(w_format_spec, space.w_unicode):
        w_as_str = space.call_function(space.w_unicode, w_obj)
    elif space.isinstance_w(w_format_spec, space.w_bytes):
        w_as_str = space.str(w_obj)
    else:
        raise oefmt(space.w_TypeError, "format_spec must be a string")
    if space.len_w(w_format_spec) > 0:
        raise oefmt(space.w_TypeError,
                     "unsupported format string passed to %T.__format__",
                     w_obj);
    return space.format(w_as_str, w_format_spec)

def descr__eq__(space, w_self, w_other):
    if space.is_w(w_self, w_other):
        return space.w_True
    # Return NotImplemented instead of False, so if two objects are
    # compared, both get a chance at the comparison (issue #1393)
    return space.w_NotImplemented

def descr__ne__(space, w_self, w_other):
    # By default, __ne__() delegates to __eq__() and inverts the result,
    # unless the latter returns NotImplemented.
    w_eq = space.lookup(w_self, '__eq__')
    w_res = space.get_and_call_function(w_eq, w_self, w_other)
    if space.is_w(w_res, space.w_NotImplemented):
        return w_res
    return space.not_(w_res)

def descr_richcompare(space, w_self, w_other):
    return space.w_NotImplemented

def descr__dir__(space, w_obj):
    from pypy.objspace.std.util import _objectdir
    return space.call_function(space.w_list, _objectdir(space, w_obj))

class ObjectObjectDocstrings:

    def __new__():
        """T.__new__(S, ...) -> a new object with type S, a subtype of T"""

    def __subclasshook__():
        """Abstract classes can override this to customize issubclass().

        This is invoked early on by abc.ABCMeta.__subclasscheck__().
        It should return True, False or NotImplemented.  If it returns
        NotImplemented, the normal algorithm is used.  Otherwise, it
        overrides the normal algorithm (and the outcome is cached).
        """

    def __hash__():
        """x.__hash__() <==> hash(x)"""

    def __setattr__():
        """x.__setattr__('name', value) <==> x.name = value"""

    def __getattribute__():
        """"x.__getattribute__('name') <==> x.name"""

    def __delattr__():
        """x.__delattr__('name') <==> del x.name"""

    def __init__():
        """x.__init__(...) initializes x; see help(type(x)) for signature."""

    def __class__():
        """type(object) -> the object's type
        type(name, bases, dict) -> a new type"""

    def __repr__():
        """x.__repr__() <==> repr(x)"""

    def __str__():
        """x.__str__() <==> str(x)"""

    def __reduce__():
        """helper for pickle"""

    def __reduce_ex__():
        """helper for pickle"""

    def __format__():
        """default object formatter"""

W_ObjectObject.typedef = TypeDef("object",
    __rpython_level_class__ = W_ObjectObject,
    _text_signature_='()',
    __doc__ = "The most base type",
    __new__ = interp2app(descr__new__,
                         doc=ObjectObjectDocstrings.__new__.__doc__),
    __subclasshook__ = interp2app(descr___subclasshook__, as_classmethod=True,
                                  doc=ObjectObjectDocstrings.__subclasshook__.__doc__),
    __init_subclass__ = interp2app(descr___init_subclass__, as_classmethod=True),

    # these are actually implemented in pypy.objspace.descroperation
    __getattribute__ = interp2app(Object.descr__getattribute__.im_func,
                                  doc=ObjectObjectDocstrings.__getattribute__.__doc__),
    __setattr__ = interp2app(Object.descr__setattr__.im_func,
                             doc=ObjectObjectDocstrings.__setattr__.__doc__),
    __delattr__ = interp2app(Object.descr__delattr__.im_func,
                             doc=ObjectObjectDocstrings.__delattr__.__doc__),

    __getstate__ = interp2app(descr__getstate__),
    __init__ = interp2app(descr__init__,
                          doc=ObjectObjectDocstrings.__init__.__doc__),
    __class__ = GetSetProperty(descr_get___class__, descr_set___class__,
                               doc=ObjectObjectDocstrings.__class__.__doc__),
    __repr__ = interp2app(descr__repr__,
                          doc=ObjectObjectDocstrings.__repr__.__doc__),
    __str__ = interp2app(descr__str__,
                         doc=ObjectObjectDocstrings.__str__.__doc__),
    __hash__ = interp2app(default_identity_hash,
                          doc=ObjectObjectDocstrings.__hash__.__doc__),
    __reduce__ = interp2app(descr__reduce__,
                            doc=ObjectObjectDocstrings.__reduce__.__doc__),
    __reduce_ex__ = interp2app(descr__reduce_ex__,
                               doc=ObjectObjectDocstrings.__reduce_ex__.__doc__),
    __format__ = interp2app(descr___format__,
                            doc=ObjectObjectDocstrings.__format__.__doc__),
    __dir__ = interp2app(descr__dir__),

    __eq__ = interp2app(descr__eq__),
    __ne__ = interp2app(descr__ne__),
    __le__ = interp2app(descr_richcompare),
    __lt__ = interp2app(descr_richcompare),
    __ge__ = interp2app(descr_richcompare),
    __gt__ = interp2app(descr_richcompare),
)