# -*- 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.admin.gists

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

gist 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: May 9, 2013

:author: marcink

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

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

"""

import time

import logging

import traceback

import formencode.htmlfill

from pylons import request, response, tmpl_context as c

from pylons.i18n.translation import _

from webob.exc import HTTPFound, HTTPNotFound, HTTPForbidden

from kallithea.config.routing import url

from kallithea.model.forms import GistForm

from kallithea.model.gist import GistModel

from kallithea.model.meta import Session

from kallithea.model.db import Gist, User

from kallithea.lib import helpers as h

from kallithea.lib.base import BaseController, render, jsonify

from kallithea.lib.auth import LoginRequired, NotAnonymous

from kallithea.lib.utils2 import safe_int, safe_unicode, time_to_datetime

from kallithea.lib.page import Page

from sqlalchemy.sql.expression import or_

from kallithea.lib.vcs.exceptions import VCSError, NodeNotChangedError

log = logging.getLogger(__name__)

class GistsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    def __load_defaults(self, extra_values=None):

        c.lifetime_values = [

            (str(-1), _('Forever')),

            (str(5), _('5 minutes')),

            (str(60), _('1 hour')),

            (str(60 * 24), _('1 day')),

            (str(60 * 24 * 30), _('1 month')),

        ]

        if extra_values:

            c.lifetime_values.append(extra_values)

        c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]

    @LoginRequired()

    def index(self):

        not_default_user = not request.authuser.is_default_user

        c.show_private = request.GET.get('private') and not_default_user

        c.show_public = request.GET.get('public') and not_default_user

        gists = Gist().query() \

            .order_by(Gist.created_on.desc())

        # MY private

        if c.show_private and not c.show_public:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE) \

                             .filter(Gist.owner_id == request.authuser.user_id)

        # MY public

        elif c.show_public and not c.show_private:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC) \

                             .filter(Gist.owner_id == request.authuser.user_id)

        # MY public+private

        elif c.show_private and c.show_public:

            gists = gists.filter(or_(Gist.gist_type == Gist.GIST_PUBLIC,

                                     Gist.gist_type == Gist.GIST_PRIVATE)) \

                             .filter(Gist.owner_id == request.authuser.user_id)

        # default show ALL public gists

        if not c.show_public and not c.show_private:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)

        c.gists = gists

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

        c.gists_pager = Page(c.gists, page=p, items_per_page=10)

        return render('admin/gists/index.html')

    @LoginRequired()

    @NotAnonymous()

    def create(self):

        self.__load_defaults()

        gist_form = GistForm([x[0] for x in c.lifetime_values])()

        try:

            form_result = gist_form.to_python(dict(request.POST))

            #TODO: multiple files support, from the form

            filename = form_result['filename'] or Gist.DEFAULT_FILENAME

            nodes = {

                filename: {

                    'content': form_result['content'],

                    'lexer': form_result['mimetype']  # None is autodetect

                }

            }

            _public = form_result['public']

            gist_type = Gist.GIST_PUBLIC if _public else Gist.GIST_PRIVATE

            gist = GistModel().create(

                description=form_result['description'],

                owner=request.authuser.user_id,

                gist_mapping=nodes,

                gist_type=gist_type,

                lifetime=form_result['lifetime']

            )

            Session().commit()

            new_gist_id = gist.gist_access_id

        except formencode.Invalid as errors:

            defaults = errors.value

            return formencode.htmlfill.render(

                render('admin/gists/new.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception as e:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during gist creation'), category='error')

            raise HTTPFound(location=url('new_gist'))

        raise HTTPFound(location=url('gist', gist_id=new_gist_id))

    @LoginRequired()

    @NotAnonymous()

    def new(self, format='html'):

        self.__load_defaults()

        return render('admin/gists/new.html')

    @LoginRequired()

    @NotAnonymous()

    def delete(self, gist_id):

        gist = GistModel().get_gist(gist_id)

        owner = gist.owner_id == request.authuser.user_id

        if h.HasPermissionAny('hg.admin')() or owner:

            GistModel().delete(gist)

            Session().commit()

            h.flash(_('Deleted gist %s') % gist.gist_access_id, category='success')

        else:

            raise HTTPForbidden()

        raise HTTPFound(location=url('gists'))

    @LoginRequired()

    def show(self, gist_id, revision='tip', format='html', f_path=None):

        c.gist = Gist.get_or_404(gist_id)

        try:

            c.file_changeset, c.files = GistModel().get_gist_files(gist_id,

                                                            revision=revision)

        except VCSError:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        if format == 'raw':

            content = '\n\n'.join([f.content for f in c.files if (f_path is None or safe_unicode(f.path) == f_path)])

            response.content_type = 'text/plain'

            return content

        return render('admin/gists/show.html')

    @LoginRequired()

    @NotAnonymous()

    def edit(self, gist_id, format='html'):

        c.gist = Gist.get_or_404(gist_id)

        try:

            c.file_changeset, c.files = GistModel().get_gist_files(gist_id)

        except VCSError:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        self.__load_defaults(extra_values=('0', _('Unmodified')))

        rendered = render('admin/gists/edit.html')

        if request.POST:

            rpost = request.POST

            nodes = {}

            for org_filename, filename, mimetype, content in zip(

                                                    rpost.getall('org_files'),

                                                    rpost.getall('files'),

                                                    rpost.getall('mimetypes'),

                                                    rpost.getall('contents')):

                nodes[org_filename] = {

                    'org_filename': org_filename,

                    'filename': filename,

                    'content': content,

                    'lexer': mimetype,

                }

            try:

                GistModel().update(

                    gist=c.gist,

                    description=rpost['description'],

                    owner=c.gist.owner,

                    gist_mapping=nodes,

                    gist_type=c.gist.gist_type,

                    lifetime=rpost['lifetime']

                )

                Session().commit()

                h.flash(_('Successfully updated gist content'), category='success')

            except NodeNotChangedError:

                # raised if nothing was changed in repo itself. We anyway then

                # store only DB stuff for gist

                Session().commit()

                h.flash(_('Successfully updated gist data'), category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during update of gist %s') % gist_id,

                        category='error')

            raise HTTPFound(location=url('gist', gist_id=gist_id))

        return rendered

    @LoginRequired()

    @NotAnonymous()

    @jsonify

    def check_revision(self, gist_id):

        c.gist = Gist.get_or_404(gist_id)

        last_rev = c.gist.scm_instance.get_changeset()

        success = True

        revision = request.POST.get('revision')

        ##TODO: maybe move this to model ?

        if revision != last_rev.raw_id:

            log.error('Last revision %s is different than submitted %s',

                      revision, last_rev)

            # our gist has newer version than we

            success = False

        return {'success': success}

        :param repogroupid: name or id of repository group

        :type repogroupid: str or int

        :param usergroupid:

        :param apply_to_children: 'none', 'repos', 'groups', 'all'

        :type apply_to_children: str

        OUTPUT::

            id : <id_given_in_input>

            result: {

                      "msg" : "Revoked perm (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",

                      "success": true

                    }

            error:  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

            "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"

          }

        """

        repo_group = get_repo_group_or_error(repogroupid)

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasRepoGroupPermissionLevel('admin')(repo_group.group_name):

                raise JSONRPCError(

                    'repository group `%s` does not exist' % (repogroupid,))

            if not HasUserGroupPermissionLevel('read')(user_group.users_group_name):

                raise JSONRPCError(

                    'user group `%s` does not exist' % (usergroupid,))

        apply_to_children = Optional.extract(apply_to_children)

        try:

            RepoGroupModel().delete_permission(repo_group=repo_group,

                                               obj=user_group,

                                               obj_type="user_group",

                                               recursive=apply_to_children)

            Session().commit()

            return dict(

                msg='Revoked perm (recursive:%s) for user group: `%s` in repo group: `%s`' % (

                    apply_to_children, user_group.users_group_name, repo_group.name

                ),

                success=True

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to edit permission for user group: `%s` in repo group: `%s`' % (

                    user_group.users_group_name, repo_group.name

                )

            )

    def get_gist(self, gistid):

        """

        Get given gist by id

        :param gistid: id of private or public gist

        :type gistid: str

        """

        gist = get_gist_or_error(gistid)

        if not HasPermissionAny('hg.admin')():

            if gist.owner_id != request.authuser.user_id:

                raise JSONRPCError('gist `%s` does not exist' % (gistid,))

        return gist.get_api_data()

    def get_gists(self, userid=Optional(OAttr('apiuser'))):

        """

        Get all gists for given user. If userid is empty returned gists

        are for user who called the api

        :param userid: user to get gists for

        :type userid: Optional(str or int)

        """

        if not HasPermissionAny('hg.admin')():

            # make sure normal user does not pass someone else userid,

            # he is not allowed to do that

            if not isinstance(userid, Optional) and userid != request.authuser.user_id:

                raise JSONRPCError(

                    'userid is not the same as your user'

                )

        if isinstance(userid, Optional):

            user_id = request.authuser.user_id

        else:

            user_id = get_user_or_error(userid).user_id

        return [

            gist.get_api_data()

            for gist in Gist().query()

                .filter(Gist.owner_id == user_id)

                .order_by(Gist.created_on.desc())

        ]

    def create_gist(self, files, owner=Optional(OAttr('apiuser')),

                    gist_type=Optional(Gist.GIST_PUBLIC), lifetime=Optional(-1),

                    description=Optional('')):

        """

        Creates new Gist

        :param files: files to be added to gist

            {'filename': {'content':'...', 'lexer': null},

             'filename2': {'content':'...', 'lexer': null}}

        :type files: dict

        :param owner: gist owner, defaults to api method caller

        :type owner: Optional(str or int)

        :param gist_type: type of gist 'public' or 'private'

        :type gist_type: Optional(str)

        :param lifetime: time in minutes of gist lifetime

        :type lifetime: Optional(int)

        :param description: gist description

        :type description: Optional(str)

        OUTPUT::

          id : <id_given_in_input>

          result : {

            "msg": "created new gist",

            "gist": {}

          }

          error :  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

            "failed to create gist"

          }

        """

        try:

            if isinstance(owner, Optional):

                owner = request.authuser.user_id

            owner = get_user_or_error(owner)

            description = Optional.extract(description)

            gist_type = Optional.extract(gist_type)

            lifetime = Optional.extract(lifetime)

            gist = GistModel().create(description=description,

                                      owner=owner,

                                      gist_mapping=files,

                                      gist_type=gist_type,

                                      lifetime=lifetime)

            Session().commit()

            return dict(

                msg='created new gist',

                gist=gist.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create gist')

    # def update_gist(self, gistid, files, owner=Optional(OAttr('apiuser')),

    #                 gist_type=Optional(Gist.GIST_PUBLIC),

    #                 gist_lifetime=Optional(-1), gist_description=Optional('')):

    #     gist = get_gist_or_error(gistid)

    #     updates = {}

    # permission check inside

    def delete_gist(self, gistid):

        """

        Deletes existing gist

        :param gistid: id of gist to delete

        :type gistid: str

        OUTPUT::

          id : <id_given_in_input>

          result : {

            "deleted gist ID: <gist_id>",

            "gist": null

          }

          error :  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

            "failed to delete gist ID:<gist_id>"

          }

    TYPE_CHANGESET_COMMENT = u'cs_comment'

    TYPE_MESSAGE = u'message'

    TYPE_MENTION = u'mention' # not used

    TYPE_REGISTRATION = u'registration'

    TYPE_PULL_REQUEST = u'pull_request'

    TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'

    notification_id = Column(Integer(), primary_key=True)

    subject = Column(Unicode(512), nullable=False)

    body = Column(UnicodeText(), nullable=False)

    created_by = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    type_ = Column('type', Unicode(255), nullable=False)

    created_by_user = relationship('User')

    notifications_to_users = relationship('UserNotification', cascade="all, delete-orphan")

    @property

    def recipients(self):

        return [x.user for x in UserNotification.query()

                .filter(UserNotification.notification == self)

                .order_by(UserNotification.user_id.asc()).all()]

    @classmethod

    def create(cls, created_by, subject, body, recipients, type_=None):

        if type_ is None:

            type_ = Notification.TYPE_MESSAGE

        notification = cls()

        notification.created_by_user = created_by

        notification.subject = subject

        notification.body = body

        notification.type_ = type_

        notification.created_on = datetime.datetime.now()

        for recipient in recipients:

            un = UserNotification()

            un.notification = notification

            un.user_id = recipient.user_id

            # Mark notifications to self "pre-read" - should perhaps just be skipped

            if recipient == created_by:

                un.read = True

            Session().add(un)

        Session().add(notification)

        Session().flush() # assign notification.notification_id

        return notification

    @property

    def description(self):

        from kallithea.model.notification import NotificationModel

        return NotificationModel().make_description(self)

class UserNotification(Base, BaseDbModel):

    __tablename__ = 'user_to_notification'

    __table_args__ = (

        UniqueConstraint('user_id', 'notification_id'),

        _table_args_default_dict,

    )

    user_id = Column(Integer(), ForeignKey('users.user_id'), primary_key=True)

    notification_id = Column(Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

    read = Column(Boolean, nullable=False, default=False)

    sent_on = Column(DateTime(timezone=False), nullable=True) # FIXME: not nullable?

    user = relationship('User')

    notification = relationship('Notification')

    def mark_as_read(self):

        self.read = True

class Gist(Base, BaseDbModel):

    __tablename__ = 'gists'

    __table_args__ = (

        Index('g_gist_access_id_idx', 'gist_access_id'),

        Index('g_created_on_idx', 'created_on'),

        _table_args_default_dict,

    )

    GIST_PUBLIC = u'public'

    GIST_PRIVATE = u'private'

    DEFAULT_FILENAME = u'gistfile1.txt'

    gist_id = Column(Integer(), primary_key=True)

    gist_access_id = Column(Unicode(250), nullable=False)

    gist_description = Column(UnicodeText(), nullable=False)

    owner_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    gist_expires = Column(Float(53), nullable=False)

    gist_type = Column(Unicode(128), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    modified_at = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    owner = relationship('User')

    def __repr__(self):

        return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)

    @classmethod

    def guess_instance(cls, value):

        return super(Gist, cls).guess_instance(value, Gist.get_by_access_id)

    @classmethod

    def get_or_404(cls, id_):

        res = cls.query().filter(cls.gist_access_id == id_).scalar()

        if res is None:

            raise HTTPNotFound

        return res

    @classmethod

    def get_by_access_id(cls, gist_access_id):

        return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()

    def gist_url(self):

        import kallithea

        alias_url = kallithea.CONFIG.get('gist_alias_url')

        if alias_url:

            return alias_url.replace('{gistid}', self.gist_access_id)

        import kallithea.lib.helpers as h

        return h.canonical_url('gist', gist_id=self.gist_access_id)

    @classmethod

    def base_path(cls):

        """

        Returns base path where all gists are stored

        :param cls:

        """

        from kallithea.model.gist import GIST_STORE_LOC

        q = Session().query(Ui) \

            .filter(Ui.ui_key == URL_SEP)

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return os.path.join(q.one().ui_value, GIST_STORE_LOC)

    def get_api_data(self):

        """

        Common function for generating gist related data for API

        """

        gist = self

        data = dict(

            gist_id=gist.gist_id,

            type=gist.gist_type,

            access_id=gist.gist_access_id,

            description=gist.gist_description,

            url=gist.gist_url(),

            expires=gist.gist_expires,

            created_on=gist.created_on,

        )

        return data

    def __json__(self):

        data = dict(

        )

        data.update(self.get_api_data())

        return data

    ## SCM functions

    @property

    def scm_instance(self):

        from kallithea.lib.vcs import get_repo

        base_path = self.base_path()

        return get_repo(os.path.join(*map(safe_str,

                                          [base_path, self.gist_access_id])))