# 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

from .i18n import _

from . import (

    encoding,

    pycompat,

    util

)

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.

    _terminfo_params = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    }

except ImportError:

    curses = None

    _terminfo_params = {}

# allow the extensions to change the default

_enabledbydefault = False

# start and stop parameters for effects

_effects = {

    'none': 0,

    'black': 30,

    'red': 31,

    'green': 32,

    'yellow': 33,

    'blue': 34,

    'magenta': 35,

    'cyan': 36,

    'white': 37,

    'bold': 1,

    'italic': 3,

    'underline': 4,

    'inverse': 7,

    'dim': 2,

    'black_background': 40,

    'red_background': 41,

    'green_background': 42,

    'yellow_background': 43,

    'blue_background': 44,

    'purple_background': 45,

    'cyan_background': 46,

    'white_background': 47,

    }

_styles = {

    'grep.match': 'red bold',

    'grep.linenumber': 'green',

    'grep.rev': 'green',

    'grep.change': 'green',

    'grep.sep': 'cyan',

    'grep.filename': 'magenta',

    'grep.user': 'magenta',

    'grep.date': 'magenta',

    'bookmarks.active': 'green',

    'branches.active': 'none',

    'branches.closed': 'black bold',

    'branches.current': 'green',

    'branches.inactive': 'none',

    'diff.changed': 'white',

    'diff.deleted': 'red',

    'diff.diffline': 'bold',

    'diff.extended': 'cyan bold',

    'diff.file_a': 'red bold',

    'diff.file_b': 'green bold',

    'diff.hunk': 'magenta',

    'diff.inserted': 'green',

    'diff.tab': '',

    'diff.trailingwhitespace': 'bold red_background',

    'changeset.public' : '',

    'changeset.draft' : '',

    'changeset.secret' : '',

    'diffstat.deleted': 'red',

    'diffstat.inserted': 'green',

    'histedit.remaining': 'red bold',

    'ui.prompt': 'yellow',

    'log.changeset': 'yellow',

    'patchbomb.finalsummary': '',

    'patchbomb.from': 'magenta',

    'patchbomb.to': 'cyan',

    'patchbomb.subject': 'green',

    'patchbomb.diffstats': '',

    'rebase.rebased': 'blue',

    'rebase.remaining': 'red bold',

    'resolve.resolved': 'green bold',

    'resolve.unresolved': 'red bold',

    'shelve.age': 'cyan',

    'shelve.newest': 'green bold',

    'shelve.name': 'blue bold',

    'status.added': 'green bold',

    'status.clean': 'none',

    'status.copied': 'none',

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

    'status.ignored': 'black bold',

    'status.modified': 'blue bold',

    'status.removed': 'red bold',

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

    'tags.normal': 'green',

    'tags.local': 'black bold',

}

def loadcolortable(ui, extname, colortable):

    _styles.update(colortable)

def _terminfosetup(ui, mode):

    '''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 ('auto', 'terminfo'):

        return

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

        if key.startswith('color.'):

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

            _terminfo_params[key[6:]] = newval

        elif key.startswith('terminfo.'):

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

            _terminfo_params[key[9:]] = newval

    try:

        curses.setupterm()

    except curses.error as e:

        _terminfo_params.clear()

        return

    for key, (b, e, c) in _terminfo_params.items():

        if not b:

            continue

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

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

            # noisy and use ui.debug().

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

            del _terminfo_params[key]

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

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

        # terminfo mode.

        if mode == "terminfo":

            ui.warn(_("no terminfo entry for setab/setaf: reverting to "

              "ECMA-48 color\n"))

        _terminfo_params.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 != 'debug':

        configstyles(ui)

def _modesetup(ui):

    if ui.plain():

        return None

    default = 'never'

    if _enabledbydefault:

        default = 'auto'

    # experimental config: ui.color

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

    if config == 'debug':

        return 'debug'

    auto = (config == 'auto')

    always = not auto and util.parsebool(config)

    if not always and not auto:

        return None

    formatted = (always or (encoding.environ.get('TERM') != 'dumb'

                 and ui.formatted()))

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

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

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

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

    realmode = mode

    if mode == 'auto':

        if pycompat.osname == 'nt':

            term = encoding.environ.get('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. 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.

            if (term and 'xterm' in term) or not w32effects:

                realmode = 'ansi'

            else:

                realmode = 'win32'

        else:

            realmode = 'ansi'

    def modewarn():

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

        # a formatted terminal

        if mode == realmode and ui.formatted():

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

    if realmode == 'win32':

        _terminfo_params.clear()

        if not w32effects:

            modewarn()

            return None

        _effects.update(w32effects)

    elif realmode == 'ansi':

        _terminfo_params.clear()

    elif realmode == 'terminfo':

        _terminfosetup(ui, mode)

        if not _terminfo_params:

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

            modewarn()

            realmode = 'ansi'

    else:

        return None

    if always or (auto and formatted):

        return realmode

    return None

def configstyles(ui):

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

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

            continue

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

        if cfgeffects:

            good = []

            for e in cfgeffects:

                    good.append(e)

                else:

                    ui.warn(_("ignoring unknown color/effect %r "

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

                            % (e, status))

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

    'Determine if the effect is valid or not.'

    return ((not _terminfo_params and effect in _effects)

             or (effect in _terminfo_params

                 or effect[:-11] in _terminfo_params))

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

    bg = False

    if effect.endswith('_background'):

        bg = True

        effect = effect[:-11]

    try:

        attr, val, termcode = _terminfo_params[effect]

    except KeyError:

        return ''

    if attr:

        if termcode:

            return termcode

        else:

            return curses.tigetstr(val)

    elif bg:

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

    else:

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

    'Wrap text in commands to turn on each effect.'

    if not text:

        return text

    if _terminfo_params:

                        for effect in ['none'] + effects.split())

    else:

        start = [str(_effects[e]) for e in ['none'] + effects.split()]

        start = '\033[' + ';'.join(start) + 'm'

        stop = '\033[' + str(_effects['none']) + 'm'

    return ''.join([start, text, stop])

def colorlabel(ui, msg, label):

    """add color control code according to the mode"""

    if ui._colormode == 'debug':

        if label and msg:

            if msg[-1] == '\n':

                msg = "[%s|%s]\n" % (label, msg[:-1])

            else:

                msg = "[%s|%s]" % (label, msg)

    elif ui._colormode is not None:

        effects = []

        for l in label.split():

            s = _styles.get(l, '')

            if s:

                effects.append(s)

                effects.append(l)

        effects = ' '.join(effects)

        if effects:

                             for line in msg.split('\n')])

    return msg

w32effects = None

if pycompat.osname == 'nt':

    import ctypes

    import re

    _kernel32 = ctypes.windll.kernel32

    _WORD = ctypes.c_ushort

    _INVALID_HANDLE_VALUE = -1

    class _COORD(ctypes.Structure):

        _fields_ = [('X', ctypes.c_short),

                    ('Y', ctypes.c_short)]

    class _SMALL_RECT(ctypes.Structure):

        _fields_ = [('Left', ctypes.c_short),

                    ('Top', ctypes.c_short),

                    ('Right', ctypes.c_short),

                    ('Bottom', ctypes.c_short)]

    class _CONSOLE_SCREEN_BUFFER_INFO(ctypes.Structure):

        _fields_ = [('dwSize', _COORD),

                    ('dwCursorPosition', _COORD),

                    ('wAttributes', _WORD),

                    ('srWindow', _SMALL_RECT),

                    ('dwMaximumWindowSize', _COORD)]

    _STD_OUTPUT_HANDLE = 0xfffffff5 # (DWORD)-11

    _STD_ERROR_HANDLE = 0xfffffff4  # (DWORD)-12

    _FOREGROUND_BLUE = 0x0001

    _FOREGROUND_GREEN = 0x0002

    _FOREGROUND_RED = 0x0004

    _FOREGROUND_INTENSITY = 0x0008

    _BACKGROUND_BLUE = 0x0010

    _BACKGROUND_GREEN = 0x0020

    _BACKGROUND_RED = 0x0040

    _BACKGROUND_INTENSITY = 0x0080

    _COMMON_LVB_REVERSE_VIDEO = 0x4000

    _COMMON_LVB_UNDERSCORE = 0x8000

    # http://msdn.microsoft.com/en-us/library/ms682088%28VS.85%29.aspx

    w32effects = {

        'none': -1,

        'black': 0,

        'red': _FOREGROUND_RED,

        'green': _FOREGROUND_GREEN,

        'yellow': _FOREGROUND_RED | _FOREGROUND_GREEN,