from pypy.tool.pairtype import pairtype
from pypy.annotation import model as annmodel
from pypy.objspace.flow.model import Constant
from pypy.rpython.rdict import AbstractDictRepr, AbstractDictIteratorRepr,\
     rtype_newdict, dum_variant, dum_keys, dum_values, dum_items
from pypy.rpython.lltypesystem import lltype
from pypy.rlib.rarithmetic import r_uint, intmask
from pypy.rlib.objectmodel import hlinvoke
from pypy.rpython import robject
from pypy.rlib import objectmodel
from pypy.rpython import rmodel
from pypy.rpython.lltypesystem import rffi
from pypy.translator.tool.cbuild import ExternalCompilationInfo

eci = ExternalCompilationInfo(
    includes = ['Judy.h'],
    libraries = ['Judy']
    )

LL_DICT = rffi.VOIDPP

JudyLIns = rffi.llexternal('JudyLIns', [LL_DICT, rffi.VOIDP, lltype.Signed],
                           LL_DICT, compilation_info=eci)
JudyLCount = rffi.llexternal('JudyLCount', [rffi.VOIDP, lltype.Signed,
                                            lltype.Signed,
                                            lltype.Signed], lltype.Signed)

class DictRepr(AbstractDictRepr):
    lowleveltype = LL_DICT
    DICT = lowleveltype
    def __init__(self, rtyper, key_repr, value_repr, dictkey, dictvalue,
                 custom_eq_hash=None):
        self.rtyper = rtyper
        self.key_repr = key_repr()
        self.value_repr = value_repr()


    def rtype_len(self, hop):
        v_dict, = hop.inputargs(self)
        return hop.gendirectcall(ll_dict_len, v_dict)

class __extend__(pairtype(DictRepr, rmodel.Repr)): 
    def rtype_setitem((r_dict, r_key), hop):
        v_dict, v_key, v_value = hop.inputargs(r_dict, r_dict.key_repr, r_dict.value_repr)
        #if r_dict.custom_eq_hash:
        #    hop.exception_is_here()
        #else:
        hop.exception_cannot_occur()
        hop.gendirectcall(ll_dict_setitem, v_dict, v_key, v_value)

def ll_newdict(DICT):
    carray = lltype.malloc(DICT.TO, 1, flavor='raw')
    carray[0] = lltype.nullptr(rffi.VOIDP.TO)
    return carray

def ll_dict_setitem(dict, key, value):
    addr = JudyLIns(dict, rffi.cast(rffi.VOIDP, key), 0)
    addr[0] = rffi.cast(rffi.VOIDP, value)
    
def ll_dict_len(dict):
    return JudyLCount(dict[0], 0, -1, 0)