#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
# 
#   http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

import sys
from proton import _compat
from cerror import Skipped
from cengine import wrap, pn_connection_wrapper

from org.apache.qpid.proton.reactor import Reactor
from org.apache.qpid.proton.engine import BaseHandler, HandlerException

# from proton/reactor.h
def pn_reactor():
    return Reactor.Factory.create()
def pn_reactor_attachments(r):
    return r.attachments()
def pn_reactor_get_global_handler(r):
    return r.getGlobalHandler()
def pn_reactor_set_global_handler(r, h):
    r.setGlobalHandler(h)
def pn_reactor_get_handler(r):
    return r.getHandler()
def pn_reactor_set_handler(r, h):
    r.setHandler(h)
def pn_reactor_set_timeout(r, t):
    r.setTimeout(t)
def pn_reactor_get_timeout(r):
    return r.getTimeout()
def pn_reactor_schedule(r, t, h):
    return r.schedule(t, h)
def pn_reactor_yield(r):
    getattr(r, "yield")()
def pn_reactor_start(r):
    r.start()
def pn_reactor_process(r):
    return peel_handler_exception(r.process)
def pn_reactor_stop(r):
    return peel_handler_exception(r.stop)
def pn_reactor_selectable(r):
    return r.selectable()
def pn_reactor_connection(r, h):
    return wrap(r.connection(h), pn_connection_wrapper)
def pn_reactor_connection_to_host(r, host, port, h):
    return wrap(r.connectionToHost(host, int(port), h),
                pn_connection_wrapper)
def pn_reactor_get_connection_address(r, c):
    return r.getConnectionAddress(c.impl)
def pn_reactor_set_connection_host(r, c, h, p):
    r.setConnectionHost(c.impl, h, int(p))
def pn_reactor_acceptor(r, host, port, handler):
    return r.acceptor(host, int(port), handler)
def pn_reactor_mark(r):
    return r.mark()
def pn_reactor_wakeup(r):
    return r.wakeup()

def peel_handler_exception(meth):
    try:
        return meth()
    except HandlerException, he:
        cause = he.cause
        t = getattr(cause, "type", cause.__class__)
        info = sys.exc_info()
        _compat.raise_(t, cause, info[2]) 

def pn_handler_add(h, c):
    h.add(c)
def pn_handler_dispatch(h, ev, et):
    if et != None and et != ev.impl.type:
      ev.impl.redispatch(et, h)
    else:
      ev.impl.dispatch(h)
def pn_record_set_handler(r, h):
    BaseHandler.setHandler(r, h)
def pn_record_get_handler(r):
    return BaseHandler.getHandler(r)

def pn_task_attachments(t):
    return t.attachments()

def pn_selectable_attachments(s):
    return s.attachments()

def pn_selectable_set_fd(s, fd):
    s.setChannel(fd.getChannel())

def pn_acceptor_close(a):
    a.close()

def pn_task_cancel(t):
    t.cancel()

def pn_object_reactor(o):
    if hasattr(o, "impl"):
        if hasattr(o.impl, "getSession"):
            return o.impl.getSession().getConnection().getReactor()
        elif hasattr(o.impl, "getConnection"):
            return o.impl.getConnection().getReactor()
        else:
            return o.impl.getReactor()
    else:
        return o.getReactor()