import distutils.version

import os

import re

import socket

import stat

import subprocess

import sys

import tempfile

tempprefix = 'hg-hghave-'

checks = {

    "true": (lambda: True, "yak shaving"),

    "false": (lambda: False, "nail clipper"),

    "known-bad-output": (lambda: True, "use for currently known bad output"),

    "missing-correct-output": (lambda: False, "use for missing good output"),

}

try:

    import msvcrt

    msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)

    msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)

except ImportError:

    pass

stdout = getattr(sys.stdout, 'buffer', sys.stdout)

stderr = getattr(sys.stderr, 'buffer', sys.stderr)

is_not_python2 = sys.version_info[0] >= 3

if is_not_python2:

    def _sys2bytes(p):

        if p is None:

            return p

        return p.encode('utf-8')

    def _bytes2sys(p):

        if p is None:

            return p

        return p.decode('utf-8')

else:

    def _sys2bytes(p):

        return p

    _bytes2sys = _sys2bytes

def check(name, desc):

    """Registers a check function for a feature."""

    def decorator(func):

        checks[name] = (func, desc)

        return func

    return decorator

def checkvers(name, desc, vers):

    """Registers a check function for each of a series of versions.

    vers can be a list or an iterator.

    Produces a series of feature checks that have the form <name><vers> without

    any punctuation (even if there's punctuation in 'vers'; i.e. this produces

    'py38', not 'py3.8' or 'py-38')."""

    def decorator(func):

        def funcv(v):

            def f():

                return func(v)

            return f

        for v in vers:

            v = str(v)

            f = funcv(v)

            checks['%s%s' % (name, v.replace('.', ''))] = (f, desc % v)

        return func

    return decorator

def checkfeatures(features):

    result = {

        'error': [],

        'missing': [],

        'skipped': [],

    }

    for feature in features:

        negate = feature.startswith('no-')

        if negate:

            feature = feature[3:]

        if feature not in checks:

            result['missing'].append(feature)

            continue

        check, desc = checks[feature]

        try:

            available = check()

        except Exception as e:

            result['error'].append('hghave check %s failed: %r' % (feature, e))

            continue

        if not negate and not available:

            result['skipped'].append('missing feature: %s' % desc)

        elif negate and available:

            result['skipped'].append('system supports %s' % desc)

    return result

def require(features):

    """Require that features are available, exiting if not."""

    result = checkfeatures(features)

    for missing in result['missing']:

        stderr.write(

            ('skipped: unknown feature: %s\n' % missing).encode('utf-8')

        )

    for msg in result['skipped']:

        stderr.write(('skipped: %s\n' % msg).encode('utf-8'))

    for msg in result['error']:

        stderr.write(('%s\n' % msg).encode('utf-8'))

    if result['missing']:

        sys.exit(2)

    if result['skipped'] or result['error']:

        sys.exit(1)

def matchoutput(cmd, regexp, ignorestatus=False):

    """Return the match object if cmd executes successfully and its output

    is matched by the supplied regular expression.

    """

    # Tests on Windows have to fake USERPROFILE to point to the test area so

    # that `~` is properly expanded on py3.8+.  However, some tools like black

    # make calls that need the real USERPROFILE in order to run `foo --version`.

    env = os.environ

    if os.name == 'nt':

        env = os.environ.copy()

        env['USERPROFILE'] = env['REALUSERPROFILE']

    r = re.compile(regexp)

    p = subprocess.Popen(

        cmd,

        shell=True,

        stdout=subprocess.PIPE,

        stderr=subprocess.STDOUT,

        env=env,

    )

    s = p.communicate()[0]

    ret = p.returncode

    return (ignorestatus or not ret) and r.search(s)

@check("baz", "GNU Arch baz client")

def has_baz():

    return matchoutput('baz --version 2>&1', br'baz Bazaar version')

@check("bzr", "Breezy library and executable version >= 3.1")

def has_bzr():

    if not is_not_python2:

        return False

    try:

        # Test the Breezy python lib

        import breezy

        import breezy.bzr.bzrdir

        import breezy.errors

        import breezy.revision

        import breezy.revisionspec

        breezy.revisionspec.RevisionSpec

        if breezy.__doc__ is None or breezy.version_info[:2] < (3, 1):

            return False

    except (AttributeError, ImportError):

        return False

    # Test the executable

    return matchoutput('brz --version 2>&1', br'Breezy \(brz\) ')

@check("chg", "running with chg")

def has_chg():

    return 'CHG_INSTALLED_AS_HG' in os.environ

@check("rhg", "running with rhg as 'hg'")

def has_rhg():

    return 'RHG_INSTALLED_AS_HG' in os.environ

@check("pyoxidizer", "running with pyoxidizer build as 'hg'")

def has_pyoxidizer():

    return 'PYOXIDIZED_INSTALLED_AS_HG' in os.environ

@check("cvs", "cvs client/server")

def has_cvs():

    re = br'Concurrent Versions System.*?server'

    return matchoutput('cvs --version 2>&1', re) and not has_msys()

@check("cvs112", "cvs client/server 1.12.* (not cvsnt)")

def has_cvs112():

    re = br'Concurrent Versions System \(CVS\) 1.12.*?server'

    return matchoutput('cvs --version 2>&1', re) and not has_msys()

@check("cvsnt", "cvsnt client/server")

def has_cvsnt():

    re = br'Concurrent Versions System \(CVSNT\) (\d+).(\d+).*\(client/server\)'

    return matchoutput('cvsnt --version 2>&1', re)

@check("darcs", "darcs client")

def has_darcs():

    return matchoutput('darcs --version', br'\b2\.([2-9]|\d{2})', True)

@check("mtn", "monotone client (>= 1.0)")

def has_mtn():

    return matchoutput('mtn --version', br'monotone', True) and not matchoutput(

        'mtn --version', br'monotone 0\.', True

    )

@check("eol-in-paths", "end-of-lines in paths")

def has_eol_in_paths():

    try:

        fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix, suffix='\n\r')

        os.close(fd)

        os.remove(path)

        return True

    except (IOError, OSError):

        return False

@check("execbit", "executable bit")

def has_executablebit():

    try:

        EXECFLAGS = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH

        fh, fn = tempfile.mkstemp(dir='.', prefix=tempprefix)

        try:

            os.close(fh)

            m = os.stat(fn).st_mode & 0o777

            new_file_has_exec = m & EXECFLAGS

            os.chmod(fn, m ^ EXECFLAGS)

            exec_flags_cannot_flip = (os.stat(fn).st_mode & 0o777) == m

        finally:

            os.unlink(fn)

    except (IOError, OSError):

        # we don't care, the user probably won't be able to commit anyway

        return False

    return not (new_file_has_exec or exec_flags_cannot_flip)

@check("suidbit", "setuid and setgid bit")

def has_suidbit():

    if (

        getattr(os, "statvfs", None) is None

        or getattr(os, "ST_NOSUID", None) is None

    ):

        return False

    return bool(os.statvfs('.').f_flag & os.ST_NOSUID)

@check("icasefs", "case insensitive file system")

def has_icasefs():

    # Stolen from mercurial.util

    fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix)

    os.close(fd)

    try:

        s1 = os.stat(path)

        d, b = os.path.split(path)

        p2 = os.path.join(d, b.upper())

        if path == p2:

            p2 = os.path.join(d, b.lower())

        try:

            s2 = os.stat(p2)

            return s2 == s1

        except OSError:

            return False

    finally:

        os.remove(path)

@check("fifo", "named pipes")

def has_fifo():

    if getattr(os, "mkfifo", None) is None:

        return False

    name = tempfile.mktemp(dir='.', prefix=tempprefix)

    try:

        os.mkfifo(name)

        os.unlink(name)

        return True

    except OSError:

        return False

@check("killdaemons", 'killdaemons.py support')

def has_killdaemons():

    return True

@check("cacheable", "cacheable filesystem")

def has_cacheable_fs():

    from mercurial import util

    fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix)

    os.close(fd)

    try:

        return util.cachestat(path).cacheable()

    finally:

        os.remove(path)

@check("lsprof", "python lsprof module")

def has_lsprof():

    try:

        import _lsprof

        _lsprof.Profiler  # silence unused import warning

        return True

    except ImportError:

        return False

def _gethgversion():

    m = matchoutput('hg --version --quiet 2>&1', br'(\d+)\.(\d+)')

    if not m:

        return (0, 0)

    return (int(m.group(1)), int(m.group(2)))

_hgversion = None

def gethgversion():

    global _hgversion

    if _hgversion is None:

        _hgversion = _gethgversion()

    return _hgversion

@checkvers(

    "hg", "Mercurial >= %s", list([(1.0 * x) / 10 for x in range(9, 99)])

)

def has_hg_range(v):

    major, minor = v.split('.')[0:2]

    return gethgversion() >= (int(major), int(minor))

@check("rust", "Using the Rust extensions")

def has_rust():

    """Check is the mercurial currently running is using some rust code"""

    cmd = 'hg debuginstall --quiet 2>&1'

    match = br'checking module policy \(([^)]+)\)'

    policy = matchoutput(cmd, match)

    if not policy:

        return False

    return b'rust' in policy.group(1)

@check("hg08", "Mercurial >= 0.8")

def has_hg08():

    if checks["hg09"][0]():

        return True

    return matchoutput('hg help annotate 2>&1', '--date')

@check("hg07", "Mercurial >= 0.7")

def has_hg07():

    if checks["hg08"][0]():

        return True

    return matchoutput('hg --version --quiet 2>&1', 'Mercurial Distributed SCM')