from __future__ import absolute_import

import errno

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

}

if sys.version_info[0] >= 3:

    def _bytespath(p):

        if p is None:

            return p

        return p.encode('utf-8')

    def _strpath(p):

        if p is None:

            return p

        return p.decode('utf-8')

else:

    def _bytespath(p):

        return p

    _strpath = _bytespath

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

    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']:

        sys.stderr.write('skipped: unknown feature: %s\n' % missing)

    for msg in result['skipped']:

        sys.stderr.write('skipped: %s\n' % msg)

    for msg in result['error']:

        sys.stderr.write('%s\n' % msg)

    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)

    try:

        p = subprocess.Popen(

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

    except OSError as e:

        if e.errno != errno.ENOENT:

            raise

        ret = -1

    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('.')[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)))

@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("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)))

# https://github.com/git-lfs/lfs-test-server

@check("lfs-test-server", "git-lfs test server")

def has_lfsserver():

    exe = 'lfs-test-server'

    if has_windows():

        exe = 'lfs-test-server.exe'

    return any(

        os.access(os.path.join(path, exe), os.X_OK)

        for path in os.environ["PATH"].split(os.pathsep)

    )

@checkvers("git", "git client (with ext::sh support) version >= %s", (1.9,))

def has_git_range(v):

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

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

@check("docutils", "Docutils text processing library")

def has_docutils():

    try:

        import docutils.core

        docutils.core.publish_cmdline # silence unused import

        return True

    except ImportError:

        return False

def getsvnversion():

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

    if not m:

        return (0, 0)

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

@checkvers("svn", "subversion client and admin tools >= %s", (1.3, 1.5))

def has_svn_range(v):

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

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

@check("svn", "subversion client and admin tools")

def has_svn():

    return matchoutput('svn --version 2>&1', br'^svn, version') and \

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

@check("svn-bindings", "subversion python bindings")

def has_svn_bindings():

    try:

        import svn.core

        version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR

        if version < (1, 4):

            return False

        return True

    except ImportError:

        return False

@check("p4", "Perforce server and client")

def has_p4():

    return (matchoutput('p4 -V', br'Rev\. P4/') and

            matchoutput('p4d -V', br'Rev\. P4D/'))

@check("symlink", "symbolic links")

def has_symlink():

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

        return False

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

    try:

        os.symlink(".", name)

        os.unlink(name)

        return True

    except (OSError, AttributeError):

        return False

@check("hardlink", "hardlinks")