"""

Utitlites aimed to help achieve mostly basic tasks.

"""

from __future__ import division

import re

import os

import time

import datetime

from subprocess import Popen, PIPE

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.lib.vcs.utils.paths import abspath

ALIASES = ['hg', 'git']

def get_scm(path, search_up=False, explicit_alias=None):

    """

    Returns one of alias from ``ALIASES`` (in order of precedence same as

    shortcuts given in ``ALIASES``) and top working dir path for the given

    argument. If no scm-specific directory is found or more than one scm is

    found at that directory, ``VCSError`` is raised.

    :param search_up: if set to ``True``, this function would try to

      move up to parent directory every time no scm is recognized for the

      currently checked path. Default: ``False``.

    :param explicit_alias: can be one of available backend aliases, when given

      it will return given explicit alias in repositories under more than one

      version control, if explicit_alias is different than found it will raise

      VCSError

    """

    if not os.path.isdir(path):

        raise VCSError("Given path %s is not a directory" % path)

    def get_scms(path):

        return [(scm, path) for scm in get_scms_for_path(path)]

    found_scms = get_scms(path)

    while not found_scms and search_up:

        newpath = abspath(path, '..')

        if newpath == path:

            break

        path = newpath

        found_scms = get_scms(path)

    if len(found_scms) > 1:

        for scm in found_scms:

            if scm[0] == explicit_alias:

                return scm

        raise VCSError('More than one [%s] scm found at given path %s'

                       % (', '.join((x[0] for x in found_scms)), path))

    if len(found_scms) is 0:

        raise VCSError('No scm found at given path %s' % path)

    return found_scms[0]

def get_scms_for_path(path):

    """

    Returns all scm's found at the given path. If no scm is recognized

    - empty list is returned.

    :param path: path to directory which should be checked. May be callable.

    :raises VCSError: if given ``path`` is not a directory

    """

    from kallithea.lib.vcs.backends import get_backend

    if hasattr(path, '__call__'):

        path = path()

    if not os.path.isdir(path):

        raise VCSError("Given path %r is not a directory" % path)

    result = []

    for key in ALIASES:

        dirname = os.path.join(path, '.' + key)

        if os.path.isdir(dirname):

            result.append(key)

            continue

        dirname = os.path.join(path, 'rm__.' + key)

        if os.path.isdir(dirname):

            return result

        # We still need to check if it's not bare repository as

        # bare repos don't have working directories

        try:

            get_backend(key)(path)

            result.append(key)

            continue

        except RepositoryError:

            # Wrong backend

            pass

        except VCSError:

            # No backend at all

            pass

    return result

def run_command(cmd, *args):

    """

    Runs command on the system with given ``args``.

    """

    command = ' '.join((cmd, args))

    p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE)

    stdout, stderr = p.communicate()

    return p.retcode, stdout, stderr

def get_highlighted_code(name, code, type='terminal'):

    """

    If pygments are available on the system

    then returned output is colored. Otherwise

    unchanged content is returned.

    """

    import logging

    try:

        import pygments

        pygments

    except ImportError:

        return code

    from pygments import highlight

    from pygments.lexers import guess_lexer_for_filename, ClassNotFound

    from pygments.formatters import TerminalFormatter

    try:

        lexer = guess_lexer_for_filename(name, code)

        formatter = TerminalFormatter()

        content = highlight(code, lexer, formatter)

    except ClassNotFound:

        logging.debug("Couldn't guess Lexer, will not use pygments.")

        content = code

    return content

def parse_changesets(text):

    """

    Returns dictionary with *start*, *main* and *end* ids.

    Examples::

        >>> parse_changesets('aaabbb')

        {'start': None, 'main': 'aaabbb', 'end': None}

        >>> parse_changesets('aaabbb..cccddd')

        {'start': 'aaabbb', 'main': None, 'end': 'cccddd'}

    """

    text = text.strip()

    CID_RE = r'[a-zA-Z0-9]+'

    if not '..' in text:

        m = re.match(r'^(?P<cid>%s)$' % CID_RE, text)

        if m:

            return {

                'start': None,

                'main': text,

                'end': None,

            }

    else:

        RE = r'^(?P<start>%s)?\.{2,3}(?P<end>%s)?$' % (CID_RE, CID_RE)

        m = re.match(RE, text)

        if m:

            result = m.groupdict()

            result['main'] = None

            return result

    raise ValueError("IDs not recognized")

def parse_datetime(text):

    """

    Parses given text and returns ``datetime.datetime`` instance or raises

    ``ValueError``.

    :param text: string of desired date/datetime or something more verbose,

      like *yesterday*, *2weeks 3days*, etc.

    """

    text = text.strip().lower()

    INPUT_FORMATS = (

        '%Y-%m-%d %H:%M:%S',

        '%Y-%m-%d %H:%M',

        '%Y-%m-%d',

        '%m/%d/%Y %H:%M:%S',

        '%m/%d/%Y %H:%M',

        '%m/%d/%Y',

        '%m/%d/%y %H:%M:%S',

        '%m/%d/%y %H:%M',

        '%m/%d/%y',

    )

    for format in INPUT_FORMATS:

        try:

            return datetime.datetime(*time.strptime(text, format)[:6])

        except ValueError:

            pass

    # Try descriptive texts

    if text == 'tomorrow':

        future = datetime.datetime.now() + datetime.timedelta(days=1)

        args = future.timetuple()[:3] + (23, 59, 59)

        return datetime.datetime(*args)

    elif text == 'today':

        return datetime.datetime(*datetime.datetime.today().timetuple()[:3])

    elif text == 'now':

        return datetime.datetime.now()

    elif text == 'yesterday':

        past = datetime.datetime.now() - datetime.timedelta(days=1)

        return datetime.datetime(*past.timetuple()[:3])

    else:

        days = 0

        matched = re.match(

            r'^((?P<weeks>\d+) ?w(eeks?)?)? ?((?P<days>\d+) ?d(ays?)?)?$', text)

        if matched:

            groupdict = matched.groupdict()

            if groupdict['days']:

                days += int(matched.groupdict()['days'])

            if groupdict['weeks']:

                days += int(matched.groupdict()['weeks']) * 7

            past = datetime.datetime.now() - datetime.timedelta(days=days)

            return datetime.datetime(*past.timetuple()[:3])

    raise ValueError('Wrong date: "%s"' % text)

def get_dict_for_attrs(obj, attrs):

    """

    Returns dictionary for each attribute from given ``obj``.

    """

    data = {}

    for attr in attrs:

        data[attr] = getattr(obj, attr)

    return data

def get_total_seconds(timedelta):

    """

    Backported for Python 2.5.

    See http://docs.python.org/library/datetime.html.

    """

    return ((timedelta.microseconds + (

            timedelta.seconds +

            timedelta.days * 24 * 60 * 60

        ) * 10**6) / 10**6)

        :param repo: Instance of Repository, repository_id, or repository name

        :param user: Instance of User, user_id or username

        :param perm: Instance of Permission, or permission_name

        """

        user = self._get_user(user)

        repo = self._get_repo(repo)

        permission = self._get_perm(perm)

        # check if we have that permission already

        obj = self.sa.query(UserRepoToPerm) \

            .filter(UserRepoToPerm.user == user) \

            .filter(UserRepoToPerm.repository == repo) \

            .scalar()

        if obj is None:

            # create new !

            obj = UserRepoToPerm()

        obj.repository = repo

        obj.user = user

        obj.permission = permission

        self.sa.add(obj)

        log.debug('Granted perm %s to %s on %s' % (perm, user, repo))

        return obj

    def revoke_user_permission(self, repo, user):

        """

        Revoke permission for user on given repository

        :param repo: Instance of Repository, repository_id, or repository name

        :param user: Instance of User, user_id or username

        """

        user = self._get_user(user)

        repo = self._get_repo(repo)

        obj = self.sa.query(UserRepoToPerm) \

            .filter(UserRepoToPerm.repository == repo) \

            .filter(UserRepoToPerm.user == user) \

            .scalar()

        if obj:

            self.sa.delete(obj)

            log.debug('Revoked perm on %s on %s' % (repo, user))

    def grant_user_group_permission(self, repo, group_name, perm):

        """

        Grant permission for user group on given repository, or update

        existing one if found

        :param repo: Instance of Repository, repository_id, or repository name

        :param group_name: Instance of UserGroup, users_group_id,

            or user group name

        :param perm: Instance of Permission, or permission_name

        """

        repo = self._get_repo(repo)

        group_name = self._get_user_group(group_name)

        permission = self._get_perm(perm)

        # check if we have that permission already

        obj = self.sa.query(UserGroupRepoToPerm) \

            .filter(UserGroupRepoToPerm.users_group == group_name) \

            .filter(UserGroupRepoToPerm.repository == repo) \

            .scalar()

        if obj is None:

            # create new

            obj = UserGroupRepoToPerm()

        obj.repository = repo

        obj.users_group = group_name

        obj.permission = permission

        self.sa.add(obj)

        log.debug('Granted perm %s to %s on %s' % (perm, group_name, repo))

        return obj

    def revoke_user_group_permission(self, repo, group_name):

        """

        Revoke permission for user group on given repository

        :param repo: Instance of Repository, repository_id, or repository name

        :param group_name: Instance of UserGroup, users_group_id,

            or user group name

        """

        repo = self._get_repo(repo)

        group_name = self._get_user_group(group_name)

        obj = self.sa.query(UserGroupRepoToPerm) \

            .filter(UserGroupRepoToPerm.repository == repo) \

            .filter(UserGroupRepoToPerm.users_group == group_name) \

            .scalar()

        if obj:

            self.sa.delete(obj)

            log.debug('Revoked perm to %s on %s' % (repo, group_name))

    def delete_stats(self, repo_name):

        """

        removes stats for given repo

        :param repo_name:

        """

        repo = self._get_repo(repo_name)

        try:

            obj = self.sa.query(Statistics) \

                .filter(Statistics.repository == repo).scalar()

            if obj:

                self.sa.delete(obj)

        except Exception:

            log.error(traceback.format_exc())

            raise

    def _create_filesystem_repo(self, repo_name, repo_type, repo_group,

                                clone_uri=None, repo_store_location=None):

        """

        makes repository on filesystem. It's group aware means it'll create

        a repository within a group, and alter the paths accordingly of

        group location

        :param repo_name:

        :param alias:

        :param parent:

        :param clone_uri:

        :param repo_store_location:

        """

        from kallithea.lib.utils import is_valid_repo, is_valid_repo_group

        from kallithea.model.scm import ScmModel

        if '/' in repo_name:

            raise ValueError('repo_name must not contain groups got `%s`' % repo_name)

        if isinstance(repo_group, RepoGroup):

            new_parent_path = os.sep.join(repo_group.full_path_splitted)

        else:

            new_parent_path = repo_group or ''

        if repo_store_location:

            _paths = [repo_store_location]

        else:

            _paths = [self.repos_path, new_parent_path, repo_name]

            # we need to make it str for mercurial

        repo_path = os.path.join(*map(lambda x: safe_str(x), _paths))

        # check if this path is not a repository

        if is_valid_repo(repo_path, self.repos_path):

            raise Exception('This path %s is a valid repository' % repo_path)

        # check if this path is a group

        if is_valid_repo_group(repo_path, self.repos_path):

            raise Exception('This path %s is a valid group' % repo_path)

        log.info('creating repo %s in %s from url: `%s`' % (

            repo_name, safe_unicode(repo_path),

            obfuscate_url_pw(clone_uri)))

        backend = get_backend(repo_type)

        if repo_type == 'hg':

            baseui = make_ui('db', clear_session=False)

            # patch and reset hooks section of UI config to not run any

            # hooks on creating remote repo

            for k, v in baseui.configitems('hooks'):

                baseui.setconfig('hooks', k, None)

            repo = backend(repo_path, create=True, src_url=clone_uri, baseui=baseui)

        elif repo_type == 'git':

            repo = backend(repo_path, create=True, src_url=clone_uri, bare=True)

            # add kallithea hook into this repo

            ScmModel().install_git_hook(repo=repo)

        else:

            raise Exception('Not supported repo_type %s expected hg/git' % repo_type)

        log.debug('Created repo %s with %s backend'

                  % (safe_unicode(repo_name), safe_unicode(repo_type)))

        return repo

    def _rename_filesystem_repo(self, old, new):

        """

        renames repository on filesystem

        :param old: old name

        :param new: new name

        """

        log.info('renaming repo from %s to %s' % (old, new))

        old_path = os.path.join(self.repos_path, old)

        new_path = os.path.join(self.repos_path, new)

        if os.path.isdir(new_path):

            raise Exception(

                'Was trying to rename to already existing dir %s' % new_path

            )

        shutil.move(old_path, new_path)

    def _delete_filesystem_repo(self, repo):

        """

        :param repo: repo object

        """

        rm_path = os.path.join(self.repos_path, repo.repo_name)

        _now = datetime.now()

        _ms = str(_now.microsecond).rjust(6, '0')

        _d = 'rm__%s__%s' % (_now.strftime('%Y%m%d_%H%M%S_' + _ms),

                             repo.just_name)

        if repo.group:

            args = repo.group.full_path_splitted + [_d]

            _d = os.path.join(*args)

            shutil.move(rm_path, os.path.join(self.repos_path, _d))