from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.indexers import JOURNAL_SCHEMA

from kallithea.lib.page import Page

from kallithea.lib.utils2 import remove_prefix, remove_suffix, safe_int

from kallithea.model.db import UserLog

log = logging.getLogger(__name__)

def _journal_filter(user_log, search_term):

    """

    Filters sqlalchemy user_log based on search_term with whoosh Query language

    http://packages.python.org/Whoosh/querylang.html

    :param user_log:

    :param search_term:

    """

    log.debug('Initial search term: %r', search_term)

    qry = None

    if search_term:

        qp = QueryParser('repository', schema=JOURNAL_SCHEMA)

        qp.add_plugin(DateParserPlugin())

        log.debug('Filtering using parsed query %r', qry)

    def wildcard_handler(col, wc_term):

        if wc_term.startswith('*') and not wc_term.endswith('*'):

            # postfix == endswith

            wc_term = remove_prefix(wc_term, prefix='*')

            return func.lower(col).endswith(func.lower(wc_term))

        elif wc_term.startswith('*') and wc_term.endswith('*'):

            # wildcard == ilike

            wc_term = remove_prefix(wc_term, prefix='*')

            wc_term = remove_suffix(wc_term, suffix='*')

            return func.lower(col).contains(func.lower(wc_term))

    def get_filterion(field, val, term):

        if field == 'repository':

            field = getattr(UserLog, 'repository_name')

        elif field == 'ip':

            field = getattr(UserLog, 'user_ip')

        elif field == 'date':

            field = getattr(UserLog, 'action_date')

        elif field == 'username':

            field = getattr(UserLog, 'username')

        else:

        log.debug('IDX: %s', index_name)

        log.debug('SCHEMA: %s', schema_defn)

        if c.cur_query:

            cur_query = c.cur_query.lower()

            log.debug(cur_query)

        if c.cur_query:

            p = safe_int(request.GET.get('page'), 1)

            highlight_items = set()

            index_dir = config['index_dir']

            try:

                if not exists_in(index_dir, index_name):

                    raise EmptyIndexError

                idx = open_dir(index_dir, indexname=index_name)

                searcher = idx.searcher()

                qp = QueryParser(search_type, schema=schema_defn)

                if c.repo_name:

                    # use "repository_rawname:" instead of "repository:"

                    # for case-sensitive matching

                    cur_query = u'repository_rawname:%s %s' % (c.repo_name, cur_query)

                try:

                    # extract words for highlight

                    if isinstance(query, Phrase):

                        highlight_items.update(query.words)

                    elif isinstance(query, Prefix):

                        highlight_items.add(query.text)

                    else:

                        for i in query.all_terms():

                            if i[0] in ['content', 'message']:

                                highlight_items.add(i[1])

                    matcher = query.matcher(searcher)

                    log.debug('query: %s', query)

                    log.debug('hl terms: %s', highlight_items)

                    results = searcher.search(query)

                    res_ln = len(results)

                    c.runtime = '%s results (%.3f seconds)' % (

                        res_ln, results.runtime

                    )

                    repo_location = RepoModel().repos_path

                    c.formated_results = Page(

                        WhooshResultWrapper(search_type, searcher, matcher,

                                            highlight_items, repo_location),

    def _get_all_revisions2(self):

        # alternate implementation using dulwich

        includes = [ascii_str(sha) for key, (sha, type_) in self._parsed_refs.items()

                    if type_ != b'T']

        return [c.commit.id for c in self._repo.get_walker(include=includes)]

    def _get_revision(self, revision):

        """

        Given any revision identifier, returns a 40 char string with revision hash.

        """

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in (None, '', 'tip', 'HEAD', 'head', -1):

            revision = -1

        if isinstance(revision, int):

            try:

                return self.revisions[revision]

            except IndexError:

                msg = "Revision %r does not exist for %s" % (revision, self.name)

                raise ChangesetDoesNotExistError(msg)

            if revision.isdigit() and (len(revision) < 12 or len(revision) == revision.count('0')):

                try:

                    return self.revisions[int(revision)]

                except IndexError:

                    msg = "Revision %r does not exist for %s" % (revision, self)

                    raise ChangesetDoesNotExistError(msg)

            # get by branch/tag name

            _ref_revision = self._parsed_refs.get(safe_bytes(revision))

            if _ref_revision:  # and _ref_revision[1] in [b'H', b'RH', b'T']:

                return ascii_str(_ref_revision[0])

            if revision in self.revisions:

                return revision

            # maybe it's a tag ? we don't have them in self.revisions

            if revision in self.tags.values():

                return revision

            if SHA_PATTERN.match(revision):

                msg = "Revision %r does not exist for %s" % (revision, self.name)

                raise ChangesetDoesNotExistError(msg)

        raise ChangesetDoesNotExistError("Given revision %r not recognized" % revision)

class MercurialInMemoryChangeset(BaseInMemoryChangeset):

    def commit(self, message, author, parents=None, branch=None, date=None,

               **kwargs):

        """

        Performs in-memory commit (doesn't check workdir in any way) and

        returns newly created ``Changeset``. Updates repository's

        ``revisions``.

        :param message: message of the commit

        :param author: full username, i.e. "Joe Doe <joe.doe@example.com>"

        :param parents: single parent or sequence of parents from which commit

          would be derived

        :param date: ``datetime.datetime`` instance. Defaults to

          ``datetime.datetime.now()``.

        :param branch: branch name, as string. If none given, default backend's

          branch would be used.

        :raises ``CommitError``: if any error occurs while committing

        """

        self.check_integrity(parents)

        from .repository import MercurialRepository

        if branch is None:

            branch = MercurialRepository.DEFAULT_BRANCH_NAME

        kwargs[b'branch'] = safe_bytes(branch)

        def filectxfn(_repo, memctx, bytes_path):

            """

            Callback from Mercurial, returning ctx to commit for the given

            path.

            """

            path = safe_str(bytes_path)

            # check if this path is removed

            if path in (node.path for node in self.removed):

                return None

            # check if this path is added

            for node in self.added:

                if node.path == path:

                    return mercurial.context.memfilectx(_repo, memctx, path=bytes_path,

                        data=node.content,

                        islink=False,

                        isexec=node.is_executable,

                        copysource=False)

    app_settings_name = Column(String(255), nullable=False, unique=True)

    _app_settings_value = Column("app_settings_value", Unicode(4096), nullable=False)

    _app_settings_type = Column("app_settings_type", String(255), nullable=True) # FIXME: not nullable?

    def __init__(self, key='', val='', type='unicode'):

        self.app_settings_name = key

        self.app_settings_value = val

        self.app_settings_type = type

    @validates('_app_settings_value')

    def validate_settings_value(self, key, val):

        assert isinstance(val, unicode)

        return val

    @hybrid_property

    def app_settings_value(self):

        v = self._app_settings_value

        _type = self.app_settings_type

        converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode']

        return converter(v)

    @app_settings_value.setter

    def app_settings_value(self, val):

        """

        """

        self._app_settings_value = safe_str(val)

    @hybrid_property

    def app_settings_type(self):

        return self._app_settings_type

    @app_settings_type.setter

    def app_settings_type(self, val):

        if val not in self.SETTINGS_TYPES:

            raise Exception('type must be one of %s got %s'

                            % (list(self.SETTINGS_TYPES), val))

        self._app_settings_type = val

    def __repr__(self):

        return "<%s %s.%s=%r>" % (

            self.__class__.__name__,

            self.app_settings_name, self.app_settings_type, self.app_settings_value

        )

    @classmethod

    def get_by_name(cls, key):

        return cls.query() \

            .filter(cls.app_settings_name == key).scalar()

Contributors are sorted "fairly" by copyright year and amount of

contribution.

New contributors are listed, without considering if the contribution contains

copyrightable work.

When the copyright might belong to a different legal entity than the

contributor, the legal entity is given credit too.

"""

import os

import re

from collections import defaultdict

from . import contributor_data

def sortkey(x):

    """Return key for sorting contributors "fairly":

    * latest contribution

    * first contribution

    * number of contribution years

    * name (with some unicode normalization)

    return (x[0] and -int(x[0][-1]),

            x[0] and int(x[0][0]),

            -len(x[0]),

            x[1].decode('utf-8').lower().replace(u'\xe9', u'e').replace(u'\u0142', u'l')

        )

def nice_years(l, dash='-', join=' '):

    """Convert a list of years into brief range like '1900-1901, 1921'."""

    if not l:

        return ''

    start = end = int(l[0])

    ranges = []

    for year in l[1:] + [0]:

        year = int(year)

        if year == end + 1:

            end = year

            continue

        if start == end:

            ranges.append('%s' % start)

        else:

            ranges.append('%s%s%s' % (start, dash, end))

        start = end = year

    assert start == 0 and end == 0, (start, end)