from __future__ import absolute_import, print_function

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"),

}

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)

if sys.version_info[0] >= 3:

    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:

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

            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.

    """

    r = re.compile(regexp)

    p = subprocess.Popen(

        cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT

    )

    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", "Canonical's Bazaar client")

def has_bzr():

    try:

        import bzrlib

        import bzrlib.bzrdir

        import bzrlib.errors

        import bzrlib.revision

        import bzrlib.revisionspec

        bzrlib.revisionspec.RevisionSpec

        return bzrlib.__doc__ is not None

    except (AttributeError, ImportError):

        return False

@checkvers("bzr", "Canonical's Bazaar client >= %s", (1.14,))

def has_bzr_range(v):

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

    try:

        import bzrlib

        return bzrlib.__doc__ is not None and bzrlib.version_info[:2] >= (

            int(major),

            int(minor),

        )

    except ImportError:

        return False

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

def has_chg():

    return 'CHGHG' 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("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')

@check("hg06", "Mercurial >= 0.6")

def has_hg06():

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

        return True

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

@check("gettext", "GNU Gettext (msgfmt)")

def has_gettext():

    return matchoutput('msgfmt --version', br'GNU gettext-tools')

@check("git", "git command line client")

def has_git():

    return matchoutput('git --version 2>&1', br'^git version')

def getgitversion():

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

    if not m:

        return (0, 0)

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

@check("pygit2", "pygit2 Python library")