# utility for color output for Mercurial commands

#

# Copyright (C) 2007 Kevin Christen <kevin.christen@gmail.com> and other

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from __future__ import absolute_import

import re

from .i18n import _

from .pycompat import getattr

from . import (

    encoding,

    pycompat,

)

from .utils import stringutil

try:

    import curses

    # Mapping from effect name to terminfo attribute name (or raw code) or

    # color number.  This will also force-load the curses module.

    _baseterminfoparams = {

        b'none': (True, b'sgr0', b''),

        b'standout': (True, b'smso', b''),

        b'underline': (True, b'smul', b''),

        b'reverse': (True, b'rev', b''),

        b'inverse': (True, b'rev', b''),

        b'blink': (True, b'blink', b''),

        b'dim': (True, b'dim', b''),

        b'bold': (True, b'bold', b''),

        b'invisible': (True, b'invis', b''),

        b'italic': (True, b'sitm', b''),

        b'black': (False, curses.COLOR_BLACK, b''),

        b'red': (False, curses.COLOR_RED, b''),

        b'green': (False, curses.COLOR_GREEN, b''),

        b'yellow': (False, curses.COLOR_YELLOW, b''),

        b'blue': (False, curses.COLOR_BLUE, b''),

        b'magenta': (False, curses.COLOR_MAGENTA, b''),

        b'cyan': (False, curses.COLOR_CYAN, b''),

        b'white': (False, curses.COLOR_WHITE, b''),

    }

except (ImportError, AttributeError):

    curses = None

    _baseterminfoparams = {}

# start and stop parameters for effects

_effects = {

    b'none': 0,

    b'black': 30,

    b'red': 31,

    b'green': 32,

    b'yellow': 33,

    b'blue': 34,

    b'magenta': 35,

    b'cyan': 36,

    b'white': 37,

    b'bold': 1,

    b'italic': 3,

    b'underline': 4,

    b'inverse': 7,

    b'dim': 2,

    b'black_background': 40,

    b'red_background': 41,

    b'green_background': 42,

    b'yellow_background': 43,

    b'blue_background': 44,

    b'purple_background': 45,

    b'cyan_background': 46,

    b'white_background': 47,

}

_defaultstyles = {

    b'grep.match': b'red bold',

    b'grep.linenumber': b'green',

    b'grep.rev': b'blue',

    b'grep.sep': b'cyan',

    b'grep.filename': b'magenta',

    b'grep.user': b'magenta',

    b'grep.date': b'magenta',

    b'grep.inserted': b'green bold',

    b'grep.deleted': b'red bold',

    b'bookmarks.active': b'green',

    b'branches.active': b'none',

    b'branches.closed': b'black bold',

    b'branches.current': b'green',

    b'branches.inactive': b'none',

    b'diff.changed': b'white',

    b'diff.deleted': b'red',

    b'diff.deleted.changed': b'red bold underline',

    b'diff.deleted.unchanged': b'red',

    b'diff.diffline': b'bold',

    b'diff.extended': b'cyan bold',

    b'diff.file_a': b'red bold',

    b'diff.file_b': b'green bold',

    b'diff.hunk': b'magenta',

    b'diff.inserted': b'green',

    b'diff.inserted.changed': b'green bold underline',

    b'diff.inserted.unchanged': b'green',

    b'diff.tab': b'',

    b'diff.trailingwhitespace': b'bold red_background',

    b'changeset.public': b'',

    b'changeset.draft': b'',

    b'changeset.secret': b'',

    b'diffstat.deleted': b'red',

    b'diffstat.inserted': b'green',

    b'formatvariant.name.mismatchconfig': b'red',

    b'formatvariant.name.mismatchdefault': b'yellow',

    b'formatvariant.name.uptodate': b'green',

    b'formatvariant.repo.mismatchconfig': b'red',

    b'formatvariant.repo.mismatchdefault': b'yellow',

    b'formatvariant.repo.uptodate': b'green',

    b'formatvariant.config.special': b'yellow',

    b'formatvariant.config.default': b'green',

    b'formatvariant.default': b'',

    b'histedit.remaining': b'red bold',

    b'ui.addremove.added': b'green',

    b'ui.addremove.removed': b'red',

    b'ui.error': b'red',

    b'ui.prompt': b'yellow',

    b'log.changeset': b'yellow',

    b'patchbomb.finalsummary': b'',

    b'patchbomb.from': b'magenta',

    b'patchbomb.to': b'cyan',

    b'patchbomb.subject': b'green',

    b'patchbomb.diffstats': b'',

    b'rebase.rebased': b'blue',

    b'rebase.remaining': b'red bold',

    b'resolve.resolved': b'green bold',

    b'resolve.unresolved': b'red bold',

    b'shelve.age': b'cyan',

    b'shelve.newest': b'green bold',

    b'shelve.name': b'blue bold',

    b'status.added': b'green bold',

    b'status.clean': b'none',

    b'status.copied': b'none',

    b'status.deleted': b'cyan bold underline',

    b'status.ignored': b'black bold',

    b'status.modified': b'blue bold',

    b'status.removed': b'red bold',

    b'status.unknown': b'magenta bold underline',

    b'tags.normal': b'green',

    b'tags.local': b'black bold',

    b'upgrade-repo.requirement.preserved': b'cyan',

    b'upgrade-repo.requirement.added': b'green',

    b'upgrade-repo.requirement.removed': b'red',

}

def loadcolortable(ui, extname, colortable):

    _defaultstyles.update(colortable)

def _terminfosetup(ui, mode, formatted):

    '''Initialize terminfo data and the terminal if we're in terminfo mode.'''

    # If we failed to load curses, we go ahead and return.

    if curses is None:

        return

    # Otherwise, see what the config file says.

    if mode not in (b'auto', b'terminfo'):

        return

    ui._terminfoparams.update(_baseterminfoparams)

    for key, val in ui.configitems(b'color'):

        if key.startswith(b'color.'):

            newval = (False, int(val), b'')

            ui._terminfoparams[key[6:]] = newval

        elif key.startswith(b'terminfo.'):

            newval = (True, b'', val.replace(b'\\E', b'\x1b'))

            ui._terminfoparams[key[9:]] = newval

    try:

        curses.setupterm()

    except curses.error:

        ui._terminfoparams.clear()

        return

    for key, (b, e, c) in ui._terminfoparams.copy().items():

        if not b:

            continue

        if not c and not curses.tigetstr(pycompat.sysstr(e)):

            # Most terminals don't support dim, invis, etc, so don't be

            # noisy and use ui.debug().

            ui.debug(b"no terminfo entry for %s\n" % e)

            del ui._terminfoparams[key]

    if not curses.tigetstr('setaf') or not curses.tigetstr('setab'):

        # Only warn about missing terminfo entries if we explicitly asked for

        # terminfo mode and we're in a formatted terminal.

        if mode == b"terminfo" and formatted:

            ui.warn(

                _(

                    b"no terminfo entry for setab/setaf: reverting to "

                    b"ECMA-48 color\n"

                )

            )

        ui._terminfoparams.clear()

def setup(ui):

    """configure color on a ui

    That function both set the colormode for the ui object and read

    the configuration looking for custom colors and effect definitions."""

    mode = _modesetup(ui)

    ui._colormode = mode

    if mode and mode != b'debug':

        configstyles(ui)

def _modesetup(ui):

    if ui.plain(b'color'):

        return None

    config = ui.config(b'ui', b'color')

    if config == b'debug':

        return b'debug'

    auto = config == b'auto'

    always = False

    if not auto and stringutil.parsebool(config):

        # We want the config to behave like a boolean, "on" is actually auto,

        # but "always" value is treated as a special case to reduce confusion.

        if (

            ui.configsource(b'ui', b'color') == b'--color'

            or config == b'always'

        ):

            always = True

        else:

            auto = True

    if not always and not auto:

        return None

    formatted = always or (

        encoding.environ.get(b'TERM') != b'dumb' and ui.formatted()

    )

    mode = ui.config(b'color', b'mode')

    # If pager is active, color.pagermode overrides color.mode.

    if getattr(ui, 'pageractive', False):

        mode = ui.config(b'color', b'pagermode', mode)

    realmode = mode

    if pycompat.iswindows:

        from . import win32

        term = encoding.environ.get(b'TERM')

        # TERM won't be defined in a vanilla cmd.exe environment.

        # UNIX-like environments on Windows such as Cygwin and MSYS will

        # set TERM. They appear to make a best effort attempt at setting it

        # to something appropriate. However, not all environments with TERM

        # defined support ANSI.

        ansienviron = term and b'xterm' in term

        if mode == b'auto':

            # Since "ansi" could result in terminal gibberish, we error on the

            # side of selecting "win32". However, if w32effects is not defined,

            # we almost certainly don't support "win32", so don't even try.

            # w32effects is not populated when stdout is redirected, so checking

            # it first avoids win32 calls in a state known to error out.

            if ansienviron or not w32effects or win32.enablevtmode():

                realmode = b'ansi'

            else:

                realmode = b'win32'

        # An empty w32effects is a clue that stdout is redirected, and thus

        # cannot enable VT mode.

        elif mode == b'ansi' and w32effects and not ansienviron:

            win32.enablevtmode()

    elif mode == b'auto':

        realmode = b'ansi'

    def modewarn():

        # only warn if color.mode was explicitly set and we're in

        # a formatted terminal

        if mode == realmode and formatted:

            ui.warn(_(b'warning: failed to set color mode to %s\n') % mode)

    if realmode == b'win32':

        ui._terminfoparams.clear()

        if not w32effects:

            modewarn()

            return None

    elif realmode == b'ansi':

        ui._terminfoparams.clear()

    elif realmode == b'terminfo':

        _terminfosetup(ui, mode, formatted)

        if not ui._terminfoparams:

            ## FIXME Shouldn't we return None in this case too?

            modewarn()

            realmode = b'ansi'

    else:

        return None

    if always or (auto and formatted):

        return realmode

    return None

def configstyles(ui):

    ui._styles.update(_defaultstyles)

    for status, cfgeffects in ui.configitems(b'color'):

        if b'.' not in status or status.startswith((b'color.', b'terminfo.')):

            continue

        cfgeffects = ui.configlist(b'color', status)

        if cfgeffects:

            good = []

            for e in cfgeffects:

                if valideffect(ui, e):

                    good.append(e)

                else:

                    ui.warn(

                        _(

                            b"ignoring unknown color/effect %s "

                            b"(configured in color.%s)\n"

                        )

                        % (stringutil.pprint(e), status)

                    )

            ui._styles[status] = b' '.join(good)

def _activeeffects(ui):

    '''Return the effects map for the color mode set on the ui.'''

    if ui._colormode == b'win32':

        return w32effects

    elif ui._colormode is not None:

        return _effects

    return {}

def valideffect(ui, effect):

    """Determine if the effect is valid or not."""

    return (not ui._terminfoparams and effect in _activeeffects(ui)) or (

        effect in ui._terminfoparams or effect[:-11] in ui._terminfoparams

    )

def _effect_str(ui, effect):

    '''Helper function for render_effects().'''

    bg = False

    if effect.endswith(b'_background'):

        bg = True

        effect = effect[:-11]

    try:

        attr, val, termcode = ui._terminfoparams[effect]

    except KeyError:

        return b''

    if attr:

        if termcode:

            return termcode

        else:

            return curses.tigetstr(pycompat.sysstr(val))

    elif bg:

        return curses.tparm(curses.tigetstr('setab'), val)

    else:

        return curses.tparm(curses.tigetstr('setaf'), val)

def _mergeeffects(text, start, stop):

    """Insert start sequence at every occurrence of stop sequence

    >>> s = _mergeeffects(b'cyan', b'[C]', b'|')

    >>> s = _mergeeffects(s + b'yellow', b'[Y]', b'|')

    >>> s = _mergeeffects(b'ma' + s + b'genta', b'[M]', b'|')

    >>> s = _mergeeffects(b'red' + s, b'[R]', b'|')

    >>> s

    '[R]red[M]ma[Y][C]cyan|[R][M][Y]yellow|[R][M]genta|'

    """

    parts = []