# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import traceback

from collections import defaultdict

from webob.exc import HTTPForbidden

from pylons import tmpl_context as c, url, request, response

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from pylons.decorators import jsonify

from rhodecode.lib.vcs.exceptions import RepositoryError, ChangesetError, \

    ChangesetDoesNotExistError

from rhodecode.lib.vcs.nodes import FileNode

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.compat import OrderedDict

from rhodecode.lib import diffs

from rhodecode.model.db import ChangesetComment, ChangesetStatus

from rhodecode.model.comment import ChangesetCommentsModel

from rhodecode.model.changeset_status import ChangesetStatusModel

from rhodecode.model.meta import Session

from rhodecode.lib.diffs import wrapped_diff

from rhodecode.model.repo import RepoModel

from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError

log = logging.getLogger(__name__)

def _update_with_GET(params, GET):

    for k in ['diff1', 'diff2', 'diff']:

        params[k] += GET.getall(k)

def anchor_url(revision, path, GET):

    fid = h.FID(revision, path)

    return h.url.current(anchor=fid, **dict(GET))

def get_ignore_ws(fid, GET):

    ig_ws_global = GET.get('ignorews')

    ig_ws = filter(lambda k: k.startswith('WS'), GET.getall(fid))

    if ig_ws:

        try:

            return int(ig_ws[0].split(':')[-1])

        except:

            pass

    return ig_ws_global

                                   'repository.admin')

    def __before__(self):

        super(CompareController, self).__before__()

    def __get_cs_or_redirect(self, rev, repo, redirect_after=True):

        """

        Safe way to get changeset if error occur it redirects to changeset with

        proper message

        :param rev: revision to fetch

        :param repo: repo instance

        """

        try:

            type_, rev = rev

            return repo.scm_instance.get_changeset(rev)

        except EmptyRepositoryError, e:

            if not redirect_after:

                return None

            h.flash(h.literal(_('There are no changesets yet')),

                    category='warning')

            redirect(url('summary_home', repo_name=repo.repo_name))

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('summary_home', repo_name=repo.repo_name))

    def index(self, org_ref_type, org_ref, other_ref_type, other_ref):

        org_repo = c.rhodecode_db_repo.repo_name

        org_ref = (org_ref_type, org_ref)

        other_ref = (other_ref_type, other_ref)

        other_repo = request.GET.get('repo', org_repo)

        c.swap_url = h.url('compare_url', repo_name=other_repo,

              org_ref_type=other_ref[0], org_ref=other_ref[1],

              other_ref_type=org_ref[0], other_ref=org_ref[1],

              repo=org_repo)

        c.org_repo = org_repo = Repository.get_by_repo_name(org_repo)

        c.other_repo = other_repo = Repository.get_by_repo_name(other_repo)

        if c.org_repo is None or c.other_repo is None:

            log.error('Could not found repo %s or %s' % (org_repo, other_repo))

            raise HTTPNotFound

        if c.org_repo.scm_instance.alias != 'hg':

            log.error('Review not available for GIT REPOS')

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import with_statement

import os

import logging

import traceback

import tempfile

from pylons import request, response, tmpl_context as c, url

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from pylons.decorators import jsonify

from rhodecode.lib import diffs

from rhodecode.lib import helpers as h

from rhodecode.lib.compat import OrderedDict

from rhodecode.lib.utils2 import convert_line_endings, detect_mode, safe_str

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import RepositoryError, \

    ChangesetDoesNotExistError, EmptyRepositoryError, \

    ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError

from rhodecode.lib.vcs.nodes import FileNode

from rhodecode.model.repo import RepoModel

from rhodecode.model.scm import ScmModel

from rhodecode.model.db import Repository

from rhodecode.controllers.changeset import anchor_url, _ignorews_url,\

    _context_url, get_line_ctx, get_ignore_ws

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    def __before__(self):

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

    def __get_cs_or_redirect(self, rev, repo_name, redirect_after=True):

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import traceback

import calendar

import logging

import urllib

from time import mktime

from datetime import timedelta, date

from urlparse import urlparse

from rhodecode.lib.compat import product

from rhodecode.lib.vcs.exceptions import ChangesetError, EmptyRepositoryError, \

    NodeDoesNotExistError

from pylons import tmpl_context as c, request, url, config

from pylons.i18n.translation import _

from beaker.cache import cache_region, region_invalidate

from rhodecode.config.conf import ALL_READMES, ALL_EXTS, LANGUAGES_EXTENSIONS_MAP

from rhodecode.model.db import Statistics, CacheInvalidation

from rhodecode.lib.utils2 import safe_unicode

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.markup_renderer import MarkupRenderer

from rhodecode.lib.celerylib import run_task

from rhodecode.lib.celerylib.tasks import get_commits_stats

from rhodecode.lib.helpers import RepoPage

from rhodecode.lib.compat import json, OrderedDict

from rhodecode.lib.vcs.nodes import FileNode

log = logging.getLogger(__name__)

README_FILES = [''.join([x[0][0], x[1][0]]) for x in

                    sorted(list(product(ALL_READMES, ALL_EXTS)),

                           key=lambda y:y[0][1] + y[1][1])]

class SummaryController(BaseRepoController):

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(SummaryController, self).__before__()

    def index(self, repo_name):

        c.dbrepo = dbrepo = c.rhodecode_db_repo

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import re

import difflib

import markupsafe

from itertools import tee, imap

from mercurial import patch

from mercurial.mdiff import diffopts

from mercurial.bundlerepo import bundlerepository

from pylons.i18n.translation import _

from rhodecode.lib.compat import BytesIO

from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.vcs.nodes import FileNode, SubModuleNode

from rhodecode.lib.helpers import escape

def wrap_to_table(str_):

    return '''<table class="code-difftable">

                <tr class="line no-comment">

                <td class="lineno new"></td>

                <td class="code no-comment"><pre>%s</pre></td>

                </tr>

              </table>''' % str_

def wrapped_diff(filenode_old, filenode_new, cut_off_limit=None,

                ignore_whitespace=True, line_context=3,

                enable_comments=False):

    """

    returns a wrapped diff into a table, checks for cut_off_limit and presents

    proper message

    """

    if filenode_old is None:

        filenode_old = FileNode(filenode_new.path, '', EmptyChangeset())

    if filenode_old.is_binary or filenode_new.is_binary:

        diff = wrap_to_table(_('binary file'))

    repositories

    :param org_repo:

    :type org_repo:

    :param org_ref:

    :type org_ref:

    :param other_repo:

    :type other_repo:

    :param other_ref:

    :type other_ref:

    """

    bundlerepo = None

    ignore_whitespace = False

    context = 3

    org_repo = org_repo.scm_instance._repo

    other_repo = other_repo.scm_instance._repo

    opts = diffopts(git=True, ignorews=ignore_whitespace, context=context)

    org_ref = org_ref[1]

    other_ref = other_ref[1]

    if org_repo != other_repo:

        common, incoming, rheads = discovery_data

        # create a bundle (uncompressed if other repo is not local)

            # disable repo hooks here since it's just bundle !

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

            # hooks on fetching archives with subrepos

            for k, _ in other_repo.ui.configitems('hooks'):

                other_repo.ui.setconfig('hooks', k, None)

            unbundle = other_repo.getbundle('incoming', common=common,

                                            heads=rheads)

            buf = BytesIO()

            while True:

                chunk = unbundle._stream.read(1024 * 4)

                if not chunk:

                    break

                buf.write(chunk)

            buf.seek(0)

            # replace chunked _stream with data that can do tell() and seek()

            unbundle._stream = buf

            ui = make_ui('db')

            bundlerepo = InMemoryBundleRepo(ui, path=org_repo.root,

                                            bundlestream=unbundle)

    """

    Updates pylons config with new settings from database

    :param config:

    """

    hgsettings = RhodeCodeSetting.get_app_settings()

    for k, v in hgsettings.items():

        config[k] = v

def invalidate_cache(cache_key, *args):

    """

    Puts cache invalidation task into db for

    further global cache invalidation

    """

    from rhodecode.model.scm import ScmModel

    if cache_key.startswith('get_repo_cached_'):

        name = cache_key.split('get_repo_cached_')[-1]

        ScmModel().mark_for_invalidation(name)

def map_groups(path):

    """

    Given a full path to a repository, create all nested groups that this

    repo is inside. This function creates parent-child relationships between

    groups and creates default perms for all new groups.

    :param paths: full path to repository

    """

    sa = meta.Session()

    groups = path.split(Repository.url_sep())

    parent = None

    group = None

    # last element is repo in nested groups structure

    groups = groups[:-1]

    rgm = ReposGroupModel(sa)

    for lvl, group_name in enumerate(groups):

        group_name = '/'.join(groups[:lvl] + [group_name])

        group = RepoGroup.get_by_group_name(group_name)

        desc = '%s group' % group_name

        # skip folders that are now removed repos

        if REMOVED_REPO_PAT.match(group_name):

            break

    """

    Returns a url with removed credentials

    :param uri:

    """

    uri = uri_filter(uri)

    #check if we have port

    if len(uri) > 2 and uri[2]:

        uri[2] = ':' + uri[2]

    return ''.join(uri)

def get_changeset_safe(repo, rev):

    """

    Safe version of get_changeset if this changeset doesn't exists for a

    repo it returns a Dummy one instead

    :param repo:

    :param rev:

    """

    from rhodecode.lib.vcs.backends.base import BaseRepository

    from rhodecode.lib.vcs.exceptions import RepositoryError

    if not isinstance(repo, BaseRepository):

        raise Exception('You must pass an Repository '

                        'object as first argument got %s', type(repo))

    try:

        cs = repo.get_changeset(rev)

    except RepositoryError:

        cs = EmptyChangeset(requested_revision=rev)

    return cs

MENTIONS_REGEX = r'(?:^@|\s@)([a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+)(?:\s{1})'

def extract_mentioned_users(s):

    """

    Returns unique usernames from given string s that have @mention

    :param s: string to get mentions

    """

    usrs = set()

    for username in re.findall(MENTIONS_REGEX, s):

        usrs.add(username)

    return sorted(list(usrs), key=lambda k: k.lower())

class AttributeDict(dict):

    def __getattr__(self, attr):

        return self.get(attr, None)

    __setattr__ = dict.__setitem__

    __delattr__ = dict.__delitem__

"""

Mercurial libs compatibility

"""

from mercurial import archival, merge as hg_merge, patch, ui

from mercurial.commands import clone, nullid, pull

from mercurial.context import memctx, memfilectx

from mercurial.error import RepoError, RepoLookupError, Abort

from mercurial.hgweb.common import get_contact

from mercurial.localrepo import localrepository

from mercurial.match import match

from mercurial.mdiff import diffopts

from mercurial.node import hex

from mercurial.encoding import tolocal

from mercurial import discovery

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import binascii

import datetime

from pylons.i18n.translation import _

from rhodecode.model.meta import Session

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

from rhodecode.model.db import PullRequest, PullRequestReviewers, Notification

from rhodecode.model.notification import NotificationModel

from rhodecode.lib.utils2 import safe_unicode

log = logging.getLogger(__name__)

class PullRequestModel(BaseModel):

    cls = PullRequest

    def __get_pull_request(self, pull_request):

        return self._get_instance(PullRequest, pull_request)

    def get_all(self, repo):

        repo = self._get_repo(repo)

        return PullRequest.query().filter(PullRequest.other_repo == repo).all()

    def create(self, created_by, org_repo, org_ref, other_repo,

               other_ref, revisions, reviewers, title, description=None):

        created_by_user = self._get_user(created_by)

        org_repo = self._get_repo(org_repo)

        other_repo = self._get_repo(other_repo)

        new = PullRequest()

        new.org_repo = org_repo

        pull_request = self.__get_pull_request(pull_request)

        pull_request.status = PullRequest.STATUS_CLOSED

        pull_request.updated_on = datetime.datetime.now()

        self.sa.add(pull_request)

    def _get_changesets(self, org_repo, org_ref, other_repo, other_ref,

                        discovery_data):

        """

        Returns a list of changesets that are incoming from org_repo@org_ref

        to other_repo@other_ref

        :param org_repo:

        :type org_repo:

        :param org_ref:

        :type org_ref:

        :param other_repo:

        :type other_repo:

        :param other_ref:

        :type other_ref:

        :param tmp:

        :type tmp:

        """

        changesets = []

        #case two independent repos

            common, incoming, rheads = discovery_data

                revs = org_repo._repo.changelog.findmissing(common, rheads)

            for cs in reversed(map(binascii.hexlify, revs)):

                changesets.append(org_repo.get_changeset(cs))

        else:

            _revset_predicates = {

                    'branch': 'branch',

                    'book': 'bookmark',

                    'tag': 'tag',

                    'rev': 'id',

                }

            revs = [

                "ancestors(%s('%s')) and not ancestors(%s('%s'))" % (

                    _revset_predicates[org_ref[0]], org_ref[1],

                    _revset_predicates[other_ref[0]], other_ref[1]

               )

            ]

            out = scmutil.revrange(org_repo._repo, revs)

            for cs in reversed(out):

                changesets.append(org_repo.get_changeset(cs))

        return changesets

    def _get_discovery(self, org_repo, org_ref, other_repo, other_ref):

        """

        Get's mercurial discovery data used to calculate difference between

        repos and refs

        :param org_repo:

        :type org_repo:

        :param org_ref:

        :type org_ref:

        :param other_repo:

        :type other_repo:

        :param other_ref:

        :type other_ref:

        """

        log.debug('Doing discovery for %s@%s vs %s@%s' % (

                        org_repo, org_ref, other_repo, other_ref)

        )

        tmp = discovery.findcommonincoming(

                  force=False

        )

        return tmp

    def get_compare_data(self, org_repo, org_ref, other_repo, other_ref):

        """

        Returns a tuple of incomming changesets, and discoverydata cache

        :param org_repo:

        :type org_repo:

        :param org_ref:

        :type org_ref:

        :param other_repo:

        :type other_repo:

        :param other_ref:

        :type other_ref:

        """

        if len(org_ref) != 2 or not isinstance(org_ref, (list, tuple)):

            raise Exception('org_ref must be a two element list/tuple')

        if len(other_ref) != 2 or not isinstance(org_ref, (list, tuple)):

            raise Exception('other_ref must be a two element list/tuple')

        discovery_data = self._get_discovery(org_repo.scm_instance,

                                           org_ref,

                                           other_repo.scm_instance,

                                           other_ref)

        cs_ranges = self._get_changesets(org_repo.scm_instance,

                                           org_ref,

                                           other_repo.scm_instance,

                                           other_ref,

                                           discovery_data)

        return cs_ranges, discovery_data

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import with_statement

import os

import re

import time

import traceback

import logging

import cStringIO

import pkg_resources

from os.path import dirname as dn, join as jn

from sqlalchemy import func

from pylons.i18n.translation import _

import rhodecode

from rhodecode.lib.vcs import get_backend

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.nodes import FileNode

from rhodecode import BACKENDS

from rhodecode.lib import helpers as h

from rhodecode.lib.utils2 import safe_str, safe_unicode

from rhodecode.lib.auth import HasRepoPermissionAny, HasReposGroupPermissionAny

from rhodecode.lib.utils import get_repos as get_filesystem_repos, make_ui, \

from rhodecode.model import BaseModel

from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \

    UserFollowing, UserLog, User, RepoGroup, PullRequest

log = logging.getLogger(__name__)

class UserTemp(object):

    def __init__(self, user_id):

        self.user_id = user_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)

class RepoTemp(object):

    def __init__(self, repo_id):

        self.repo_id = repo_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)

class CachedRepoList(object):

            raise Exception("This repository doesn't have a clone uri")

        repo = dbrepo.scm_instance

        try:

            extras = {

                'ip': '',

                'username': username,

                'action': 'push_remote',

                'repository': dbrepo.repo_name,

                'scm': repo.alias,

            }

            Repository.inject_ui(repo, extras=extras)

            if repo.alias == 'git':

                repo.fetch(clone_uri)

            else:

                repo.pull(clone_uri)

            self.mark_for_invalidation(dbrepo.repo_name)

        except:

            log.error(traceback.format_exc())

            raise

    def commit_change(self, repo, repo_name, cs, user, author, message,

                      content, f_path):

        if repo.alias == 'hg':

            from rhodecode.lib.vcs.backends.hg import \

                MercurialInMemoryChangeset as IMC

        elif repo.alias == 'git':

            from rhodecode.lib.vcs.backends.git import \

                GitInMemoryChangeset as IMC

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        content = safe_str(content)

        path = safe_str(f_path)

        # message and author needs to be unicode

        # proper backend should then translate that into required type

        message = safe_unicode(message)

        author = safe_unicode(author)

        m = IMC(repo)

        m.change(FileNode(path, content))

        tip = m.commit(message=message,

                       author=author,

                       parents=[cs], branch=cs.branch)

        action = 'push_local:%s' % tip.raw_id

        action_logger(user, action, repo_name)

        self.mark_for_invalidation(repo_name)

    def create_node(self, repo, repo_name, cs, user, author, message, content,

                      f_path):

        if repo.alias == 'hg':

            from rhodecode.lib.vcs.backends.hg import MercurialInMemoryChangeset as IMC

        elif repo.alias == 'git':

            from rhodecode.lib.vcs.backends.git import GitInMemoryChangeset as IMC

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        if isinstance(content, (basestring,)):

            content = safe_str(content)

        elif isinstance(content, (file, cStringIO.OutputType,)):

            content = content.read()

        else:

            raise Exception('Content is of unrecognized type %s' % (

                type(content)

            ))

        message = safe_unicode(message)

        author = safe_unicode(author)

        path = safe_str(f_path)

        m = IMC(repo)

        if isinstance(cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            parents = [cs]

        m.add(FileNode(path, content=content))

        tip = m.commit(message=message,

                       author=author,

                       parents=parents, branch=cs.branch)

        action = 'push_local:%s' % tip.raw_id

        action_logger(user, action, repo_name)

        self.mark_for_invalidation(repo_name)

    def get_nodes(self, repo_name, revision, root_path='/', flat=True):

        """

        recursive walk in root dir and return a set of all path in that dir

        based on repository walk function

        :param repo_name: name of repository

        :param revision: revision for which to list nodes

        :param root_path: root path to list

        :param flat: return as a list, if False returns a dict with decription