import traceback
from functools import wraps
from . import exception
from . import flavor, peel, is_event, chat_flavors, inline_flavors

def _wrap_none(fn):
    def w(*args, **kwargs):
        try:
            return fn(*args, **kwargs)
        except (KeyError, exception.BadFlavor):
            return None
    return w

def per_chat_id(types='all'):
    """
    :param types:
        ``all`` or a list of chat types (``private``, ``group``, ``channel``)

    :return:
        a seeder function that returns the chat id only if the chat type is in ``types``.
    """
    return _wrap_none(lambda msg:
                          msg['chat']['id']
                          if types == 'all' or msg['chat']['type'] in types
                          else None)

def per_chat_id_in(s, types='all'):
    """
    :param s:
        a list or set of chat id

    :param types:
        ``all`` or a list of chat types (``private``, ``group``, ``channel``)

    :return:
        a seeder function that returns the chat id only if the chat id is in ``s``
        and chat type is in ``types``.
    """
    return _wrap_none(lambda msg:
                          msg['chat']['id']
                          if (types == 'all' or msg['chat']['type'] in types) and msg['chat']['id'] in s
                          else None)

def per_chat_id_except(s, types='all'):
    """
    :param s:
        a list or set of chat id

    :param types:
        ``all`` or a list of chat types (``private``, ``group``, ``channel``)

    :return:
        a seeder function that returns the chat id only if the chat id is *not* in ``s``
        and chat type is in ``types``.
    """
    return _wrap_none(lambda msg:
                          msg['chat']['id']
                          if (types == 'all' or msg['chat']['type'] in types) and msg['chat']['id'] not in s
                          else None)

def per_from_id(flavors=chat_flavors+inline_flavors):
    """
    :param flavors:
        ``all`` or a list of flavors

    :return:
        a seeder function that returns the from id only if the message flavor is
        in ``flavors``.
    """
    return _wrap_none(lambda msg:
                          msg['from']['id']
                          if flavors == 'all' or flavor(msg) in flavors
                          else None)

def per_from_id_in(s, flavors=chat_flavors+inline_flavors):
    """
    :param s:
        a list or set of from id

    :param flavors:
        ``all`` or a list of flavors

    :return:
        a seeder function that returns the from id only if the from id is in ``s``
        and message flavor is in ``flavors``.
    """
    return _wrap_none(lambda msg:
                          msg['from']['id']
                          if (flavors == 'all' or flavor(msg) in flavors) and msg['from']['id'] in s
                          else None)

def per_from_id_except(s, flavors=chat_flavors+inline_flavors):
    """
    :param s:
        a list or set of from id

    :param flavors:
        ``all`` or a list of flavors

    :return:
        a seeder function that returns the from id only if the from id is *not* in ``s``
        and message flavor is in ``flavors``.
    """
    return _wrap_none(lambda msg:
                          msg['from']['id']
                          if (flavors == 'all' or flavor(msg) in flavors) and msg['from']['id'] not in s
                          else None)

def per_inline_from_id():
    """
    :return:
        a seeder function that returns the from id only if the message flavor
        is ``inline_query`` or ``chosen_inline_result``
    """
    return per_from_id(flavors=inline_flavors)

def per_inline_from_id_in(s):
    """
    :param s: a list or set of from id
    :return:
        a seeder function that returns the from id only if the message flavor
        is ``inline_query`` or ``chosen_inline_result`` and the from id is in ``s``.
    """
    return per_from_id_in(s, flavors=inline_flavors)

def per_inline_from_id_except(s):
    """
    :param s: a list or set of from id
    :return:
        a seeder function that returns the from id only if the message flavor
        is ``inline_query`` or ``chosen_inline_result`` and the from id is *not* in ``s``.
    """
    return per_from_id_except(s, flavors=inline_flavors)

def per_application():
    """
    :return:
        a seeder function that always returns 1, ensuring at most one delegate is ever spawned
        for the entire application.
    """
    return lambda msg: 1

def per_message(flavors='all'):
    """
    :param flavors: ``all`` or a list of flavors
    :return:
        a seeder function that returns a non-hashable only if the message flavor
        is in ``flavors``.
    """
    return _wrap_none(lambda msg: [] if flavors == 'all' or flavor(msg) in flavors else None)

def per_event_source_id(event_space):
    """
    :return:
        a seeder function that returns an event's source id only if that event's
        source space equals to ``event_space``.
    """
    def f(event):
        if is_event(event):
            v = peel(event)
            if v['source']['space'] == event_space:
                return v['source']['id']
            else:
                return None
        else:
            return None
    return _wrap_none(f)

def per_callback_query_chat_id(types='all'):
    """
    :param types:
        ``all`` or a list of chat types (``private``, ``group``, ``channel``)

    :return:
        a seeder function that returns a callback query's originating chat id
        if the chat type is in ``types``.
    """
    def f(msg):
        if (flavor(msg) == 'callback_query' and 'message' in msg
            and (types == 'all' or msg['message']['chat']['type'] in types)):
            return msg['message']['chat']['id']
        else:
            return None
    return f

def per_callback_query_origin(origins='all'):
    """
    :param origins:
        ``all`` or a list of origin types (``chat``, ``inline``)

    :return:
        a seeder function that returns a callback query's origin identifier if
        that origin type is in ``origins``. The origin identifier is guaranteed
        to be a tuple.
    """
    def f(msg):
        def origin_type_ok():
            return (origins == 'all'
                or ('chat' in origins and 'message' in msg)
                or ('inline' in origins and 'inline_message_id' in msg))

        if flavor(msg) == 'callback_query' and origin_type_ok():
            if 'inline_message_id' in msg:
                return msg['inline_message_id'],
            else:
                return msg['message']['chat']['id'], msg['message']['message_id']
        else:
            return None
    return f

def per_invoice_payload():
    """
    :return:
        a seeder function that returns the invoice payload.
    """
    def f(msg):
        if 'successful_payment' in msg:
            return msg['successful_payment']['invoice_payload']
        else:
            return msg['invoice_payload']

    return _wrap_none(f)

def call(func, *args, **kwargs):
    """
    :return:
        a delegator function that returns a tuple (``func``, (seed tuple,)+ ``args``, ``kwargs``).
        That is, seed tuple is inserted before supplied positional arguments.
        By default, a thread wrapping ``func`` and all those arguments is spawned.
    """
    def f(seed_tuple):
        return func, (seed_tuple,)+args, kwargs
    return f

def create_run(cls, *args, **kwargs):
    """
    :return:
        a delegator function that calls the ``cls`` constructor whose arguments being
        a seed tuple followed by supplied ``*args`` and ``**kwargs``, then returns
        the object's ``run`` method. By default, a thread wrapping that ``run`` method
        is spawned.
    """
    def f(seed_tuple):
        j = cls(seed_tuple, *args, **kwargs)
        return j.run
    return f

def create_open(cls, *args, **kwargs):
    """
    :return:
        a delegator function that calls the ``cls`` constructor whose arguments being
        a seed tuple followed by supplied ``*args`` and ``**kwargs``, then returns
        a looping function that uses the object's ``listener`` to wait for messages
        and invokes instance method ``open``, ``on_message``, and ``on_close`` accordingly.
        By default, a thread wrapping that looping function is spawned.
    """
    def f(seed_tuple):
        j = cls(seed_tuple, *args, **kwargs)

        def wait_loop():
            bot, msg, seed = seed_tuple
            try:
                handled = j.open(msg, seed)
                if not handled:
                    j.on_message(msg)

                while 1:
                    msg = j.listener.wait()
                    j.on_message(msg)

            # These exceptions are "normal" exits.
            except (exception.IdleTerminate, exception.StopListening) as e:
                j.on_close(e)

            # Any other exceptions are accidents. **Print it out.**
            # This is to prevent swallowing exceptions in the case that on_close()
            # gets overridden but fails to account for unexpected exceptions.
            except Exception as e:
                traceback.print_exc()
                j.on_close(e)

        return wait_loop
    return f

def until(condition, fns):
    """
    Try a list of seeder functions until a condition is met.

    :param condition:
        a function that takes one argument - a seed - and returns ``True``
        or ``False``

    :param fns:
        a list of seeder functions

    :return:
        a "composite" seeder function that calls each supplied function in turn,
        and returns the first seed where the condition is met. If the condition
        is never met, it returns ``None``.
    """
    def f(msg):
        for fn in fns:
            seed = fn(msg)
            if condition(seed):
                return seed
        return None
    return f

def chain(*fns):
    """
    :return:
        a "composite" seeder function that calls each supplied function in turn,
        and returns the first seed that is not ``None``.
    """
    return until(lambda seed: seed is not None, fns)

def _ensure_seeders_list(fn):
    @wraps(fn)
    def e(seeders, *aa, **kw):
        return fn(seeders if isinstance(seeders, list) else [seeders], *aa, **kw)
    return e

@_ensure_seeders_list
def pair(seeders, delegator_factory, *args, **kwargs):
    """
    The basic pair producer.

    :return:
        a (seeder, delegator_factory(\*args, \*\*kwargs)) tuple.

    :param seeders:
        If it is a seeder function or a list of one seeder function, it is returned
        as the final seeder. If it is a list of more than one seeder function, they
        are chained together before returned as the final seeder.
    """
    return (chain(*seeders) if len(seeders) > 1 else seeders[0],
            delegator_factory(*args, **kwargs))

def _natural_numbers():
    x = 0
    while 1:
        x += 1
        yield x

_event_space = _natural_numbers()

def pave_event_space(fn=pair):
    """
    :return:
        a pair producer that ensures the seeder and delegator share the same event space.
    """
    global _event_space
    event_space = next(_event_space)

    @_ensure_seeders_list
    def p(seeders, delegator_factory, *args, **kwargs):
        return fn(seeders + [per_event_source_id(event_space)],
                  delegator_factory, *args, event_space=event_space, **kwargs)
    return p

def include_callback_query_chat_id(fn=pair, types='all'):
    """
    :return:
        a pair producer that enables static callback query capturing
        across seeder and delegator.

    :param types:
        ``all`` or a list of chat types (``private``, ``group``, ``channel``)
    """
    @_ensure_seeders_list
    def p(seeders, delegator_factory, *args, **kwargs):
        return fn(seeders + [per_callback_query_chat_id(types=types)],
                  delegator_factory, *args, include_callback_query=True, **kwargs)
    return p

from . import helper

def intercept_callback_query_origin(fn=pair, origins='all'):
    """
    :return:
        a pair producer that enables dynamic callback query origin mapping
        across seeder and delegator.

    :param origins:
        ``all`` or a list of origin types (``chat``, ``inline``).
        Origin mapping is only enabled for specified origin types.
    """
    origin_map = helper.SafeDict()

    # For key functions that returns a tuple as key (e.g. per_callback_query_origin()),
    # wrap the key in another tuple to prevent router from mistaking it as
    # a key followed by some arguments.
    def tuplize(fn):
        def tp(msg):
            return (fn(msg),)
        return tp

    router = helper.Router(tuplize(per_callback_query_origin(origins=origins)),
                           origin_map)

    def modify_origin_map(origin, dest, set):
        if set:
            origin_map[origin] = dest
        else:
            try:
                del origin_map[origin]
            except KeyError:
                pass

    if origins == 'all':
        intercept = modify_origin_map
    else:
        intercept = (modify_origin_map if 'chat' in origins else False,
                     modify_origin_map if 'inline' in origins else False)

    @_ensure_seeders_list
    def p(seeders, delegator_factory, *args, **kwargs):
        return fn(seeders + [_wrap_none(router.map)],
                  delegator_factory, *args, intercept_callback_query=intercept, **kwargs)
    return p
