# -*- coding: utf-8 -*-

# 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/>.

"""

kallithea.controllers.files

~~~~~~~~~~~~~~~~~~~~~~~~~~~

Files controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 21, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

from __future__ import with_statement

import os

import logging

import traceback

import tempfile

import shutil

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

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from kallithea.lib.utils import jsonify, action_logger

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.compat import OrderedDict

from kallithea.lib.utils2 import convert_line_endings, detect_mode, safe_str,\

    str2bool

from kallithea.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.conf import settings

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

    ChangesetDoesNotExistError, EmptyRepositoryError, \

    ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,\

    NodeDoesNotExistError, ChangesetError, NodeError

from kallithea.lib.vcs.nodes import FileNode

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

from kallithea.model.db import Repository

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

    _context_url, get_line_ctx, get_ignore_ws

from webob.exc import HTTPNotFound

from kallithea.lib.exceptions import NonRelativePathError

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(self, rev, silent_empty=False):

        """

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

        proper message

        :param rev: revision to fetch

        :silent_empty: return None if repository is empty

        """

        try:

            return c.db_repo_scm_instance.get_changeset(rev)

        except EmptyRepositoryError, e:

            if silent_empty:

                return None

            url_ = url('files_add_home',

                       repo_name=c.repo_name,

                       revision=0, f_path='', anchor='edit')

            add_new = h.link_to(_('Click here to add new file'), url_, class_="alert-link")

            h.flash(h.literal(_('There are no files yet. %s') % add_new),

                    category='warning')

            raise HTTPNotFound()

        except(ChangesetDoesNotExistError, LookupError), e:

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        except RepositoryError, e:

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

    def __get_filenode(self, cs, path):

        """

        Returns file_node or raise HTTP error.

        :param cs: given changeset

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

                raise RepositoryError('given path is a directory')

        except(ChangesetDoesNotExistError,), e:

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        except RepositoryError, e:

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

        return file_node

    @LoginRequired()

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

                                   'repository.admin')

    def index(self, repo_name, revision, f_path, annotate=False):

        # redirect to given revision from form if given

        post_revision = request.POST.get('at_rev', None)

        if post_revision:

            cs = self.__get_cs(post_revision) # FIXME - unused!

        c.revision = revision

        c.changeset = self.__get_cs(revision)

        c.branch = request.GET.get('branch', None)

        c.f_path = f_path

        c.annotate = annotate

        cur_rev = c.changeset.revision

        # prev link

        try:

            prev_rev = c.db_repo_scm_instance.get_changeset(cur_rev).prev(c.branch)

            c.url_prev = url('files_home', repo_name=c.repo_name,

                         revision=prev_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_prev += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_prev = '#'

        # next link

        try:

            next_rev = c.db_repo_scm_instance.get_changeset(cur_rev).next(c.branch)

            c.url_next = url('files_home', repo_name=c.repo_name,

                     revision=next_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_next += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_next = '#'

        # files or dirs

        try:

            c.file = c.changeset.get_node(f_path)

            if c.file.is_file():

                c.load_full_history = False

                file_last_cs = c.file.last_changeset

                c.file_changeset = (c.changeset

                                    if c.changeset.revision < file_last_cs.revision

                                    else file_last_cs)

                #determine if we're on branch head

                _branches = c.db_repo_scm_instance.branches

                c.on_branch_head = revision in _branches.keys() + _branches.values()

                _hist = []

                c.file_history = []

                if c.load_full_history:

                    c.file_history, _hist = self._get_node_history(c.changeset, f_path)

                c.authors = []

                for a in set([x.author for x in _hist]):

                    c.authors.append((h.email(a), h.person(a)))

            else:

                c.authors = c.file_history = []

        except RepositoryError, e:

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return render('files/files_ypjax.html')

        return render('files/files.html')

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

    def history(self, repo_name, revision, f_path):

        changeset = self.__get_cs(revision)

        f_path = f_path

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, f_path)

            res = []

            for obj in file_history:

                res.append({

                    'text': obj[1],

                    'children': [{'id': o[0], 'text': o[1]} for o in obj[0]]

                })

            data = {

                'more': False,

                'results': res

            }

            return data

    @LoginRequired()

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

                                   'repository.admin')

    def authors(self, repo_name, revision, f_path):

        changeset = self.__get_cs(revision)

        f_path = f_path

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, f_path)

            c.authors = []

            for a in set([x.author for x in _hist]):

                c.authors.append((h.email(a), h.person(a)))

            return render('files/files_history_box.html')

    @LoginRequired()

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

                                   'repository.admin')

    def rawfile(self, repo_name, revision, f_path):

        cs = self.__get_cs(revision)

        file_node = self.__get_filenode(cs, f_path)

        response.content_disposition = 'attachment; filename=%s' % \

            safe_str(f_path.split(Repository.url_sep())[-1])

        response.content_type = file_node.mimetype

        return file_node.content

    @LoginRequired()

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

                                   'repository.admin')

    def raw(self, repo_name, revision, f_path):

        cs = self.__get_cs(revision)

        file_node = self.__get_filenode(cs, f_path)

        raw_mimetype_mapping = {

            # map original mimetype to a mimetype used for "show as raw"

            # you can also provide a content-disposition to override the

            # default "attachment" disposition.

            # orig_type: (new_type, new_dispo)

            # show images inline:

            'image/x-icon': ('image/x-icon', 'inline'),

            'image/png': ('image/png', 'inline'),

            'image/gif': ('image/gif', 'inline'),

            'image/jpeg': ('image/jpeg', 'inline'),

            'image/svg+xml': ('image/svg+xml', 'inline'),

        }

        mimetype = file_node.mimetype

        try:

            mimetype, dispo = raw_mimetype_mapping[mimetype]

        except KeyError:

            # we don't know anything special about this, handle it safely

            if file_node.is_binary:

                # do same as download raw for binary files

                mimetype, dispo = 'application/octet-stream', 'attachment'

            else:

                # do not just use the original mimetype, but force text/plain,

                # otherwise it would serve text/html and that might be unsafe.

                # Note: underlying vcs library fakes text/plain mimetype if the

                # mimetype can not be determined and it thinks it is not

                # binary.This might lead to erroneous text display in some

                # cases, but helps in other cases, like with text files

                # without extension.

                mimetype, dispo = 'text/plain', 'inline'

        if dispo == 'attachment':

            dispo = 'attachment; filename=%s' % \

                        safe_str(f_path.split(os.sep)[-1])

        response.content_disposition = dispo

        response.content_type = mimetype

        return file_node.content

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def delete(self, repo_name, revision, f_path):

        repo = c.db_repo

        if repo.enable_locking and repo.locked[0]:

            h.flash(_('This repository is has been locked by %s on %s')

                % (h.person_by_id(repo.locked[0]),

                   h.fmt_date(h.time_to_datetime(repo.locked[1]))),

                'warning')

            return redirect(h.url('files_home',

                                  repo_name=repo_name, revision='tip'))

        # check if revision is a branch identifier- basically we cannot

        # create multiple heads via file editing

        _branches = repo.scm_instance.branches

        # check if revision is a branch name or branch hash

        if revision not in _branches.keys() + _branches.values():

        # ChangesetDoesNotExistError)

        if rev1 != self.EMPTY_CHANGESET:

            self.get_changeset(rev1)

        self.get_changeset(rev2)

        if path:

            file_filter = match(self.path, '', [path])

        else:

            file_filter = None

        return ''.join(patch.diff(self._repo, rev1, rev2, match=file_filter,

                          opts=diffopts(git=True,

                                        ignorews=ignore_whitespace,

                                        context=context)))

    @classmethod

    def _check_url(cls, url, repoui=None):

        """

        Function will check given url and try to verify if it's a valid

        link. Sometimes it may happened that mercurial will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError, exception is also thrown

        when the return code is non 200

        """

        # check first if it's not an local url

        if os.path.isdir(url) or url.startswith('file:'):

            return True

        if '+' in url[:url.find('://')]:

            url = url[url.find('+') + 1:]

        handlers = []

        url_obj = hg_url(url)

        test_uri, authinfo = url_obj.authinfo()

        url_obj.passwd = '*****'

        cleaned_uri = str(url_obj)

        if authinfo:

            #create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

            handlers.extend((httpbasicauthhandler(passmgr),

                             httpdigestauthhandler(passmgr)))

        o = urllib2.build_opener(*handlers)

        o.addheaders = [('Content-Type', 'application/mercurial-0.1'),

                        ('Accept', 'application/mercurial-0.1')]

        q = {"cmd": 'between'}

        q.update({'pairs': "%s-%s" % ('0' * 40, '0' * 40)})

        qs = '?%s' % urllib.urlencode(q)

        cu = "%s%s" % (test_uri, qs)

        req = urllib2.Request(cu, None, {})

        try:

            resp = o.open(req)

            if resp.code != 200:

                raise Exception('Return Code is not 200')

        except Exception, e:

            # means it cannot be cloned

            raise urllib2.URLError("[%s] org_exc: %s" % (cleaned_uri, e))

        # now check if it's a proper hg repo

        try:

            httppeer(repoui or ui.ui(), url).lookup('tip')

        except Exception, e:

            raise urllib2.URLError(

                "url [%s] does not look like an hg repo org_exc: %s"

                % (cleaned_uri, e))

        return True

    def _get_repo(self, create, src_url=None, update_after_clone=False):

        """

        Function will check for mercurial repository in given path and return

        a localrepo object. If there is no repository in that path it will

        raise an exception unless ``create`` parameter is set to True - in

        that case repository would be created and returned.

        If ``src_url`` is given, would try to clone repository from the

        location at given clone_point. Additionally it'll make update to

        working copy accordingly to ``update_after_clone`` flag

        """

        try:

            if src_url:

                url = str(self._get_url(src_url))

                opts = {}

                if not update_after_clone:

                    opts.update({'noupdate': True})

                try:

                    MercurialRepository._check_url(url, self.baseui)

                    clone(self.baseui, url, self.path, **opts)

#                except urllib2.URLError:

#                    raise Abort("Got HTTP 404 error")

                except Exception:

                    raise

                # Don't try to create if we've already cloned repo

                create = False

            return localrepository(self.baseui, self.path, create=create)

        except (Abort, RepoError), err:

            if create:

                msg = "Cannot create repository at %s. Original error was %s"\

                    % (self.path, err)

            else:

                msg = "Not valid repository at %s. Original error was %s"\

                    % (self.path, err)

            raise RepositoryError(msg)

    @LazyProperty

    def in_memory_changeset(self):

        return MercurialInMemoryChangeset(self)

    @LazyProperty

    def description(self):

        undefined_description = u'unknown'

        _desc = self._repo.ui.config('web', 'description', None, untrusted=True)

        return safe_unicode(_desc or undefined_description)

    @LazyProperty

    def contact(self):

        undefined_contact = u'Unknown'

        return safe_unicode(get_contact(self._repo.ui.config)

                            or undefined_contact)

    @LazyProperty

    def last_change(self):

        """

        Returns last change made on this repository as datetime object

        """

        return date_fromtimestamp(self._get_mtime(), makedate()[1])

    def _get_mtime(self):

        try:

            return time.mktime(self.get_changeset().date.timetuple())

        except RepositoryError:

            #fallback to filesystem

            cl_path = os.path.join(self.path, '.hg', "00changelog.i")

            st_path = os.path.join(self.path, '.hg', "store")

            if os.path.exists(cl_path):

                return os.stat(cl_path).st_mtime

            else:

                return os.stat(st_path).st_mtime

    def _get_hidden(self):

        return self._repo.ui.configbool("web", "hidden", untrusted=True)

    def _get_revision(self, revision):

        """

        Gets an ID revision given as str. This will always return a fill

        40 char revision number

        :param revision: str or int or None

        """

        if isinstance(revision, unicode):

            revision = safe_str(revision)

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in [-1, 'tip', None]:

            revision = 'tip'

        try:

            revision = hex(self._repo.lookup(revision))

        except (LookupError, ):

            msg = ("Ambiguous identifier `%s` for %s" % (revision, self))

            raise ChangesetDoesNotExistError(msg)

        except (IndexError, ValueError, RepoLookupError, TypeError):

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

            raise ChangesetDoesNotExistError(msg)

        return revision

    def get_ref_revision(self, ref_type, ref_name):

        """

        Returns revision number for the given reference.

        """

        ref_name = safe_str(ref_name)

        # lookup up the exact node id

        _revset_predicates = {

                'branch': 'branch',

                'book': 'bookmark',

                'tag': 'tag',

                'rev': 'id',

            }

        # avoid expensive branch(x) iteration over whole repo

        rev_spec = "%%s & %s(%%s)" % _revset_predicates[ref_type]

        try:

            revs = self._repo.revs(rev_spec, ref_name, ref_name)

            msg = ("Ambiguous identifier %s:%s for %s" % (ref_type, ref_name, self.name))

            raise ChangesetDoesNotExistError(msg)

            msg = ("Revision %s:%s does not exist for %s" % (ref_type, ref_name, self.name))

            raise ChangesetDoesNotExistError(msg)

        if revs:

            revision = revs[-1]

        else:

            # TODO: just report 'not found'?

            revision = ref_name

        return self._get_revision(revision)

    def _get_archives(self, archive_name='tip'):

        allowed = self.baseui.configlist("web", "allow_archive",

                                         untrusted=True)

        for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:

            if i[0] in allowed or self._repo.ui.configbool("web",

                                                           "allow" + i[0],

                                                           untrusted=True):

                yield {"type": i[0], "extension": i[1], "node": archive_name}

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, would fall

        to filesystem

        (``file:///``) schema.

        """

        url = str(url)

        if url != 'default' and not '://' in url:

            url = "file:" + urllib.pathname2url(url)

        return url

    def get_hook_location(self):

        """

        returns absolute path to location where hooks are stored

        """

        return os.path.join(self.path, '.hg', '.hgrc')

    def get_changeset(self, revision=None):

        """

        Returns ``MercurialChangeset`` object representing repository's

        changeset at the given ``revision``.

        """

        revision = self._get_revision(revision)

        changeset = MercurialChangeset(repository=self, revision=revision)

        return changeset

    def get_changesets(self, start=None, end=None, start_date=None,

                       end_date=None, branch_name=None, reverse=False):

        """

        Returns iterator of ``MercurialChangeset`` objects from start to end

        (both are inclusive)

        :param start: None, str, int or mercurial lookup format

        :param end:  None, str, int or mercurial lookup format

        :param start_date:

        :param end_date:

        :param branch_name:

        :param reversed: return changesets in reversed order

        """

        start_raw_id = self._get_revision(start)

        start_pos = self.revisions.index(start_raw_id) if start else None

        end_raw_id = self._get_revision(end)

        end_pos = self.revisions.index(end_raw_id) if end else None

        if None not in [start, end] and start_pos > end_pos:

            raise RepositoryError("Start revision '%s' cannot be "

                                  "after end revision '%s'" % (start, end))

        if branch_name and branch_name not in self.allbranches.keys():

            msg = ("Branch %s not found in %s" % (branch_name, self))

            raise BranchDoesNotExistError(msg)

        if end_pos is not None:

            end_pos += 1

        #filter branches

        filter_ = []

        if branch_name:

            filter_.append('branch("%s")' % (branch_name))

        if start_date and not end_date:

            filter_.append('date(">%s")' % start_date)

        if end_date and not start_date:

            filter_.append('date("<%s")' % end_date)

        if start_date and end_date:

            filter_.append('date(">%s") and date("<%s")' % (start_date, end_date))

        if filter_:

            revisions = scmutil.revrange(self._repo, filter_)

        else:

            revisions = self.revisions

        revs = revisions[start_pos:end_pos]

        if reverse:

            revs = reversed(revs)

        return CollectionGenerator(self, revs)

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        try:

            other = peer(self._repo, {}, url)

            self._repo.pull(other, heads=None, force=None)

        except Abort, err:

            # Propagate error but with vcs's type

            raise RepositoryError(str(err))

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        return MercurialWorkdir(self)

    def get_config_value(self, section, name=None, config_file=None):

        """

        Returns configuration value for a given [``section``] and ``name``.

        :param section: Section we want to retrieve value from

        :param name: Name of configuration we want to retrieve

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        if config_file is None:

            config_file = []

        elif isinstance(config_file, basestring):

            config_file = [config_file]

        config = self._repo.ui

        for path in config_file:

            config.readconfig(path)

        return config.config(section, name)

    def get_user_name(self, config_file=None):

        """

        Returns user's name from global configuration file.

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        username = self.get_config_value('ui', 'username')

        if username:

            return author_name(username)

        return None

    def get_user_email(self, config_file=None):

        """

        Returns user's email from global configuration file.

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        username = self.get_config_value('ui', 'username')

        if username:

            return author_email(username)

        return None