import re
from gettext import NullTranslations
from translationstring.compat import text_type
from translationstring.compat import string_types
from translationstring.compat import PY3

NAME_RE = r"[a-zA-Z][-a-zA-Z0-9_]*"

_interp_regex = re.compile(r'(?<!\$)(\$(?:(%(n)s)|{(%(n)s)}))'
    % ({'n': NAME_RE}))

CONTEXT_MASK = text_type('%s\x04%s')

class TranslationString(text_type):
    """
    The constructor for a :term:`translation string`.  A translation
    string is a Unicode-like object that has some extra metadata.

    This constructor accepts one required argument named ``msgid``.
    ``msgid`` must be the :term:`message identifier` for the
    translation string.  It must be a ``unicode`` object or a ``str``
    object encoded in the default system encoding.

    Optional keyword arguments to this object's constructor include
    ``domain``, ``default``, and ``mapping``.

    ``domain`` represents the :term:`translation domain`.  By default,
    the translation domain is ``None``, indicating that this
    translation string is associated with the default translation
    domain (usually ``messages``).

    ``default`` represents an explicit *default text* for this
    translation string.  Default text appears when the translation
    string cannot be translated.  Usually, the ``msgid`` of a
    translation string serves double duty as its default text.
    However, using this option you can provide a different default
    text for this translation string.  This feature is useful when the
    default of a translation string is too complicated or too long to
    be used as a message identifier. If ``default`` is provided, it
    must be a ``unicode`` object or a ``str`` object encoded in the
    default system encoding (usually means ASCII).  If ``default`` is
    ``None`` (its default value), the ``msgid`` value used by this
    translation string will be assumed to be the value of ``default``.

    ``mapping``, if supplied, must be a dictionary-like object which
    represents the replacement values for any :term:`translation
    string` *replacement marker* instances found within the ``msgid``
    (or ``default``) value of this translation string.

    ``context`` represents the :term:`translation context`.  By default,
    the translation context is ``None``.

    After a translation string is constructed, it behaves like most
    other ``unicode`` objects; its ``msgid`` value will be displayed
    when it is treated like a ``unicode`` object.  Only when its
    ``ugettext`` method is called will it be translated.

    Its default value is available as the ``default`` attribute of the
    object, its :term:`translation domain` is available as the
    ``domain`` attribute, and the ``mapping`` is available as the
    ``mapping`` attribute.  The object otherwise behaves much like a
    Unicode string.
    """
    __slots__ = ('domain', 'context', 'default', 'mapping')

    def __new__(self, msgid, domain=None, default=None, mapping=None, context=None):

        # NB: this function should never never lose the *original
        # identity* of a non-``None`` but empty ``default`` value
        # provided to it.  See the comment in ChameleonTranslate.

        self = text_type.__new__(self, msgid)
        if isinstance(msgid, self.__class__):
            domain = domain or msgid.domain and msgid.domain[:]
            context = context or msgid.context and msgid.context[:]
            default = default or msgid.default and msgid.default[:]
            if msgid.mapping:
                if mapping:
                    for k, v in msgid.mapping.items():
                        mapping.setdefault(k, v)
                else:
                    mapping = msgid.mapping.copy()
            msgid = text_type(msgid)
        self.domain = domain
        self.context = context
        if default is None:
            default = text_type(msgid)
        self.default = default
        self.mapping = mapping
        return self

    def __mod__(self, options):
        """Create a new TranslationString instance with an updated mapping.
        This makes it possible to use the standard python %-style string
        formatting with translatable strings. Only dictionary
        arguments are supported.
        """
        if not isinstance(options, dict):
            raise ValueError(
                    'Can only interpolate translationstring '
                    'with dictionaries.')
        if self.mapping:
            mapping = self.mapping.copy()
            mapping.update(options)
        else:
            mapping = options.copy()
        return TranslationString(self, mapping=mapping)

    def interpolate(self, translated=None):
        """ Interpolate the value ``translated`` which is assumed to
        be a Unicode object containing zero or more *replacement
        markers* (``$foo`` or ``${bar}``) using the ``mapping``
        dictionary attached to this instance.  If the ``mapping``
        dictionary is empty or ``None``, no interpolation is
        performed.

        If ``translated`` is ``None``, interpolation will be performed
        against the ``default`` value.
        """
        if translated is None:
            translated = self.default

        # NB: this function should never never lose the *original
        # identity* of a non-``None`` but empty ``default`` value it
        # is provided.  If (translated == default) , it should return the
        # *original* default, not a derivation.  See the comment below in
        # ChameleonTranslate.

        if self.mapping and translated:
            def replace(match):
                whole, param1, param2 = match.groups()
                return text_type(self.mapping.get(param1 or param2, whole))
            translated = _interp_regex.sub(replace, translated)

        return translated

    def __reduce__(self):
        return self.__class__, self.__getstate__()

    def __getstate__(self):
        return text_type(self), self.domain, self.default, self.mapping, self.context

def TranslationStringFactory(factory_domain):
    """ Create a factory which will generate translation strings
    without requiring that each call to the factory be passed a
    ``domain`` value.  A single argument is passed to this class'
    constructor: ``domain``.  This value will be used as the
    ``domain`` values of :class:`translationstring.TranslationString`
    objects generated by the ``__call__`` of this class.  The
    ``msgid``, ``mapping``, and ``default`` values provided to the
    ``__call__`` method of an instance of this class have the meaning
    as described by the constructor of the
    :class:`translationstring.TranslationString`"""
    def create(msgid, mapping=None, default=None, context=None):
        """ Provided a msgid (Unicode object or :term:`translation
        string`) and optionally a mapping object, and a *default
        value*, return a :term:`translation string` object."""

        # if we are passing in a TranslationString as the msgid, then
        # use its domain
        if isinstance(msgid, TranslationString):
            domain = msgid.domain or factory_domain
        else:
            domain = factory_domain

        return TranslationString(msgid, domain=domain, default=default,
                                 mapping=mapping, context=context)
    return create

def ChameleonTranslate(translator):
    """
    When necessary, use the result of calling this function as a
    Chameleon template 'translate' function (e.g. the ``translate``
    argument to the ``chameleon.zpt.template.PageTemplate``
    constructor) to allow our translation machinery to drive template
    translation.  A single required argument ``translator`` is
    passsed.  The ``translator`` provided should be a callable which
    accepts a single argument ``translation_string`` ( a
    :class:`translationstring.TranslationString` instance) which
    returns a ``unicode`` object as a translation.  ``translator`` may
    also optionally be ``None``, in which case no translation is
    performed (the ``msgid`` or ``default`` value is returned
    untranslated).
    """
    def translate(msgid, domain=None, mapping=None, context=None,
                 target_language=None, default=None):

        # NB: note that both TranslationString._init__ and
        # TranslationString.interpolate are careful to never lose the
        # *identity* of an empty but non-``None`` ``default`` value we
        # provide to them.  For example, neither of those functions
        # are permitted to run an empty but non-``None`` ``default``
        # through ``unicode`` and throw the original default value
        # away afterwards.

        # This has a dubious cause: for Chameleon API reasons we must
        # ensure that, after translation, if ( (translated == msgid)
        # and (not default) and (default is not None) ) that we return
        # the ``default`` value provided to us *unmodified*, because
        # Chameleon uses it as a sentinel (it compares the return
        # value of this function by identity to what it passed in as
        # ``default``; this marker is a
        # chameleon.core.i18n.StringMarker instance, a subclass of str
        # that == '').  This is, of course, totally absurd, because
        # Chameleon *also* wants us to use ``default`` as the input to
        # a translation string in some cases, and maintaining the
        # identity of this object through translation operations isn't
        # a contract it spells out in its docs.

        # Chameleon's use of ``default`` to represent both a sentinel
        # and input to a translation string is a Chameleon i18n
        # extensibility design bug.  Until we overhaul its hook point
        # for translation extensibility, we need to appease it by
        # preserving ``default`` in the aforementioned case.  So we
        # spray these indignant comments all over this module. ;-)

        if not isinstance(msgid, string_types):
            if msgid is not None:
                msgid = text_type(msgid)
            return msgid

        tstring = msgid

        if not hasattr(tstring, 'interpolate'):
            tstring = TranslationString(msgid, domain, default, mapping, context)
        if translator is None:
            result = tstring.interpolate()
        else:
            result = translator(tstring)

        return result

    return translate

def ugettext_policy(translations, tstring, domain, context):
    """ A translator policy function which unconditionally uses the
    ``ugettext`` API on the translations object."""

    if PY3: # pragma: no cover
        _gettext = translations.gettext
    else: # pragma: no cover
        _gettext = translations.ugettext

    if context:
	# Workaround for http://bugs.python.org/issue2504?
        msgid = CONTEXT_MASK % (context, tstring)
    else:
        msgid = tstring

    translated = _gettext(msgid)
    return tstring if translated == msgid else translated

def dugettext_policy(translations, tstring, domain, context):
    """ A translator policy function which assumes the use of a
    :class:`babel.support.Translations` translations object, which
    supports the dugettext API; fall back to ugettext."""
    if domain is None:
        default_domain = getattr(translations, 'domain', None) or 'messages'
        domain = getattr(tstring, 'domain', None) or default_domain
    context = context or getattr(tstring, 'context', None)
    if context:
	# Workaround for http://bugs.python.org/issue2504?
        msgid = CONTEXT_MASK % (context, tstring)
    else:
        msgid = tstring

    if getattr(translations, 'dugettext', None) is not None:
        translated = translations.dugettext(domain, msgid)
    else:
        if PY3: # pragma: no cover
            _gettext = translations.gettext
        else: # pragma: no cover
            _gettext = translations.ugettext

        translated = _gettext(msgid)
    return tstring if translated == msgid else translated

def Translator(translations=None, policy=None):
    """
    Return a translator object based on the ``translations`` and
    ``policy`` provided.  ``translations`` should be an object
    supporting *at least* the Python :class:`gettext.NullTranslations`
    API but ideally the :class:`babel.support.Translations` API, which
    has support for domain lookups like dugettext.

    ``policy`` should be a callable which accepts three arguments:
    ``translations``, ``tstring`` and ``domain``.  It must perform the
    actual translation lookup.  If ``policy`` is ``None``, the
    :func:`translationstring.dugettext_policy` policy will be used.

    The callable returned accepts three arguments: ``tstring``
    (required), ``domain`` (optional) and ``mapping`` (optional).
    When called, it will translate the ``tstring`` translation string
    to a ``unicode`` object using the ``translations`` provided.  If
    ``translations`` is ``None``, the result of interpolation of the
    default value is returned.  The optional ``domain`` argument can
    be used to specify or override the domain of the ``tstring``
    (useful when ``tstring`` is a normal string rather than a
    translation string).  The optional ``mapping`` argument can
    specify or override the ``tstring`` interpolation mapping, useful
    when the ``tstring`` argument is a simple string instead of a
    translation string.
    """
    if policy is None:
        policy = dugettext_policy
    def translator(tstring, domain=None, mapping=None, context=None):
        if not hasattr(tstring, 'interpolate'):
            tstring = TranslationString(tstring, domain=domain, mapping=mapping, context=context)
        elif mapping:
            if tstring.mapping:
                new_mapping = tstring.mapping.copy()
                new_mapping.update(mapping)
            else:
                new_mapping = mapping
            tstring = TranslationString(tstring, domain=domain, mapping=new_mapping, context=context)
        translated = tstring
        domain = domain or tstring.domain
        context = context or tstring.context
        if translations is not None:
            translated = policy(translations, tstring, domain, context)
        if translated == tstring:
            translated = tstring.default
        if translated and '$' in translated and tstring.mapping:
            translated = tstring.interpolate(translated)
        return translated
    return translator

def ungettext_policy(translations, singular, plural, n, domain, context):
    """ A pluralizer policy function which unconditionally uses the
    ``ungettext`` API on the translations object."""

    if PY3: # pragma: no cover
        _gettext = translations.ngettext
    else: # pragma: no cover
        _gettext = translations.ungettext

    if context:
	# Workaround for http://bugs.python.org/issue2504?
        msgid = CONTEXT_MASK % (context, singular)
    else:
        msgid = singular

    translated = _gettext(msgid, plural, n)
    return singular if translated == msgid else translated

def dungettext_policy(translations, singular, plural, n, domain, context):
    """ A pluralizer policy function which assumes the use of the
    :class:`babel.support.Translations` class, which supports the
    dungettext API; falls back to ungettext."""

    default_domain = getattr(translations, 'domain', None) or 'messages'
    domain = domain or default_domain
    if context:
	# Workaround for http://bugs.python.org/issue2504?
        msgid = CONTEXT_MASK % (context, singular)
    else:
        msgid = singular
    if getattr(translations, 'dungettext', None) is not None:
        translated = translations.dungettext(domain, msgid, plural, n)
    else:
        if PY3: # pragma: no cover
            _gettext = translations.ngettext
        else: # pragma: no cover
            _gettext = translations.ungettext

        translated = _gettext(msgid, plural, n)
    return singular if translated == msgid else translated

def Pluralizer(translations=None, policy=None):
    """
    Return a pluralizer object based on the ``translations`` and
    ``policy`` provided.  ``translations`` should be an object
    supporting *at least* the Python :class:`gettext.NullTranslations`
    API but ideally the :class:`babel.support.Translations` API, which
    has support for domain lookups like dugettext.

    ``policy`` should be a callable which accepts five arguments:
    ``translations``, ``singular`` and ``plural``, ``n`` and
    ``domain``.  It must perform the actual pluralization lookup.  If
    ``policy`` is ``None``, the
    :func:`translationstring.dungettext_policy` policy will be used.

    The object returned will be a callable which has the following
    signature::

        def pluralizer(singular, plural, n, domain=None, mapping=None):
            ...

    The ``singular`` and ``plural`` objects passed may be translation
    strings or unicode strings.  ``n`` represents the number of
    elements.  ``domain`` is the translation domain to use to do the
    pluralization, and ``mapping`` is the interpolation mapping that
    should be used on the result.  Note that if the objects passed are
    translation strings, their domains and mappings are ignored.  The
    domain and mapping arguments must be used instead.  If the ``domain`` is
    not supplied, a default domain is used (usually ``messages``).
    """

    if policy is None:
        policy = dungettext_policy
    if translations is None:
        translations = NullTranslations()
    def pluralizer(singular, plural, n, domain=None, mapping=None, context=None):
        """ Pluralize this object """
        translated = text_type(
            policy(translations, singular, plural, n, domain, context))
        if translated and '$' in translated and mapping:
            return TranslationString(translated, mapping=mapping).interpolate()
        return translated
    return pluralizer
