from pixie.vm.object import Object, Type, safe_invoke
from pixie.vm.primitives import true
import rpython.rlib.rthread as rthread
from pixie.vm.primitives import nil
import rpython.rlib.rgil as rgil
from pixie.vm.code import as_var
import pixie.vm.rt as rt

from rpython.rlib.objectmodel import invoke_around_extcall

class Bootstrapper(object):
    def __init__(self):
        self._is_inited = False
        #_self.init()

    def init(self):
        if not self._is_inited:
            self._is_inited = True
            self._lock = rthread.allocate_lock()
            rgil.gil_allocate()
            invoke_around_extcall(before_external_call, after_external_call)

    def aquire(self, fn):
        self.init()
        self._lock.acquire(True)
        self._fn = fn

    def fn(self):
        return self._fn

    def release(self):
        self._fn = None
        self._lock.release()


    def _cleanup_(self):
        self._lock = None
        self._is_inited = False


def bootstrap():
    rthread.gc_thread_start()
    fn = bootstrapper.fn()
    bootstrapper.release()
    safe_invoke(fn, [])
    rthread.gc_thread_die()

bootstrapper = Bootstrapper()

@as_var("-thread")
def new_thread(fn):
    bootstrapper.aquire(fn)
    ident = rthread.start_new_thread(bootstrap, ())
    return nil

@as_var("-yield-thread")
def yield_thread():
    do_yield_thread()
    return nil

# Locks

class Lock(Object):
    _type = Type(u"pixie.stdlib.Lock")
    def __init__(self, ll_lock):
        self._ll_lock = ll_lock

    def type(self):
        return Lock._type


@as_var("-create-lock")
def _create_lock():
    return Lock(rthread.allocate_lock())

@as_var("-acquire-lock")
def _acquire_lock(self, no_wait):
    assert isinstance(self, Lock)
    return rt.wrap(self._ll_lock.acquire(no_wait == true))

@as_var("-acquire-lock-timed")
def _acquire_lock(self, ms):
    assert isinstance(self, Lock)
    return rt.wrap(self._ll_lock.acquire(ms.int_val()))

@as_var("-release-lock")
def _release_lock(self):
    assert isinstance(self, Lock)
    return rt.wrap(self._ll_lock.release())



## From PYPY


after_thread_switch = lambda: None     # hook for signal.py

# Fragile code below.  We have to preserve the C-level errno manually...

def before_external_call():
    # this function must not raise, in such a way that the exception
    # transformer knows that it cannot raise!
    rgil.gil_release()
before_external_call._gctransformer_hint_cannot_collect_ = True
before_external_call._dont_reach_me_in_del_ = True

def after_external_call():
    rgil.gil_acquire()
    rthread.gc_thread_run()
    after_thread_switch()
after_external_call._gctransformer_hint_cannot_collect_ = True
after_external_call._dont_reach_me_in_del_ = True

# The _gctransformer_hint_cannot_collect_ hack is needed for
# translations in which the *_external_call() functions are not inlined.
# They tell the gctransformer not to save and restore the local GC
# pointers in the shadow stack.  This is necessary because the GIL is
# not held after the call to before_external_call() or before the call
# to after_external_call().

def do_yield_thread():
    # explicitly release the gil, in a way that tries to give more
    # priority to other threads (as opposed to continuing to run in
    # the same thread).
    if rgil.gil_yield_thread():
        rthread.gc_thread_run()
        after_thread_switch()
do_yield_thread._gctransformer_hint_close_stack_ = True
do_yield_thread._dont_reach_me_in_del_ = True
do_yield_thread._dont_inline_ = True

# do_yield_thread() needs a different hint: _gctransformer_hint_close_stack_.
# The *_external_call() functions are themselves called only from the rffi
# module from a helper function that also has this hint.