: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; version 2

# of the License or (at your opinion) any later version of the license.

# 

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

import logging

import tempfile

import rhodecode.lib.helpers as h

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

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import EmptyChangeset

from rhodecode.model.repo import RepoModel

from vcs.backends import ARCHIVE_SPECS

from vcs.exceptions import RepositoryError, ChangesetDoesNotExistError, \

    EmptyRepositoryError, ImproperArchiveTypeError, VCSError

from vcs.nodes import FileNode, NodeKind

from vcs.utils import diffs as differ

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

        """

        :param rev: revision to fetch

        :param repo_name: repo name to redirect after

        """

        try:

            return c.rhodecode_repo.get_changeset(rev)

        except EmptyRepositoryError, e:

            h.flash(_('There are no files yet'), category='warning')

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

        except RepositoryError, e:

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

            redirect(h.url('files_home', repo_name=repo_name, revision='tip'))

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

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

            if post_revision:

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

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

            c.f_path = f_path

            cur_rev = c.changeset.revision

            #prev link

            try:

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

                if c.branch:

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

            except (ChangesetDoesNotExistError, VCSError):

                c.url_prev = '#'

            #next link

            try:

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

                if c.branch:

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

            except (ChangesetDoesNotExistError, VCSError):

                c.url_next = '#'

            #files

            try:

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

            except RepositoryError, e:

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

        return render('files/files.html')

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

        try:

            file_node = cs.get_node(f_path)

        except RepositoryError, e:

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

        fname = f_path.split('/')[-1].encode('utf8', 'replace')

        response.content_type = file_node.mimetype

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

        return file_node.content

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

        try:

            file_node = cs.get_node(f_path)

        except RepositoryError, e:

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

        response.content_type = 'text/plain'

        return file_node.content

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

        try:

            c.file = cs.get_node(f_path)

        except RepositoryError, e:

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

        c.cs = cs

        c.f_path = f_path

        return render('files/files_annotate.html')

    def archivefile(self, repo_name, fname):

        fileformat = None

        revision = None

        ext = None

        for a_type, ext_data in ARCHIVE_SPECS.items():

            archive_spec = fname.split(ext_data[1])

            if len(archive_spec) == 2 and archive_spec[1] == '':

                fileformat = a_type or ext_data[1]

                revision = archive_spec[0]

                ext = ext_data[1]

        try:

            dbrepo = RepoModel().get_by_repo_name(repo_name)

            if dbrepo.enable_downloads is False:

                return _('downloads disabled')

            cs = c.rhodecode_repo.get_changeset(revision)

            content_type = ARCHIVE_SPECS[fileformat][0]

        except ChangesetDoesNotExistError:

            return _('Unknown revision %s') % revision

        except EmptyRepositoryError:

            return _('Empty repository')

        except (ImproperArchiveTypeError, KeyError):

            return _('Unknown archive type')

        response.content_type = content_type

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

            % (repo_name, revision, ext)

        return cs.get_chunked_archive(stream=tempfile.TemporaryFile(),

                                      kind=fileformat)

    def diff(self, repo_name, f_path):

        diff1 = request.GET.get('diff1')

        diff2 = request.GET.get('diff2')

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        try: