# -*- 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.model.comment

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

comments model 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: Nov 11, 2011

:author: marcink

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

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

"""

import logging

from pylons.i18n.translation import _

from collections import defaultdict

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

from kallithea.lib import helpers as h

from kallithea.model.base import BaseModel

from kallithea.model.db import ChangesetComment, User, \

    Notification, PullRequest, Repository

from kallithea.model.notification import NotificationModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class ChangesetCommentsModel(BaseModel):

    def _get_notification_data(self, repo, comment, author, comment_text,

                               line_no=None, revision=None, pull_request=None,

                               status_change=None, closing_pr=False):

        """

        :returns: tuple (subj,body,recipients,notification_type,email_kwargs)

        """

        # make notification

        body = comment_text  # text of the comment

        line = ''

        if line_no:

            line = _('on line %s') % line_no

        #changeset

        if revision:

            notification_type = Notification.TYPE_CHANGESET_COMMENT

            cs = repo.scm_instance.get_changeset(revision)

            desc = cs.short_id

            threading = ['%s-rev-%s@%s' % (repo.repo_name, revision, h.canonical_hostname())]

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-rev-%s-line-%s@%s' % (repo.repo_name, revision, line_no,

                                                           h.canonical_hostname()))

            comment_url = h.canonical_url('changeset_home',

                repo_name=repo.repo_name,

                revision=revision,

                anchor='comment-%s' % comment.comment_id)

            subj = safe_unicode(

                h.link_to('Re changeset: %(desc)s %(line)s' % \

                          {'desc': desc, 'line': line},

                          comment_url)

            )

            # get the current participants of this changeset

            # add changeset author if it's known locally

            cs_author = User.get_from_cs_author(cs.author)

            if not cs_author:

                #use repo owner if we cannot extract the author correctly

                # FIXME: just use committer name even if not a user

                cs_author = repo.owner

            email_kwargs = {

                'status_change': status_change,

                'cs_comment_user': author.full_name_and_username,

                'cs_target_repo': h.canonical_url('summary_home', repo_name=repo.repo_name),

                'cs_comment_url': comment_url,

                'cs_url': h.canonical_url('changeset_home', repo_name=repo.repo_name, revision=revision),

                'raw_id': revision,

                'message': cs.message,

                'message_short': h.shorter(cs.message, 50, firstline=True),

                'cs_author': cs_author,

                'repo_name': repo.repo_name,

                'short_id': h.short_id(revision),

                'branch': cs.branch,

                'comment_username': author.username,

                'threading': threading,

            }

        #pull request

        elif pull_request:

            notification_type = Notification.TYPE_PULL_REQUEST_COMMENT

            desc = comment.pull_request.title

            _org_ref_type, org_ref_name, _org_rev = comment.pull_request.org_ref.split(':')

            _other_ref_type, other_ref_name, _other_rev = comment.pull_request.other_ref.split(':')

            threading = ['%s-pr-%s@%s' % (pull_request.other_repo.repo_name,

                                          pull_request.pull_request_id,

                                          h.canonical_hostname())]

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-pr-%s-line-%s@%s' % (pull_request.other_repo.repo_name,

                                                          pull_request.pull_request_id, line_no,

                                                          h.canonical_hostname()))

            comment_url = pull_request.url(canonical=True,

                anchor='comment-%s' % comment.comment_id)

            subj = safe_unicode(

                h.link_to('Re pull request %(pr_nice_id)s: %(desc)s %(line)s' % \

                          {'desc': desc,

                           'pr_nice_id': comment.pull_request.nice_id(),

                           'line': line},

                          comment_url)

            )

            # get the current participants of this pull request

            recipients += pull_request.get_reviewer_users()

            #set some variables for email notification

            email_kwargs = {

                'pr_title': pull_request.title,

                'pr_title_short': h.shorter(pull_request.title, 50),

                'pr_nice_id': pull_request.nice_id(),

                'status_change': status_change,

                'closing_pr': closing_pr,

                'pr_comment_url': comment_url,

                'pr_url': pull_request.url(canonical=True),

                'pr_comment_user': author.full_name_and_username,

                'pr_target_repo': h.canonical_url('summary_home',

                                   repo_name=pull_request.other_repo.repo_name),

                'pr_target_branch': other_ref_name,

                'pr_source_repo': h.canonical_url('summary_home',

                                   repo_name=pull_request.org_repo.repo_name),

                'pr_source_branch': org_ref_name,

                'pr_owner': pull_request.owner,

                'pr_owner_username': pull_request.owner.username,

                'repo_name': pull_request.other_repo.repo_name,

                'comment_username': author.username,

                'threading': threading,

            }

        return subj, body, recipients, notification_type, email_kwargs

    def create(self, text, repo, author, revision=None, pull_request=None,

               f_path=None, line_no=None, status_change=None, closing_pr=False,

               send_email=True):

        """

        Creates a new comment for either a changeset or a pull request.

        status_change and closing_pr is only for the optional email.

        Returns the created comment.

        """

        if not status_change and not text:

            log.warning('Missing text for comment, skipping...')

            return None

        repo = Repository.guess_instance(repo)

        author = User.guess_instance(author)

        comment = ChangesetComment()

        comment.repo = repo

        comment.author = author

        comment.text = text

        comment.f_path = f_path

        comment.line_no = line_no

        if revision is not None:

            comment.revision = revision

        elif pull_request is not None:

            pull_request = PullRequest.guess_instance(pull_request)

            comment.pull_request = pull_request

        else:

            raise Exception('Please specify revision or pull_request_id')

        Session().add(comment)

        Session().flush()

        if send_email:

            (subj, body, recipients, notification_type,

             email_kwargs) = self._get_notification_data(

                                repo, comment, author,

                                comment_text=text,

                                line_no=line_no,

                                revision=revision,

                                pull_request=pull_request,

                                status_change=status_change,

                                closing_pr=closing_pr)

            email_kwargs['is_mention'] = False

            # create notification objects, and emails

            NotificationModel().create(

                created_by=author, subject=subj, body=body,

                recipients=recipients, type_=notification_type,

                email_kwargs=email_kwargs,

            )

            mention_recipients = extract_mentioned_users(body).difference(recipients)

            if mention_recipients:

                email_kwargs['is_mention'] = True

                subj = _('[Mention]') + ' ' + subj

                # FIXME: this subject is wrong and unused!

                NotificationModel().create(

                    created_by=author, subject=subj, body=body,

                    recipients=mention_recipients,

                    type_=notification_type,

                    email_kwargs=email_kwargs

                )

        return comment

    def delete(self, comment):

        comment = ChangesetComment.guess_instance(comment)

        Session().delete(comment)

    @classmethod

    def _get_cache_key(cls, key):

        """

        Wrapper for generating a unique cache key for this instance and "key".

        key must / will start with a repo_name which will be stored in .cache_args .

        """

        import kallithea

        prefix = kallithea.CONFIG.get('instance_id', '')

        return "%s%s" % (prefix, key)

    @classmethod

    def set_invalidate(cls, repo_name):

        """

        Mark all caches of a repo as invalid in the database.

        """

        inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()

        log.debug('for repo %s got %s invalidation objects',

                  safe_str(repo_name), inv_objs)

        for inv_obj in inv_objs:

            log.debug('marking %s key for invalidation based on repo_name=%s',

                      inv_obj, safe_str(repo_name))

            Session().delete(inv_obj)

        Session().commit()

    @classmethod

    def test_and_set_valid(cls, repo_name, kind, valid_cache_keys=None):

        """

        Mark this cache key as active and currently cached.

        Return True if the existing cache registration still was valid.

        Return False to indicate that it had been invalidated and caches should be refreshed.

        """

        key = (repo_name + '_' + kind) if kind else repo_name

        cache_key = cls._get_cache_key(key)

        if valid_cache_keys and cache_key in valid_cache_keys:

            return True

        inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

        if inv_obj is None:

            inv_obj = cls(cache_key, repo_name)

            Session().add(inv_obj)

        elif inv_obj.cache_active:

            return True

        inv_obj.cache_active = True

        try:

            Session().commit()

        except sqlalchemy.exc.IntegrityError:

            log.error('commit of CacheInvalidation failed - retrying')

            Session().rollback()

            inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

            if inv_obj is None:

                log.error('failed to create CacheInvalidation entry')

                # TODO: fail badly?

            # else: TOCTOU - another thread added the key at the same time; no further action required

        return False

    @classmethod

    def get_valid_cache_keys(cls):

        """

        Return opaque object with information of which caches still are valid

        and can be used without checking for invalidation.

        """

        return set(inv_obj.cache_key for inv_obj in cls.query().filter(cls.cache_active).all())

class ChangesetComment(Base, BaseDbModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = (

        Index('cc_revision_idx', 'revision'),

        Index('cc_pull_request_id_idx', 'pull_request_id'),

        _table_args_default_dict,

    )

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

    repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    revision = Column(String(40), nullable=True)

    pull_request_id = Column(Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

    line_no = Column(Unicode(10), nullable=True)

    f_path = Column(Unicode(1000), nullable=True)

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

    text = Column(UnicodeText(), 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)

    author = relationship('User')

    repo = relationship('Repository')

    # status_change is frequently used directly in templates - make it a lazy

    # join to avoid fetching each related ChangesetStatus on demand.

    # There will only be one ChangesetStatus referencing each comment so the join will not explode.

    status_change = relationship('ChangesetStatus',

                                 cascade="all, delete-orphan", lazy='joined')

    pull_request = relationship('PullRequest')

    def url(self):

        anchor = "comment-%s" % self.comment_id

        import kallithea.lib.helpers as h

        if self.revision:

            return h.url('changeset_home', repo_name=self.repo.repo_name, revision=self.revision, anchor=anchor)

        elif self.pull_request_id is not None:

            return self.pull_request.url(anchor=anchor)

    def deletable(self):

        return self.created_on > datetime.datetime.now() - datetime.timedelta(minutes=5)

class ChangesetStatus(Base, BaseDbModel):

    __tablename__ = 'changeset_statuses'

    __table_args__ = (

        Index('cs_revision_idx', 'revision'),

        Index('cs_version_idx', 'version'),

        Index('cs_pull_request_id_idx', 'pull_request_id'),

        Index('cs_changeset_comment_id_idx', 'changeset_comment_id'),

        Index('cs_pull_request_id_user_id_version_idx', 'pull_request_id', 'user_id', 'version'),

        Index('cs_repo_id_pull_request_id_idx', 'repo_id', 'pull_request_id'),

        UniqueConstraint('repo_id', 'revision', 'version'),

        _table_args_default_dict,

    )

    STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

    STATUS_APPROVED = 'approved'

    STATUS_REJECTED = 'rejected' # is shown as "Not approved" - TODO: change database content / scheme

    STATUS_UNDER_REVIEW = 'under_review'

    STATUSES = [

        (STATUS_NOT_REVIEWED, _("Not reviewed")),  # (no icon) and default

        (STATUS_UNDER_REVIEW, _("Under review")),

        (STATUS_REJECTED, _("Not approved")),

        (STATUS_APPROVED, _("Approved")),

    ]

    STATUSES_DICT = dict(STATUSES)

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

    repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

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

    revision = Column(String(40), nullable=True)

    status = Column(String(128), nullable=False, default=DEFAULT)

    comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=False)

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

    version = Column(Integer(), nullable=False, default=0)

    pull_request_id = Column(Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

    author = relationship('User')

    repo = relationship('Repository')

    comment = relationship('ChangesetComment')

    pull_request = relationship('PullRequest')

    def __unicode__(self):

        return u"<%s('%s:%s')>" % (

            self.__class__.__name__,

            self.status, self.author

        )

    @classmethod

    def get_status_lbl(cls, value):

        return cls.STATUSES_DICT.get(value)

    @property

    def status_lbl(self):

        return ChangesetStatus.get_status_lbl(self.status)

class PullRequest(Base, BaseDbModel):

    __tablename__ = 'pull_requests'

    __table_args__ = (

        Index('pr_org_repo_id_idx', 'org_repo_id'),

        Index('pr_other_repo_id_idx', 'other_repo_id'),

        _table_args_default_dict,

    )

    # values for .status

    STATUS_NEW = u'new'

    STATUS_CLOSED = u'closed'

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

    title = Column(Unicode(255), nullable=False)

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

    status = Column(Unicode(255), nullable=False, default=STATUS_NEW) # only for closedness, not approve/reject/etc

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

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

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

    _revisions = Column('revisions', UnicodeText(), nullable=False)

    org_repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    org_ref = Column(Unicode(255), nullable=False)

    other_repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    other_ref = Column(Unicode(255), nullable=False)

    @hybrid_property

    def revisions(self):

        return self._revisions.split(':')