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

"""

 (c) 2014-2018 - Copyright Red Hat Inc

 Authors:

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

"""

from __future__ import unicode_literals, absolute_import

import arrow

import datetime

import collections

import logging

import json

import operator

import re

import pygit2

import os

import six

import sqlalchemy as sa

from sqlalchemy import create_engine

from sqlalchemy.exc import SQLAlchemyError

from sqlalchemy.orm import backref

from sqlalchemy.orm import sessionmaker

from sqlalchemy.orm import scoped_session

from sqlalchemy.orm import relation

from sqlalchemy.orm import validates

import pagure.exceptions

from pagure.config import config as pagure_config

from pagure.lib.model_base import BASE

from pagure.lib.plugins import get_plugin_tables

from pagure.utils import is_true

_log = logging.getLogger(__name__)

# hit w/ all the id field we use

# pylint: disable=invalid-name

# pylint: disable=too-few-public-methods

# pylint: disable=no-init

# pylint: disable=too-many-lines

def create_tables(db_url, alembic_ini=None, acls=None, debug=False):

    """ Create the tables in the database using the information from the

    url obtained.

    :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 alembic_ini, path to the alembic ini file. This is necessary

        to be able to use alembic correctly, but not for the unit-tests.

    :kwarg debug, a boolean specifying whether 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("postgres"):  # pragma: no cover

        engine = create_engine(db_url, echo=debug, client_encoding="utf8")

    else:  # pragma: no cover

        engine = create_engine(db_url, echo=debug)

    get_plugin_tables()

    BASE.metadata.create_all(engine)

    # engine.execute(collection_package_create_view(driver=engine.driver))

    if db_url.startswith("sqlite:"):

        # Ignore the warning about con_record

        # pylint: disable=unused-argument

        def _fk_pragma_on_connect(dbapi_con, _):  # pragma: no cover

            """ Tries to enforce referential constraints on sqlite. """

            dbapi_con.execute("pragma foreign_keys=ON")

        sa.event.listen(engine, "connect", _fk_pragma_on_connect)

    if alembic_ini is not None:  # pragma: no cover

        # then, load the Alembic configuration and generate the

        # version table, "stamping" it with the most recent rev:

        # Ignore the warning missing alembic

        # pylint: disable=import-error

        from alembic.config import Config

        from alembic import command

        alembic_cfg = Config(alembic_ini)

        command.stamp(alembic_cfg, "head")

    scopedsession = scoped_session(sessionmaker(bind=engine))

    BASE.metadata.bind = scopedsession

    # Insert the default data into the db

    create_default_status(scopedsession, acls=acls)

    return scopedsession

def create_default_status(session, acls=None):

    """ Insert the defaults status in the status tables.

    """

    statuses = ["Open", "Closed"]

    for status in statuses:

        ticket_stat = StatusIssue(status=status)

        session.add(ticket_stat)

        try:

            session.commit()

        except SQLAlchemyError:  # pragma: no cover

            session.rollback()

            _log.debug("Status %s could not be added", ticket_stat)

    for status in ["Open", "Closed", "Merged"]:

        pr_stat = StatusPullRequest(status=status)

        session.add(pr_stat)

        try:

            session.commit()

        except SQLAlchemyError:  # pragma: no cover

            session.rollback()

            _log.debug("Status %s could not be added", pr_stat)

    for grptype in ["user", "admin"]:

        grp_type = PagureGroupType(group_type=grptype)

        session.add(grp_type)

        try:

            session.commit()

        except SQLAlchemyError:  # pragma: no cover

            session.rollback()

            _log.debug("Type %s could not be added", grptype)

    acls = acls or {}

    keys = sorted(list(acls.keys()))

    for acl in keys:

        item = ACL(name=acl, description=acls[acl])

        session.add(item)

        try:

            session.commit()

        except SQLAlchemyError:  # pragma: no cover

            session.rollback()

            _log.debug("ACL %s could not be added", acl)

    for access in ["ticket", "commit", "admin"]:

        access_obj = AccessLevels(access=access)

        session.add(access_obj)

        try:

            session.commit()

        except SQLAlchemyError:

            session.rollback()

            _log.debug("Access level %s could not be added", access)

def arrow_ts(value):

    return "%s" % arrow.get(value).timestamp

class AccessLevels(BASE):

    """ Different access levels a user/group can have for a project """

    __tablename__ = "access_levels"

    access = sa.Column(sa.String(255), primary_key=True)

class StatusIssue(BASE):

    """ Stores the status a ticket can have.

    Table -- status_issue

    """

    __tablename__ = "status_issue"

    id = sa.Column(sa.Integer, primary_key=True)

    status = sa.Column(sa.String(255), nullable=False, unique=True)

class StatusPullRequest(BASE):

    """ Stores the status a pull-request can have.

    Table -- status_issue

    """

    __tablename__ = "status_pull_requests"

    id = sa.Column(sa.Integer, primary_key=True)

    status = sa.Column(sa.String(255), nullable=False, unique=True)

class User(BASE):

    """ Stores information about users.

    Table -- users

    """

    __tablename__ = "users"

    id = sa.Column(sa.Integer, primary_key=True)

    user = sa.Column(sa.String(255), nullable=False, unique=True, index=True)

    fullname = sa.Column(sa.String(255), nullable=False, index=True)

    default_email = sa.Column(sa.Text, nullable=False)

    _settings = sa.Column(sa.Text, nullable=True)

    password = sa.Column(sa.Text, nullable=True)

    token = sa.Column(sa.String(50), nullable=True)

    created = sa.Column(sa.DateTime, nullable=False, default=sa.func.now())

    updated_on = sa.Column(

        sa.DateTime,

        nullable=False,

        default=sa.func.now(),

        onupdate=sa.func.now(),

    )

    refuse_sessions_before = sa.Column(

        sa.DateTime, nullable=True, default=None

    )

    # Relations

    group_objs = relation(

        "PagureGroup",

        secondary="pagure_user_group",

        primaryjoin="users.c.id==pagure_user_group.c.user_id",

        secondaryjoin="pagure_group.c.id==pagure_user_group.c.group_id",

        backref="users",

    )

    session = relation("PagureUserVisit", backref="user")

    @property

    def username(self):

        """ Return the username. """

        return self.user

    @property

    def html_title(self):

        """ Return the ``fullname (username)`` or simply ``username`` to be

        used in the html templates.

        """

        if self.fullname:

            return "%s (%s)" % (self.fullname, self.user)

        else:

            return self.user

    @property

    def groups(self):

        """ Return the list of Group.group_name in which the user is. """

        return [group.group_name for group in self.group_objs]

    @property

    def settings(self):

        """ Return the dict stored as string in the database as an actual

        dict object.

        """

        default = {"cc_me_to_my_actions": False}

        if self._settings:

            current = json.loads(self._settings)

            # Update the current dict with the new keys

            for key in default:

                if key not in current:

                    current[key] = default[key]

                elif is_true(current[key]):

                    current[key] = True

            return current

        else:

            return default

    @settings.setter

    def settings(self, settings):

        """ Ensures the settings are properly saved. """

        self._settings = json.dumps(settings)

    def __repr__(self):

        """ Return a string representation of this object. """

        return "User: %s - name %s" % (self.id, self.user)

    def to_json(self, public=False):

        """ Return a representation of the User in a dictionary. """

        output = {"name": self.user, "fullname": self.fullname}

        if not public:

            output["default_email"] = self.default_email

            output["emails"] = sorted([email.email for email in self.emails])

        return output

class UserEmail(BASE):

    """ Stores email information about the users.

    Table -- user_emails

    """

    __tablename__ = "user_emails"

    id = sa.Column(sa.Integer, primary_key=True)

    user_id = sa.Column(

        sa.Integer,

        sa.ForeignKey("users.id", onupdate="CASCADE"),

        nullable=False,

        index=True,

    )

    email = sa.Column(sa.String(255), nullable=False, unique=True)

    user = relation(

        "User",

        foreign_keys=[user_id],

        remote_side=[User.id],

        backref=backref(

            "emails", cascade="delete, delete-orphan", single_parent=True

        ),

    )

class UserEmailPending(BASE):

    """ Stores email information about the users.

    Table -- user_emails_pending

    """

    __tablename__ = "user_emails_pending"

    id = sa.Column(sa.Integer, primary_key=True)

    user_id = sa.Column(

        sa.Integer,

        sa.ForeignKey("users.id", onupdate="CASCADE"),

        nullable=False,

        index=True,

    )

    email = sa.Column(sa.String(255), nullable=False, unique=True)

    token = sa.Column(sa.String(50), nullable=True)

    created = sa.Column(sa.DateTime, nullable=False, default=sa.func.now())

    user = relation(

        "User",

        foreign_keys=[user_id],

        remote_side=[User.id],

        backref=backref(

            "emails_pending",

            cascade="delete, delete-orphan",

            single_parent=True,

        ),

    )

class Project(BASE):

    """ Stores the projects.

    Table -- projects

    """

    __tablename__ = "projects"

    id = sa.Column(sa.Integer, primary_key=True)

    user_id = sa.Column(

        sa.Integer,

        sa.ForeignKey("users.id", onupdate="CASCADE"),

        nullable=False,

        index=True,

    )

    namespace = sa.Column(sa.String(255), nullable=True, index=True)

    name = sa.Column(sa.String(255), nullable=False, index=True)

    description = sa.Column(sa.Text, nullable=True)

    url = sa.Column(sa.Text, nullable=True)

    _settings = sa.Column(sa.Text, nullable=True)

    # The hook_token is used to sign the notification sent via web-hook

    hook_token = sa.Column(sa.String(40), nullable=False, unique=True)

    avatar_email = sa.Column(sa.Text, nullable=True)

    is_fork = sa.Column(sa.Boolean, default=False, nullable=False)

    read_only = sa.Column(sa.Boolean, default=True, nullable=False)

    parent_id = sa.Column(

        sa.Integer,

        sa.ForeignKey("projects.id", onupdate="CASCADE"),

        nullable=True,

    )

    _priorities = sa.Column(sa.Text, nullable=True)

    default_priority = sa.Column(sa.Text, nullable=True)

    _milestones = sa.Column(sa.Text, nullable=True)

    _milestones_keys = sa.Column(sa.Text, nullable=True)

    _quick_replies = sa.Column(sa.Text, nullable=True)

    _reports = sa.Column(sa.Text, nullable=True)

    _notifications = sa.Column(sa.Text, nullable=True)

    _close_status = sa.Column(sa.Text, nullable=True)

    _block_users = sa.Column(sa.Text, nullable=True)

    mirrored_from = sa.Column(sa.Text, nullable=True)

    mirrored_from_last_log = sa.Column(sa.Text, nullable=True)

    date_created = sa.Column(

        sa.DateTime, nullable=False, default=datetime.datetime.utcnow

    )

    date_modified = sa.Column(

        sa.DateTime, nullable=False, default=datetime.datetime.utcnow

    )

    parent = relation(

        "Project",

        remote_side=[id],

        backref=backref(

            "forks", order_by=str("(projects.c.date_created).desc()")

        ),

    )

    user = relation(

        "User",

        foreign_keys=[user_id],

        remote_side=[User.id],

        backref="projects",

    )

    private = sa.Column(sa.Boolean, nullable=False, default=False)

    repospanner_region = sa.Column(sa.Text, nullable=True)

    users = relation(

        "User",

        secondary="user_projects",

        primaryjoin="projects.c.id==user_projects.c.project_id",

        secondaryjoin="users.c.id==user_projects.c.user_id",

        backref="co_projects",

    )

    admins = relation(

        "User",

        secondary="user_projects",

        primaryjoin="projects.c.id==user_projects.c.project_id",

        secondaryjoin="and_(users.c.id==user_projects.c.user_id,\

                user_projects.c.access=='admin')",

        backref="co_projects_admins",

        viewonly=True,

    )

    committers = relation(

        "User",

        secondary="user_projects",

        primaryjoin="projects.c.id==user_projects.c.project_id",

        secondaryjoin="and_(users.c.id==user_projects.c.user_id,\

                or_(user_projects.c.access=='commit',\

                    user_projects.c.access=='admin'))",

        backref="co_projects_committers",

        viewonly=True,

    )

    groups = relation(

        "PagureGroup",

        secondary="projects_groups",

        primaryjoin="projects.c.id==projects_groups.c.project_id",

        secondaryjoin="pagure_group.c.id==projects_groups.c.group_id",

        backref=backref(

            "projects",

            order_by=str(

                "func.lower(projects.c.namespace).desc(), "

                "func.lower(projects.c.name)"

            ),

        ),

        order_by="PagureGroup.group_name.asc()",

    )

    admin_groups = relation(

        "PagureGroup",

        secondary="projects_groups",

        primaryjoin="projects.c.id==projects_groups.c.project_id",

        secondaryjoin="and_(pagure_group.c.id==projects_groups.c.group_id,\

                projects_groups.c.access=='admin')",

        backref="projects_admin_groups",

        order_by="PagureGroup.group_name.asc()",

        viewonly=True,

    )

    committer_groups = relation(

        "PagureGroup",

        secondary="projects_groups",

        primaryjoin="projects.c.id==projects_groups.c.project_id",

        secondaryjoin="and_(pagure_group.c.id==projects_groups.c.group_id,\

                or_(projects_groups.c.access=='admin',\

                    projects_groups.c.access=='commit'))",

        backref="projects_committer_groups",

        order_by="PagureGroup.group_name.asc()",

        viewonly=True,

    )

    def __repr__(self):

        return (

            "Project(%s, name:%s, namespace:%s, url:%s, is_fork:%s, "

            "parent_id:%s)"

            % (

                self.id,

                self.name,

                self.namespace,

                self.url,

                self.is_fork,

                self.parent_id,

            )

        )

    @property

    def isa(self):

        """ A string to allow finding out that this is a project. """

        return "project"

    @property

    def mail_id(self):

        """ Return a unique representation of the project as string that

        can be used when sending emails.

        """

        return "%s-project-%s" % (self.fullname, self.id)

    @property

    def is_on_repospanner(self):

        """ Returns whether this repo is on repoSpanner. """

        return self.repospanner_region is not None

    @property

    def path(self):

        """ Return the name of the git repo on the filesystem. """

        return "%s.git" % self.fullname

    def repospanner_repo_info(self, repotype, region=None):

        """ Returns info for getting a repoSpanner repo for a project.

        Args:

            repotype (string): Type of repository

            region (string): If repo is not on repoSpanner, return url as if

                it was in this region. Used for migrating to repoSpanner.

        Return type: (url, dict): First is the clone url, then a dict with

            the regioninfo.

        """

        if not self.is_on_repospanner and region is None:

            raise ValueError("Repo %s is not on repoSpanner" % self.fullname)

        if self.is_on_repospanner and region is not None:

            raise ValueError(

                "Repo %s is already on repoSpanner" % self.fullname

            )

        if region is None:

            region = self.repospanner_region

        regioninfo = pagure_config["REPOSPANNER_REGIONS"].get(region)

        if not regioninfo:

            raise ValueError(

                "Invalid repoSpanner region %s looked up" % region

            )

        url = "%s/repo/%s.git" % (

            regioninfo["url"],

            self._repospanner_repo_name(repotype, region),

        )

        return url, regioninfo

    def _repospanner_repo_name(self, repotype, region=None):

        """ Returns the name of a repo as named in repoSpanner.

        Args:

            repotype (string): Type of repository

            region (string): repoSpanner region name

        Return type: (string)

        """

        if region is None:

            region = self.repospanner_region

        return os.path.join(

            pagure_config["REPOSPANNER_REGIONS"][region].get(

                "repo_prefix", ""

            ),

            repotype,

            self.fullname,

        )

    def repopath(self, repotype):

        """ Return the full repository path of the git repo on the filesystem.

        If the repository is on repoSpanner, this will be a pseudo repository,

        which is "git repo enough" to be considered a valid repo, but any

        access should go through a repoSpanner enlightened libgit2.

        """

        if self.is_on_repospanner:

            pseudopath = os.path.join(

                pagure_config["REPOSPANNER_PSEUDO_FOLDER"], repotype, self.path

            )

            if not os.path.exists(pseudopath):

                repourl, regioninfo = self.repospanner_repo_info(repotype)

                fake = pygit2.init_repository(pseudopath, bare=True)

                fake.config["repospanner.url"] = repourl

                fake.config["repospanner.cert"] = regioninfo["push_cert"][

                    "cert"

                ]

                fake.config["repospanner.key"] = regioninfo["push_cert"]["key"]

                fake.config["repospanner.cacert"] = regioninfo["ca"]

                fake.config["repospanner.enabled"] = True

                del fake

            return pseudopath

        maindir = None

        if repotype == "main":

            maindir = pagure_config["GIT_FOLDER"]

        elif repotype == "docs":

            maindir = pagure_config["DOCS_FOLDER"]

        elif repotype == "tickets":

            maindir = pagure_config["TICKETS_FOLDER"]

        elif repotype == "requests":

            maindir = pagure_config["REQUESTS_FOLDER"]

        else:

            return ValueError("Repotype %s is invalid" % repotype)

        if maindir is None:

            if repotype == "main":

                raise Exception("No maindir for main repos?")

            return None

        return os.path.join(maindir, self.path)

    @property

    def fullname(self):

        """ Return the name of the git repo as user/project if it is a

        project forked, otherwise it returns the project name.

        """

        str_name = self.name

        if self.namespace:

            str_name = "%s/%s" % (self.namespace, str_name)

        if self.is_fork:

            str_name = "forks/%s/%s" % (self.user.user, str_name)

        return str_name

    @property

    def url_path(self):

        """ Return the path at which this project can be accessed in the

        web UI.

        """

        path = self.name

        if self.namespace:

            path = "%s/%s" % (self.namespace, path)

        if self.is_fork:

            path = "fork/%s/%s" % (self.user.user, path)

        return path

    @property

    def tags_text(self):

        """ Return the list of tags in a simple text form. """

        return [tag.tag for tag in self.tags]

    @property

    def settings(self):

        """ Return the dict stored as string in the database as an actual

        dict object.

        """

        default = {

            "issue_tracker": True,

            "project_documentation": False,

            "pull_requests": True,

            "Only_assignee_can_merge_pull-request": False,

            "Minimum_score_to_merge_pull-request": -1,

            "Web-hooks": None,

            "Enforce_signed-off_commits_in_pull-request": False,

            "always_merge": False,

            "issues_default_to_private": False,

            "fedmsg_notifications": True,

            "stomp_notifications": True,

            "mqtt_notifications": True,

            "pull_request_access_only": False,

            "notify_on_pull-request_flag": False,

            "notify_on_commit_flag": False,

            "issue_tracker_read_only": False,

            "disable_non_fast-forward_merges": False,

            "open_metadata_access_to_all": False,

        }

        if self._settings:

            current = json.loads(self._settings)

            # Update the current dict with the new keys

            for key in default:

                if key not in current:

                    current[key] = default[key]

                elif key == "Minimum_score_to_merge_pull-request":

                    current[key] = int(current[key])

                elif is_true(current[key]):

                    current[key] = True

            # Update the current dict, removing the old keys

            for key in sorted(current):

                if key not in default:

                    del current[key]

            return current

        else:

            return default

    @settings.setter

    def settings(self, settings):

        """ Ensures the settings are properly saved. """

        self._settings = json.dumps(settings)

    @property

    def milestones(self):

        """ Return the dict stored as string in the database as an actual

        dict object.

        """

        milestones = {}

        if self._milestones:

            def _convert_to_dict(value):

                if isinstance(value, dict):

                    return value

                else:

                    return {"date": value, "active": True}

            milestones = dict(

                [

                    (k, _convert_to_dict(v))

                    for k, v in json.loads(self._milestones).items()

                ]

            )

        return milestones

    @milestones.setter

    def milestones(self, milestones):

        """ Ensures the milestones are properly saved. """

        self._milestones = json.dumps(milestones)

    @property

    def milestones_keys(self):

        """ Return the list of milestones so we can keep the order consistent.

        """

        milestones_keys = {}

        if self._milestones_keys:

            milestones_keys = json.loads(self._milestones_keys)

        return milestones_keys

    @milestones_keys.setter

    def milestones_keys(self, milestones_keys):

        """ Ensures the milestones keys are properly saved. """

        self._milestones_keys = json.dumps(milestones_keys)

    @property

    def priorities(self):

        """ Return the dict stored as string in the database as an actual

        dict object.

        """

        priorities = {}

        if self._priorities:

            priorities = json.loads(self._priorities)

        return priorities

    @priorities.setter

    def priorities(self, priorities):

        """ Ensures the priorities are properly saved. """

        self._priorities = json.dumps(priorities)

    @property

    def block_users(self):

        """ Return the dict stored as string in the database as an actual

        dict object.

        """

        block_users = []

        if self._block_users:

            block_users = json.loads(self._block_users)

        return block_users

    @block_users.setter

    def block_users(self, block_users):

        """ Ensures the block_users are properly saved. """

        self._block_users = json.dumps(block_users)

    @property

    def quick_replies(self):

        """ Return a list of quick replies available for pull requests and

        issues.

        """

        quick_replies = []

        if self._quick_replies:

            quick_replies = json.loads(self._quick_replies)

        return quick_replies

    @quick_replies.setter

    def quick_replies(self, quick_replies):

        """ Ensures the quick replies are properly saved. """

        self._quick_replies = json.dumps(quick_replies)

    @property

    def notifications(self):

        """ Return the dict stored as string in the database as an actual

        dict object.

        """

        notifications = {}

        if self._notifications:

            notifications = json.loads(self._notifications)

        return notifications

    @notifications.setter

    def notifications(self, notifications):

        """ Ensures the notifications are properly saved. """

        self._notifications = json.dumps(notifications)

    @property

    def reports(self):

        """ Return the dict stored as string in the database as an actual

        dict object.

        """

        reports = {}

        if self._reports:

            reports = json.loads(self._reports)

        return reports

    @reports.setter

    def reports(self, reports):

        """ Ensures the reports are properly saved. """

        self._reports = json.dumps(reports)

    @property

    def close_status(self):

        """ Return the dict stored as string in the database as an actual

        dict object.

        """

        close_status = []

        if self._close_status:

            close_status = json.loads(self._close_status)

        return close_status

    @close_status.setter

    def close_status(self, close_status):

        """ Ensures the different close status are properly saved. """

        self._close_status = json.dumps(close_status)

    @property

    def open_requests(self):

        """ Returns the number of open pull-requests for this project. """

        return (

            BASE.metadata.bind.query(PullRequest)

            .filter(self.id == PullRequest.project_id)

            .filter(PullRequest.status == "Open")

            .count()

        )

    @property

    def open_tickets(self):

        """ Returns the number of open tickets for this project. """

        return (

            BASE.metadata.bind.query(Issue)

            .filter(self.id == Issue.project_id)

            .filter(Issue.status == "Open")

            .count()

        )

    @property

    def open_tickets_public(self):

        """ Returns the number of open tickets for this project. """

        return (

            BASE.metadata.bind.query(Issue)

            .filter(self.id == Issue.project_id)

            .filter(Issue.status == "Open")

            .filter(Issue.private == False)  # noqa: E712

            .count()

        )

    @property

    def contributors(self):

        """ Return the dict presenting the different contributors of the

        project based on their access level.

        """

        contributors = collections.defaultdict(list)

        for user in self.user_projects:

            contributors[user.access].append(user.user)

        return contributors

    @property

    def contributor_groups(self):

        """ Return the dict presenting the different contributors of the

        project based on their access level.

        """

        contributors = collections.defaultdict(list)

        for group in self.projects_groups:

            contributors[group.access].append(group.group)

        return contributors

    def get_project_users(self, access, combine=True):

        """ Returns the list of users/groups of the project according