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

"""

 (c) 2014-2016 - Copyright Red Hat Inc

 Authors:

   Pierre-Yves Chibon <pingou@pingoured.fr></pingou@pingoured.fr>

"""

# pylint: disable=too-many-branches

# pylint: disable=too-many-arguments

# pylint: disable=too-many-locals

# pylint: disable=too-many-statements

# pylint: disable=too-many-lines

try:

    import simplejson as json

except ImportError:

    import json

import datetime

import markdown

import os

import shutil

import tempfile

import subprocess

import urlparse

import uuid

import bleach

import redis

import six

import sqlalchemy

import sqlalchemy.schema

from sqlalchemy import func

from sqlalchemy import asc

from sqlalchemy.orm import aliased

from sqlalchemy.orm import sessionmaker

from sqlalchemy.orm import scoped_session

import pygit2

import pagure.exceptions

import pagure.lib.git

import pagure.lib.login

import pagure.lib.notify

import pagure.lib.plugins

import pagure.pfmarkdown

from pagure.lib import model

REDIS = None

PAGURE_CI = None

def set_redis(host, port, dbname):

    """ Set the redis connection with the specified information. """

    global REDIS

    pool = redis.ConnectionPool(host=host, port=port, db=dbname)

    REDIS = redis.StrictRedis(connection_pool=pool)

def set_pagure_ci(services):

    """ Set the list of CI services supported by this pagure instance. """

    global PAGURE_CI

    PAGURE_CI = services

def get_user(session, key):

    """ Searches for a user in the database for a given username or email.

    """

    user_obj = search_user(session, username=key)

    if not user_obj:

        user_obj = search_user(session, email=key)

    if not user_obj:

        raise pagure.exceptions.PagureException(

            'No user "%s" found' % key

        )

    return user_obj

def create_session(db_url, debug=False, pool_recycle=3600):

    ''' Create the Session object to use to query the database.

    :arg db_url: URL used to connect to the database. The URL contains

    information with regards to the database engine, the host to connect

    to, the user and password and the database name.

      ie: <engine>://<user>:<password>@<host>/<dbname></dbname></host></password></user></engine>

    :kwarg debug: a boolean specifying wether we should have the verbose

        output of sqlalchemy or not.

    :return a Session that can be used to query the database.

    '''

    if db_url.startswith('sqlite'):

        engine = sqlalchemy.create_engine(

            db_url, echo=debug, pool_recycle=pool_recycle)

    else:

        engine = sqlalchemy.create_engine(

            db_url, echo=debug, pool_recycle=pool_recycle,

            client_encoding='utf8')

    scopedsession = scoped_session(sessionmaker(bind=engine))

    model.BASE.metadata.bind = scopedsession

    return scopedsession

def get_next_id(session, projectid):

    """ Returns the next identifier of a project ticket or pull-request

    based on the identifier already in the database.

    """

    query1 = session.query(

        func.max(model.Issue.id)

    ).filter(

        model.Issue.project_id == projectid

    )

    query2 = session.query(

        func.max(model.PullRequest.id)

    ).filter(

        model.PullRequest.project_id == projectid

    )

    nid = max([el[0] for el in query1.union(query2).all()]) or 0

    return nid + 1

def search_user(session, username=None, email=None, token=None, pattern=None):

    ''' Searches the database for the user or users matching the given

    criterias.

    :arg session: the session to use to connect to the database.

    :kwarg username: the username of the user to look for.

    :type username: string or None

    :kwarg email: the email or one of the email of the user to look for

    :type email: string or None

    :kwarg token: the token of the user to look for

    :type token: string or None

    :kwarg pattern: a pattern to search the users with.

    :type pattern: string or None

    :return: A single User object if any of username, email or token is

        specified, a list of User objects otherwise.

    :rtype: User or [User]

    '''

    query = session.query(

        model.User

    ).order_by(

        model.User.user

    )

    if username is not None:

        query = query.filter(

            model.User.user == username

        )

    if email is not None:

        query = query.filter(

            model.UserEmail.user_id == model.User.id

        ).filter(

            model.UserEmail.email == email

        )

    if token is not None:

        query = query.filter(

            model.User.token == token

        )

    if pattern:

        pattern = pattern.replace('*', '%')

        query = query.filter(

            model.User.user.like(pattern)

        )

    if any([username, email, token]):

        output = query.first()

    else:

        output = query.all()

    return output

def is_valid_ssh_key(key):

    key = key.strip()

    if not key:

        return None

    with tempfile.TemporaryFile() as f:

        f.write(key.encode('utf-8'))

        f.seek(0)

        proc = subprocess.Popen(['/usr/bin/ssh-keygen', '-l', '-f',

                                 '/dev/stdin'],

                                stdin=f,

                                stdout=subprocess.PIPE,

                                stderr=subprocess.PIPE)

    proc.communicate()

    return proc.returncode == 0

def are_valid_ssh_keys(keys):

    return all([is_valid_ssh_key(key) is not False

                for key in keys.split('\n')])

def create_user_ssh_keys_on_disk(user, gitolite_keydir):

    ''' Create the ssh keys for the user on the specific folder.

    This is the method allowing to have multiple ssh keys per user.

    '''

    if gitolite_keydir:

        # First remove any old keyfiles for the user

        # Assumption: we populated the keydir. This means that files

        #  will be in 0/<username>.pub, ..., and not in any deeper</username>

        #  directory structures. Also, this means that if a user

        #  had 5 lines, they will be up to at most keys_4/<username>.pub,</username>

        #  meaning that if a user is not in keys_/<username>.pub, with</username>

        #  i being any integer, the user is most certainly not in

        #  keys_<i+1>/<username>.pub.</username></i+1>

        i = 0

        keyline_file = os.path.join(gitolite_keydir,

                                    'keys_%i' % i,

                                    '%s.pub' % user.user)

        while os.path.exists(keyline_file):

            os.unlink(keyline_file)

            i += 1

            keyline_file = os.path.join(gitolite_keydir,

                                        'keys_%i' % i,

                                        '%s.pub' % user.user)

        # Now let's create new keyfiles for the user

        keys = user.public_ssh_key.split('\n')

        for i in range(len(keys)):

            if not keys[i]:

                continue

            if not is_valid_ssh_key(keys[i]):

                continue

            keyline_dir = os.path.join(gitolite_keydir, 'keys_%i' % i)

            if not os.path.exists(keyline_dir):

                os.mkdir(keyline_dir)

            keyfile = os.path.join(keyline_dir, '%s.pub' % user.user)

            with open(keyfile, 'w') as stream:

                stream.write(keys[i].strip().encode('UTF-8'))

def add_issue_comment(session, issue, comment, user, ticketfolder,

                      notify=True, date_created=None, notification=False):

    ''' Add a comment to an issue. '''

    user_obj = get_user(session, user)

    issue_comment = model.IssueComment(

        issue_uid=issue.uid,

        comment=comment,

        user_id=user_obj.id,

        date_created=date_created,

        notification=notification,

    )

    session.add(issue_comment)

    # Make sure we won't have SQLAlchemy error before we continue

    session.commit()

    pagure.lib.git.update_git(

        issue, repo=issue.project, repofolder=ticketfolder)

    if notify:

        pagure.lib.notify.notify_new_comment(issue_comment, user=user_obj)

    if not issue.private:

        pagure.lib.notify.log(

            issue.project,

            topic='issue.comment.added',

            msg=dict(

                issue=issue.to_json(public=True),

                project=issue.project.to_json(public=True),

                agent=user_obj.username,

            ),

            redis=REDIS,

        )

    if REDIS:

        if issue.private:

            REDIS.publish('pagure.%s' % issue.uid, json.dumps({

                'issue': 'private',

                'comment_id': issue_comment.id,

            }))

        else:

            REDIS.publish('pagure.%s' % issue.uid, json.dumps({

                'comment_id': issue_comment.id,

                'issue_id': issue.id,

                'project': issue.project.fullname,

                'comment_added': text2markdown(issue_comment.comment),

                'comment_user': issue_comment.user.user,

                'avatar_url': avatar_url_from_openid(

                    issue_comment.user.default_email, size=16),

                'comment_date': issue_comment.date_created.strftime(

                    '%Y-%m-%d %H:%M:%S'),

                'notification': notification,

            }))

    return 'Comment added'

def add_tag_obj(session, obj, tags, user, ticketfolder):

    ''' Add a tag to an object (either an issue or a project). '''

    user_obj = get_user(session, user)

    if isinstance(tags, basestring):

        tags = [tags]

    added_tags = []

    for objtag in tags:

        objtag = objtag.strip()

        known = False

        for tagobj in obj.tags:

            if tagobj.tag == objtag:

                known = True

        if known:

            continue

        tagobj = get_tag(session, objtag)

        if not tagobj:

            tagobj = model.Tag(tag=objtag)

            session.add(tagobj)

            session.flush()

        if isinstance(obj, model.Issue):

            dbobjtag = model.TagIssue(

                issue_uid=obj.uid,

                tag=tagobj.tag,

            )

        if isinstance(obj, model.Project):

            dbobjtag = model.TagProject(

                project_id=obj.id,

                tag=tagobj.tag,

            )

        session.add(dbobjtag)

        # Make sure we won't have SQLAlchemy error before we continue

        session.flush()

        added_tags.append(tagobj.tag)

    if isinstance(obj, model.Issue):

        pagure.lib.git.update_git(

            obj, repo=obj.project, repofolder=ticketfolder)

        if not obj.private:

            pagure.lib.notify.log(

                obj.project,

                topic='issue.tag.added',

                msg=dict(

                    issue=obj.to_json(public=True),

                    project=obj.project.to_json(public=True),

                    tags=added_tags,

                    agent=user_obj.username,

                ),

                redis=REDIS,

            )

        # Send notification for the event-source server

        if REDIS:

            REDIS.publish('pagure.%s' % obj.uid, json.dumps(

                {'added_tags': added_tags}))

    if added_tags:

        return 'Tag added: %s' % ', '.join(added_tags)

    else:

        return 'Nothing to add'

def add_issue_assignee(session, issue, assignee, user, ticketfolder,

                       notify=True):

    ''' Add an assignee to an issue, in other words, assigned an issue. '''

    user_obj = get_user(session, user)

    if assignee is None and issue.assignee is not None:

        issue.assignee_id = None

        session.add(issue)

        session.commit()

        pagure.lib.git.update_git(

            issue, repo=issue.project, repofolder=ticketfolder)

        if notify:

            pagure.lib.notify.notify_assigned_issue(issue, None, user_obj)

        if not issue.private:

            pagure.lib.notify.log(

                issue.project,

                topic='issue.assigned.reset',

                msg=dict(

                    issue=issue.to_json(public=True),

                    project=issue.project.to_json(public=True),

                    agent=user_obj.username,

                ),

                redis=REDIS,

            )

        # Send notification for the event-source server

        if REDIS:

            REDIS.publish('pagure.%s' % issue.uid, json.dumps(

                {'unassigned': '-'}))

        return 'Assignee reset'

    elif assignee is None and issue.assignee is None:

        return

    # Validate the assignee

    assignee_obj = get_user(session, assignee)

    if issue.assignee_id != assignee_obj.id:

        issue.assignee_id = assignee_obj.id

        session.add(issue)

        session.flush()

        pagure.lib.git.update_git(

            issue, repo=issue.project, repofolder=ticketfolder)

        if notify:

            pagure.lib.notify.notify_assigned_issue(

                issue, assignee_obj, user_obj)

        if not issue.private:

            pagure.lib.notify.log(

                issue.project,

                topic='issue.assigned.added',

                msg=dict(

                    issue=issue.to_json(public=True),

                    project=issue.project.to_json(public=True),

                    agent=user_obj.username,

                ),

                redis=REDIS,

            )

        # Send notification for the event-source server

        if REDIS:

            REDIS.publish('pagure.%s' % issue.uid, json.dumps(

                {'assigned': assignee_obj.to_json(public=True)}))

        return 'Issue assigned'

def add_pull_request_assignee(

        session, request, assignee, user, requestfolder):

    ''' Add an assignee to a request, in other words, assigned an issue. '''

    get_user(session, assignee)

    user_obj = get_user(session, user)

    if assignee is None and request.assignee is not None:

        request.assignee_id = None

        session.add(request)

        session.commit()

        pagure.lib.git.update_git(

            request, repo=request.project, repofolder=requestfolder)

        pagure.lib.notify.notify_assigned_request(request, None, user_obj)

        pagure.lib.notify.log(

            request.project,

            topic='request.assigned.reset',

            msg=dict(

                request=request.to_json(public=True),

                project=request.project.to_json(public=True),

                agent=user_obj.username,

            ),

            redis=REDIS,

        )

        return 'Request reset'

    elif assignee is None and request.assignee is None:

        return

    # Validate the assignee

    assignee_obj = get_user(session, assignee)

    if request.assignee_id != assignee_obj.id:

        request.assignee_id = assignee_obj.id

        session.add(request)

        session.flush()

        pagure.lib.git.update_git(

            request, repo=request.project, repofolder=requestfolder)

        pagure.lib.notify.notify_assigned_request(

            request, assignee_obj, user_obj)

        pagure.lib.notify.log(

            request.project,

            topic='request.assigned.added',

            msg=dict(

                request=request.to_json(public=True),

                project=request.project.to_json(public=True),

                agent=user_obj.username,

            ),

            redis=REDIS,

        )

        return 'Request assigned'

def add_issue_dependency(

        session, issue, issue_blocked, user, ticketfolder):

    ''' Add a dependency between two issues. '''

    user_obj = get_user(session, user)

    if issue.uid == issue_blocked.uid:

        raise pagure.exceptions.PagureException(

            'An issue cannot depend on itself'

        )

    if issue_blocked not in issue.children:

        i2i = model.IssueToIssue(

            parent_issue_id=issue_blocked.uid,

            child_issue_id=issue.uid

        )

        session.add(i2i)

        # Make sure we won't have SQLAlchemy error before we continue

        session.flush()

        pagure.lib.git.update_git(

            issue,

            repo=issue.project,

            repofolder=ticketfolder)

        pagure.lib.git.update_git(

            issue_blocked,

            repo=issue_blocked.project,

            repofolder=ticketfolder)

        #pagure.lib.notify.notify_assigned_issue(issue, user_obj)

        #pagure.lib.notify.notify_assigned_issue(issue_blocked, user_obj)

        if not issue.private:

            pagure.lib.notify.log(

                issue.project,

                topic='issue.dependency.added',

                msg=dict(

                    issue=issue.to_json(public=True),

                    project=issue.project.to_json(public=True),

                    added_dependency=issue_blocked.id,

                    agent=user_obj.username,

                ),

                redis=REDIS,

            )

        # Send notification for the event-source server

        if REDIS:

            REDIS.publish('pagure.%s' % issue.uid, json.dumps({

                'added_dependency': issue_blocked.id,

                'issue_uid': issue.uid,

                'type': 'children',

            }))

            REDIS.publish('pagure.%s' % issue_blocked.uid, json.dumps({

                'added_dependency': issue.id,

                'issue_uid': issue_blocked.uid,

                'type': 'parent',

            }))

        return 'Dependency added'

def remove_issue_dependency(

        session, issue, issue_blocked, user, ticketfolder):

    ''' Remove a dependency between two issues. '''

    user_obj = get_user(session, user)

    if issue.uid == issue_blocked.uid:

        raise pagure.exceptions.PagureException(

            'An issue cannot depend on itself'

        )

    if issue_blocked in issue.children:

        child_del = []

        for child in issue.children:

            if child.uid == issue_blocked.uid:

                child_del.append(child.id)

                issue.children.remove(child)

        # Make sure we won't have SQLAlchemy error before we continue

        session.flush()

        pagure.lib.git.update_git(

            issue,

            repo=issue.project,

            repofolder=ticketfolder)

        pagure.lib.git.update_git(

            issue_blocked,

            repo=issue_blocked.project,

            repofolder=ticketfolder)

        #pagure.lib.notify.notify_assigned_issue(issue, user_obj)

        #pagure.lib.notify.notify_assigned_issue(issue_blocked, user_obj)

        if not issue.private:

            pagure.lib.notify.log(

                issue.project,

                topic='issue.dependency.removed',

                msg=dict(

                    issue=issue.to_json(public=True),

                    project=issue.project.to_json(public=True),

                    removed_dependency=child_del,

                    agent=user_obj.username,

                ),

                redis=REDIS,

            )

        # Send notification for the event-source server

        if REDIS:

            REDIS.publish('pagure.%s' % issue.uid, json.dumps({

                'removed_dependency': child_del,

                'issue_uid': issue.uid,

                'type': 'children',

            }))

            REDIS.publish('pagure.%s' % issue_blocked.uid, json.dumps({

                'removed_dependency': issue.id,

                'issue_uid': issue_blocked.uid,

                'type': 'parent',

            }))

        return 'Dependency removed'

def remove_tags(session, project, tags, ticketfolder, user):

    ''' Removes the specified tag of a project. '''

    user_obj = get_user(session, user)

    if not isinstance(tags, list):

        tags = [tags]

    issues = search_issues(session, project, closed=False, tags=tags)

    issues.extend(search_issues(session, project, closed=True, tags=tags))

    msgs = []

    removed_tags = []

    if not issues:

        raise pagure.exceptions.PagureException(

            'No issue found with the tags: %s' % ', '.join(tags))

    else:

        for issue in issues:

            for issue_tag in issue.tags:

                if issue_tag.tag in tags:

                    tag = issue_tag.tag

                    removed_tags.append(tag)

                    session.delete(issue_tag)

                    msgs.append('Removed tag: %s' % tag)

            pagure.lib.git.update_git(

                issue, repo=issue.project, repofolder=ticketfolder)

    pagure.lib.notify.log(

        project,

        topic='project.tag.removed',

        msg=dict(

            project=project.to_json(public=True),

            tags=removed_tags,

            agent=user_obj.username,

        ),

        redis=REDIS,

    )

    return msgs

def remove_tags_obj(

        session, obj, tags, ticketfolder, user):

    ''' Removes the specified tag(s) of a given object. '''

    user_obj = get_user(session, user)

    if isinstance(tags, basestring):

        tags = [tags]

    removed_tags = []

    for objtag in obj.tags:

        if objtag.tag in tags:

            tag = objtag.tag

            removed_tags.append(tag)

            session.delete(objtag)

    if isinstance(obj, model.Issue):

        pagure.lib.git.update_git(

            obj, repo=obj.project, repofolder=ticketfolder)

        pagure.lib.notify.log(

            obj.project,

            topic='issue.tag.removed',

            msg=dict(

                issue=obj.to_json(public=True),

                project=obj.project.to_json(public=True),

                tags=removed_tags,

                agent=user_obj.username,

            ),

            redis=REDIS,

        )

        # Send notification for the event-source server

        if REDIS:

            REDIS.publish('pagure.%s' % obj.uid, json.dumps(

                {'removed_tags': removed_tags}))

    return 'Removed tag: %s' % ', '.join(removed_tags)

def edit_issue_tags(session, project, old_tag, new_tag, ticketfolder, user):

    ''' Removes the specified tag of a project. '''

    user_obj = get_user(session, user)

    if old_tag == new_tag:

        raise pagure.exceptions.PagureException(

            'Old tag: "%s" is the same as new tag "%s", nothing to change'

            % (old_tag, new_tag))

    issues = search_issues(session, project, closed=False, tags=old_tag)

    issues.extend(search_issues(session, project, closed=True, tags=old_tag))

    msgs = []

    if not issues:

        raise pagure.exceptions.PagureException(

            'No issue found with the tags: %s' % old_tag)

    else:

        tagobj = get_tag(session, new_tag)

        if not tagobj:

            tagobj = model.Tag(tag=new_tag)

            session.add(tagobj)

            session.flush()

        for issue in set(issues):

            add = True

            # Drop the old tag

            cnt = 0

            while cnt < len(issue.tags):

                issue_tag = issue.tags[cnt]

                if issue_tag.tag == old_tag:

                    issue.tags.remove(issue_tag)

                    cnt -= 1

                if issue_tag.tag == new_tag:

                    add = False

                cnt += 1

            session.flush()

            # Add the new one

            if add:

                issue_tag = model.TagIssue(

                    issue_uid=issue.uid,

                    tag=tagobj.tag

                )

                session.add(issue_tag)

                session.flush()

            # Update the git version

            pagure.lib.git.update_git(

                issue, repo=issue.project, repofolder=ticketfolder)

        msgs.append('Edited tag: %s to %s' % (old_tag, new_tag))

        pagure.lib.notify.log(

            project,

            topic='project.tag.edited',

            msg=dict(

                project=project.to_json(public=True),

                old_tag=old_tag,

                new_tag=new_tag,

                agent=user_obj.username,

            ),

            redis=REDIS,

        )

    return msgs

def add_user_to_project(session, project, new_user, user):

    ''' Add a specified user to a specified project. '''

    new_user_obj = get_user(session, new_user)

    user_obj = get_user(session, user)

    users = set([user.user for user in project.users])

    users.add(project.user.user)

    if new_user in users:

        raise pagure.exceptions.PagureException(

            'This user is already listed on this project.'

        )

    project_user = model.ProjectUser(

        project_id=project.id,

        user_id=new_user_obj.id,

    )

    session.add(project_user)

    # Make sure we won't have SQLAlchemy error before we continue

    session.flush()

    pagure.lib.notify.log(

        project,

        topic='project.user.added',

        msg=dict(

            project=project.to_json(public=True),

            new_user=new_user_obj.username,

            agent=user_obj.username,

        ),

        redis=REDIS,

    )

    return 'User added'

def add_group_to_project(

        session, project, new_group, user, create=False, is_admin=False):

    ''' Add a specified group to a specified project. '''

    user_obj = search_user(session, username=user)

    if not user_obj:

        raise pagure.exceptions.PagureException(

            'No user %s found.' % user

        )

    group_obj = search_groups(session, group_name=new_group)

    if not group_obj:

        if create:

            group_obj = pagure.lib.model.PagureGroup(

                group_name=new_group,

                group_type='user',

                user_id=user_obj.id,

            )

            session.add(group_obj)

            session.flush()

        else:

            raise pagure.exceptions.PagureException(

                'No group %s found.' % new_group

            )

    if user_obj not in project.users \

            and user_obj != project.user \

            and not is_admin:

        raise pagure.exceptions.PagureException(

            'You are not allowed to add a group of users to this project'

        )

    groups = set([group.group_name for group in project.groups])

    if new_group in groups:

        raise pagure.exceptions.PagureException(

            'This group is already associated to this project.'

        )

    project_group = model.ProjectGroup(

        project_id=project.id,

        group_id=group_obj.id,

    )

    session.add(project_group)

    # Make sure we won't have SQLAlchemy error before we continue

    session.flush()

    pagure.lib.notify.log(

        project,

        topic='project.group.added',

        msg=dict(

            project=project.to_json(public=True),

            new_group=group_obj.group_name,

            agent=user,

        ),

        redis=REDIS,

    )

    return 'Group added'

def add_pull_request_comment(session, request, commit, tree_id, filename,

                             row, comment, user, requestfolder,

                             notify=True, notification=False):

    ''' Add a comment to a pull-request. '''

    user_obj = get_user(session, user)

    pr_comment = model.PullRequestComment(

        pull_request_uid=request.uid,

        commit_id=commit,

        tree_id=tree_id,

        filename=filename,

        line=row,

        comment=comment,

        user_id=user_obj.id,

        notification=notification,

    )

    session.add(pr_comment)

    # Make sure we won't have SQLAlchemy error before we continue

    session.flush()

    pagure.lib.git.update_git(

        request, repo=request.project, repofolder=requestfolder)

    if notify:

        pagure.lib.notify.notify_pull_request_comment(pr_comment, user_obj)