# -*- coding: utf-8 -*-

import sys
from fixedint.compat import *
from weakref import WeakValueDictionary

class FixedProperty(object):
    def __init__(self, val, doc):
        self.val = val
        self.__doc__ = doc
    def __get__(self, obj, type=None):
        return self.val
    def __set__(self, obj, value):
        raise AttributeError("property is read-only")

class FixedMetaProperty(object):
    def __init__(self, name, doc):
        self.name = name
        self.__doc__ = doc
    def __get__(self, obj, type=None):
        if self.name not in obj.__dict__:
            # this should only happen when trying to access FixedInt.prop, which help() does
            raise AttributeError("Attribute %s not defined on base class" % self.name)
        prop = obj.__dict__[self.name]
        return prop.__get__(obj)
    def __set__(self, obj, value):
        raise AttributeError("property %s is read-only" % self.name)

if not PY3K:
    # While it'd be nice to put machine-sized integers into Python 2.x "int"s,
    # it turns out that the int methods occasionally freak out when given longs.
    # So, we use arbitrary-precision ints for all Pythons.
    int = long

_class_cache = WeakValueDictionary()

_doc_width = "Bit width of this integer, including the sign bit."
_doc_signed = "True if this integer is a twos-complement signed type."
_doc_mutable = "True if this integer is mutable (modifiable in-place)."
_doc_minval = "Minimum representable value of this integer type"
_doc_maxval = "Maximum representable value of this integer type"

_subclass_token = object()
class _FixedIntBaseMeta(type):
    def __new__(cls, name, bases, dict):
        if dict.get('_subclass_enable', None) == _subclass_token:
            del dict['_subclass_enable']
            return type.__new__(cls, name, bases, dict)

        for base in bases:
            if issubclass(base, FixedInt):
                basename = base.__name__
                raise Exception("Cannot subclass %s; use the %s constructor to produce new subclasses." % (basename, basename))
        raise Exception("Cannot subclass this class.")

    def __call__(self, width, signed=True, mutable=None):
        signed = bool(signed)
        if mutable is None:
            # Take mutable from constructor used (FixedInt or MutableFixedInt)
            mutable = (self == MutableFixedInt)

        cachekey = (width, signed, mutable)
        try:
            return _class_cache[cachekey]
        except KeyError:
            pass
            
        if signed:
            min = -1<<(width-1)
            max = (1<<(width-1))-1
        else:
            min = 0
            max = (1<<width)-1

        if mutable:
            bases = (MutableFixedInt,)
        else:
            bases = (FixedInt, int)

        dict = {}
        dict['width'] = FixedProperty(width, doc=_doc_width)
        dict['signed'] = FixedProperty(signed, doc=_doc_signed)
        dict['mutable'] = FixedProperty(mutable, doc=_doc_mutable)
        dict['minval'] = FixedProperty(min, doc=_doc_minval)
        dict['maxval'] = FixedProperty(max, doc=_doc_maxval)

        if signed:
            _mask1 = (1<<(width-1)) - 1
            _mask2 = 1<<(width-1)
            def _rectify(val):
                return (val & _mask1) - (val & _mask2)
        else:
            _mask = (1<<width) - 1
            def _rectify(val):
                return val & _mask
        dict['_rectify'] = staticmethod(_rectify)

        if not mutable:
            intbase = bases[1]
            def _newfunc(cls, val=0):
                ''' Convert an integer into a fixed-width integer. '''
                return intbase.__new__(cls, _rectify(int(val)))
            _newfunc.__name__ = '__new__'
            dict['__new__'] = _newfunc

        name = ''.join(['Mutable'*mutable, 'U'*(not signed), 'Int', str(width)])

        cls = _FixedIntMeta(name, bases, dict)
        _class_cache[cachekey] = cls
        return cls

    width = FixedMetaProperty('width', doc=_doc_width)
    signed = FixedMetaProperty('signed', doc=_doc_signed)
    mutable = FixedMetaProperty('mutable', doc=_doc_mutable)
    minval = FixedMetaProperty('minval', doc=_doc_minval)
    maxval = FixedMetaProperty('maxval', doc=_doc_maxval)

class _FixedIntMeta(_FixedIntBaseMeta):
    __new__ = type.__new__
    __call__ = type.__call__


def int_method(f):
    if isinstance(f, str):
        def wrapper(f2):
            f2.__name__ = f
            return int_method(f2)
        return wrapper
    else:
        f.__doc__ = getattr(int, f.__name__).__doc__
        return f

class FixedInt:
    __slots__ = ()
    _subclass_enable = _subclass_token

    # width, signed, mutable, minval, maxval defined in metaclass
    # _rectify defined in metaclass
    # __new__ defined in metaclass

    if not PY3K:
        @int_method
        def __hex__(self):
            return '%#x' % int(self)
        def __oct__(self):
            return '%#o' % int(self)

    @int_method
    def __pow__(self, other, modulo=None):
        # Jython can't handle int.__pow__(x, y, None)
        if modulo is None:
            return type(self)(int.__pow__(int(self), int(other)))
        return type(self)(int.__pow__(int(self), int(other), modulo))

    @int_method
    def __rpow__(self, other):
        return type(other)(int.__rpow__(int(self), int(other)))

    @int_method
    def __repr__(self):
        return '%s(%s)' % (type(self).__name__, self)

    @int_method
    def __str__(self):
        return str(int(self))

    @classmethod
    def _canonicalize_index(cls, idx):
        if idx < 0:
            idx += cls.width
        return idx

    @classmethod
    def _canonicalize_slice(cls, slice):
        start = slice.start
        stop = slice.stop

        if slice.step is not None:
            raise ValueError("slice step unsupported")

        if start is None:
            start = 0
        else:
            start = cls._canonicalize_index(start)

        if stop is None:
            stop = cls.width
        elif isinstance(stop, complex):
            if stop.real:
                raise ValueError("invalid slice stop: must be integer or pure-imaginary complex number")
            stop = int(stop.imag) + start
        else:
            stop = cls._canonicalize_index(stop)

        if 0 <= start < stop <= cls.width:
            return (start, stop)
        else:
            raise IndexError("invalid slice %d:%d" % (start, stop))

    def __getitem__(self, item):
        ''' Slice the bits of an integer.

        x[a] gets a single bit at position a, returning a bool.
        x[a:b] gets a range of bits as a FixedInt.

        For slice notation, b may be of the form 'bj' (a complex number) to treat it
        as a length rather than a stop index.
        The result will be of the type UIntX, where X is the number of bits in the range.

        Examples:
        x[0]: equal to (x & 1)
        x[1:5] or x[1:4j]: equal to (x & 31) >> 1
        x[:5]: equal to (x & 31)
        '''

        if isinstance(item, slice):
            start, stop = self._canonicalize_slice(item)
            return FixedInt(stop - start, signed=False)(int(self) >> start)
        else:
            item = self._canonicalize_index(item)
            if 0 <= item < self.width:
                return bool(int(self) & (1 << item))
            else:
                raise IndexError("index %d out of range" % item)

    def to_bytes(self, length=None, byteorder=sys.byteorder):
        if length is None:
            length = (self.width + 7) // 8
        try:
            return int(self).to_bytes(length, byteorder=byteorder, signed=self.signed)
        except (OverflowError, AttributeError):
            pass

        val = int(self) & ((1 << (length * 8)) - 1)
        out = []
        while length > 0:
            out.append(val & 0xff)
            val >>= 8
            length -= 1
        if byteorder == 'big':
            out = reversed(out)
        if PY3K:
            return bytes(out)
        else:
            return ''.join(map(chr, out))

    @classmethod
    def from_bytes(cls, bytes, byteorder=sys.byteorder, signed=None):
        if cls in (FixedInt, MutableFixedInt):
            if signed is None:
                signed = False
        elif signed is None:
                signed = cls.signed
        else:
            raise ValueError("can't set signed with a concrete FixedInt")

        blen = len(bytes)
        try:
            val = int.from_bytes(bytes, byteorder=byteorder, signed=signed)
        except AttributeError:
            val = 0
            if byteorder == 'big':
                bytes = reversed(bytes)
            if PY3K:
                for i,c in enumerate(bytes):
                    val |= c << (8 * i)
            else:
                for i,c in enumerate(bytes):
                    val |= ord(c) << (8 * i)

        if cls in (FixedInt, MutableFixedInt):
            return cls(blen*8, signed=signed)(val)
        else:
            return cls(val)

    if PY3K:
        @int_method
        def __round__(self, n=0):
            return int(self)

    # Inherited methods which are fine as-is:
    # complex, int, long, float, index
    # truediv, rtruediv, divmod, rdivmod, rlshift, rrshift
    # format

FixedInt = add_metaclass(_FixedIntBaseMeta)(FixedInt)


class MutableFixedInt(FixedInt):
    _subclass_enable = _subclass_token

    def __init__(self, val=0, base=None):
        ''' Convert an integer into a fixed-width integer. '''
        if base is None:
            val = int(val)
        else:
            val = int(val, base)

        self._val = self._rectify(val)

    if PY3K:
        @int_method
        def __format__(self, format_spec):
            return format(self._val, format_spec)

    def __ipow__(self, other, modulo=None):
        if modulo is None:
            self._val = self._rectify(int.__pow__(int(self), int(other)))
        else:
            self._val = self._rectify(int.__pow__(int(self), int(other), modulo))
        return self

    def __setitem__(self, item, value):
        ''' Modify a slice of an integer.

        x[a]=y sets a single bit at position a.
        x[a:b]=y sets a range of bits from an integer.

        See __getitem__ for more details on the slice notation.
        '''

        value = int(value)
        if isinstance(item, slice):
            start, stop = self._canonicalize_slice(item)
            mask = (1 << (stop - start)) - 1
            self._val = (self._val & ~(mask << start)) | ((value & mask) << start)
        else:
            item = self._canonicalize_index(item)
            if 0 <= item < self.width:
                if value:
                    self._val |= (1 << item)
                else:
                    self._val &= ~(1 << item)
                return bool(int(self) & (1 << item))
            else:
                raise IndexError("index %d out of range" % item)

## Arithmetic methods
def _arith_unary_factory(name, mutable):
    ''' Factory function producing methods for unary operations. '''
    intfunc = getattr(int, name)
    if mutable:
        @int_method(name)
        def _f(self):
            return type(self)(intfunc(self._val))
    else:
        @int_method(name)
        def _f(self):
            return type(self)(intfunc(self))
    return _f

_arith_unary = 'neg pos abs invert'.split()
for f in _arith_unary:
    s = '__%s__' % f
    setattr(FixedInt, s, _arith_unary_factory(s, mutable=False))
    setattr(MutableFixedInt, s, _arith_unary_factory(s, mutable=True))


def _arith_convert(t1, t2):
    if not issubclass(t2, FixedInt):
        return t1

    # Follow C conversion rules (ISO/IEC 9899:TC3 §6.3.1.8)
    if t1.signed == t2.signed:
        # If both are signed or both are unsigned, return the larger type.
        if t1.width >= t2.width:
            return t1
        return t2

    if not t1.signed:
        ut, st = t1, t2
    else:
        ut, st = t2, t1

    if ut.width >= st.width:
        # If the unsigned type has rank >= the signed type, convert the signed type to the unsigned type.
        return ut
    else:
        return st

def _arith_binfunc_factory(name):
    ''' Factory function producing methods for arithmetic operators '''
    intfunc = getattr(int, name)
    @int_method(name)
    def _f(self, other):
        nt = _arith_convert(type(self), type(other))
        return nt(intfunc(int(self), int(other)))
    return _f

# divmod, rdivmod, truediv, rtruediv are considered non-arithmetic since they don't return ints
# pow, rpow, rlshift, and rrshift are special since the LHS and RHS are very different
_arith_binfunc = 'add sub mul floordiv mod lshift rshift and xor or'.split()
_arith_binfunc += 'radd rsub rmul rfloordiv rmod rand rxor ror'.split()
if not PY3K:
    _arith_binfunc += 'div rdiv'.split()

for f in _arith_binfunc:
    s = '__%s__' % f
    setattr(FixedInt, s, _arith_binfunc_factory(s))


## Non-arithmetic methods (Mutable only)
def _nonarith_unary_factory_mutable(name):
    ''' Factory function producing methods for unary operations. '''
    intfunc = getattr(int, name)
    @int_method(name)
    def _f(self):
        return intfunc(self._val)
    return _f

_mutable_unary = 'int float'.split()
if sys.version_info[:2] >= (2,5):
    _mutable_unary += ['index']
if sys.version_info[:2] >= (2,6):
    _mutable_unary += ['trunc']
if PY3K:
    _mutable_unary += 'bool'.split()
else:
    _mutable_unary += 'nonzero long'.split()

for f in _mutable_unary:
    s = '__%s__' % f
    setattr(MutableFixedInt, s, _nonarith_unary_factory_mutable(s))


def _nonarith_binfunc_factory_mutable(name):
    ''' Factory function producing methods for non-arithmetic binary operators on Mutable instances. '''
    intfunc = getattr(int, name)
    @int_method(name)
    def _f(self, other):
        return intfunc(self._val, int(other))
    return _f

_mutable_binfunc = 'truediv rtruediv divmod rdivmod rlshift rrshift'.split()
if hasattr(int, '__cmp__'):
    _mutable_binfunc += ['cmp']
else:
    _mutable_binfunc += 'lt le eq ne gt ge'.split()
for f in _mutable_binfunc:
    s = '__%s__' % f
    setattr(MutableFixedInt, s, _nonarith_binfunc_factory_mutable(s))


## In-place operators
def _inplace_factory_mutable(iname, name, op):
    ''' Factory function producing methods for augmented assignments on Mutable instances. '''
    # This uses compiled operators instead of an int.__X__ function call for speed.
    # Measured improvement is about 15% speed increase.
    exec("""
def _f(self, other):
    self._val = self._rectify(self._val %s int(other))
    return self
globals()['_f'] = _f""" % op)
    _f.__name__ = iname
    doc = list.__iadd__.__doc__
    if doc:
        _f.__doc__ = doc.replace('__iadd__', name).replace('+=', op+'=')
    return _f

# pow is special because it takes three arguments.
_inplace_func = 'add,+ sub,- mul,* truediv,/ floordiv,// mod,% lshift,<< rshift,<< and,& or,| xor,^'.split()
if not PY3K:
    _inplace_func += ['div,/']
for f in _inplace_func:
    fn, op = f.split(',')
    si = '__i%s__' % fn
    so = '__%s__' % fn
    setattr(MutableFixedInt, si, _inplace_factory_mutable(si, so, op))