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

"""

 (c) 2014-2018 - Copyright Red Hat Inc

 Authors:

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

   Farhaan Bukhsh <farhaan.bukhsh@gmail.com></farhaan.bukhsh@gmail.com>

"""

from __future__ import unicode_literals, absolute_import

import datetime

import logging

from math import ceil

import flask

from sqlalchemy.exc import SQLAlchemyError

import pagure.exceptions

import pagure.lib.git

import pagure.lib.query

import pagure.forms

import pagure.ui.filters

from pagure.config import config as pagure_config

from pagure.flask_app import _get_user, admin_session_timedout

from pagure.ui import UI_NS

from pagure.utils import (

    authenticated,

    is_safe_url,

    login_required,

    get_task_redirect_url,

    is_true,

)

_log = logging.getLogger(__name__)

def _filter_acls(repos, acl, user):

    """ Filter the given list of repositories to return only the ones where

    the user has the specified acl.

    """

    if acl.lower() == "main admin":

        repos = [repo for repo in repos if user.username == repo.user.username]

    elif acl.lower() == "ticket" or "commit" or "admin":

        repos = [

            repo for repo in repos if user in repo.contributors[acl.lower()]

        ]

    return repos

@UI_NS.route("/browse/projects", endpoint="browse_projects")

@UI_NS.route("/browse/projects/", endpoint="browse_projects")

@UI_NS.route("/")

def index():

    """ Front page of the application.

    """

    if (

        authenticated()

        and flask.request.path == "/"

        and not flask.session.get("_requires_fpca", False)

    ):

        flask.request.from_index = True

        return flask.redirect(flask.url_for("ui_ns.userdash_projects"))

    sorting = flask.request.args.get("sorting") or None

    page = flask.request.args.get("page", 1)

    try:

        page = int(page)

        if page < 1:

            page = 1

    except ValueError:

        page = 1

    limit = pagure_config["ITEM_PER_PAGE"]

    start = limit * (page - 1)

    private = None

    if authenticated():

        private = flask.g.fas_user.username

    repos = pagure.lib.query.search_projects(

        flask.g.session,

        fork=False,

        start=start,

        limit=limit,

        sort=sorting,

        private=private,

    )

    num_repos = pagure.lib.query.search_projects(

        flask.g.session, fork=False, private=private, count=True

    )

    total_page = int(ceil(num_repos / float(limit)) if num_repos > 0 else 1)

    return flask.render_template(

        "index.html",

        select="projects",

        namespace=None,

        repos=repos,

        repos_length=num_repos,

        total_page=total_page,

        page=page,

        sorting=sorting,

    )

def get_userdash_common(user):

    userdash_counts = {}

    userdash_counts["repos_length"] = pagure.lib.query.list_users_projects(

        flask.g.session,

        username=flask.g.fas_user.username,

        exclude_groups=None,

        fork=False,

        private=flask.g.fas_user.username,

        count=True,

    )

    userdash_counts["forks_length"] = pagure.lib.query.search_projects(

        flask.g.session,

        username=flask.g.fas_user.username,

        fork=True,

        private=flask.g.fas_user.username,

        count=True,

    )

    userdash_counts["watchlist_length"] = len(

        pagure.lib.query.user_watch_list(

            flask.g.session,

            user=flask.g.fas_user.username,

            exclude_groups=pagure_config.get("EXCLUDE_GROUP_INDEX"),

        )

    )

    userdash_counts["groups_length"] = len(user.groups)

    search_data = pagure.lib.query.list_users_projects(

        flask.g.session,

        username=flask.g.fas_user.username,

        private=flask.g.fas_user.username,

    )

    return userdash_counts, search_data

@UI_NS.route("/dashboard/projects/")

@UI_NS.route("/dashboard/projects")

@login_required

def userdash_projects():

    """ User Dashboard page listing projects for the user

    """

    user = _get_user(username=flask.g.fas_user.username)

    userdash_counts, search_data = get_userdash_common(user)

    groups = []

    for group in user.groups:

        groups.append(

            pagure.lib.query.search_groups(

                flask.g.session, group_name=group, group_type="user"

            )

        )

    acl = flask.request.args.get("acl", "").strip().lower() or None

    search_pattern = flask.request.args.get("search_pattern", None)

    if search_pattern == "":

        search_pattern = None

    limit = pagure_config["ITEM_PER_PAGE"]

    repopage = flask.request.args.get("repopage", 1)

    try:

        repopage = int(repopage)

        if repopage < 1:

            repopage = 1

    except ValueError:

        repopage = 1

    pattern = "*" + search_pattern + "*" if search_pattern else search_pattern

    start = limit * (repopage - 1)

    repos = pagure.lib.query.list_users_projects(

        flask.g.session,

        username=flask.g.fas_user.username,

        exclude_groups=None,

        fork=False,

        pattern=pattern,

        private=flask.g.fas_user.username,

        start=start,

        limit=limit,

        acls=[acl] if acl else None,

    )

    filtered_repos_count = pagure.lib.query.list_users_projects(

        flask.g.session,

        username=flask.g.fas_user.username,

        exclude_groups=None,

        fork=False,

        pattern=pattern,

        private=flask.g.fas_user.username,

        count=True,

        acls=[acl] if acl else None,

    )

    repo_list = []

    for repo in repos:

        access = ""

        if repo.user.user == user.username:

            access = "main admin"

        else:

            for repoaccess in repo.contributors:

                for repouser in repo.contributors[repoaccess]:

                    if repouser.username == user.username:

                        access = repoaccess

        grouplist = []

        for group in groups:

            if repo in group.projects:

                thegroup = {"group_name": "", "access": ""}

                thegroup["group_name"] = group.group_name

                for a in repo.contributor_groups:

                    for gr in repo.contributor_groups[a]:

                        if group.group_name == gr.group_name:

                            thegroup["access"] = a

                grouplist.append(thegroup)

        repo_list.append(

            {"repo": repo, "grouplist": grouplist, "access": access}

        )

    total_repo_page = int(

        ceil(filtered_repos_count / float(limit))

        if filtered_repos_count > 0

        else 1

    )

    return flask.render_template(

        "userdash_projects.html",

        username=flask.g.fas_user.username,

        user=user,

        select="projects",

        repo_list=repo_list,

        repopage=repopage,

        total_repo_page=total_repo_page,

        userdash_counts=userdash_counts,

        search_data=search_data,

        acl=acl,

        filtered_repos_count=filtered_repos_count,

        search_pattern=search_pattern,

    )

@UI_NS.route("/dashboard/activity/")

@UI_NS.route("/dashboard/activity")

@login_required

def userdash_activity():

    """ User Dashboard page listing user activity

    """

    user = _get_user(username=flask.g.fas_user.username)

    userdash_counts, search_data = get_userdash_common(user)

    messages = pagure.lib.query.get_watchlist_messages(

        flask.g.session, user, limit=20

    )

    return flask.render_template(

        "userdash_activity.html",

        username=flask.g.fas_user.username,

        user=user,

        select="activity",

        messages=messages,

        userdash_counts=userdash_counts,

        search_data=search_data,

    )

@UI_NS.route("/dashboard/groups/")

@UI_NS.route("/dashboard/groups")

@login_required

def userdash_groups():

    """ User Dashboard page listing a user's groups

    """

    user = _get_user(username=flask.g.fas_user.username)

    userdash_counts, search_data = get_userdash_common(user)

    groups = []

    for group in user.groups:

        groups.append(

            pagure.lib.query.search_groups(

                flask.g.session, group_name=group, group_type="user"

            )

        )

    return flask.render_template(

        "userdash_groups.html",

        username=flask.g.fas_user.username,

        user=user,

        select="groups",

        groups=groups,

        userdash_counts=userdash_counts,

        search_data=search_data,

    )

@UI_NS.route("/dashboard/forks/")

@UI_NS.route("/dashboard/forks")

@login_required

def userdash_forks():

    """ Forks tab of the user dashboard

    """

    user = _get_user(username=flask.g.fas_user.username)

    userdash_counts, search_data = get_userdash_common(user)

    limit = pagure_config["ITEM_PER_PAGE"]

    # FORKS

    forkpage = flask.request.args.get("forkpage", 1)

    try:

        forkpage = int(forkpage)

        if forkpage < 1:

            forkpage = 1

    except ValueError:

        forkpage = 1

    start = limit * (forkpage - 1)

    forks = pagure.lib.query.search_projects(

        flask.g.session,

        username=flask.g.fas_user.username,

        fork=True,

        private=flask.g.fas_user.username,

        start=start,

        limit=limit,

    )

    total_fork_page = int(

        ceil(userdash_counts["forks_length"] / float(limit))

        if userdash_counts["forks_length"] > 0

        else 1

    )

    return flask.render_template(

        "userdash_forks.html",

        username=flask.g.fas_user.username,

        user=user,

        select="forks",

        forks=forks,

        forkpage=forkpage,

        total_fork_page=total_fork_page,

        userdash_counts=userdash_counts,

        search_data=search_data,

    )

@UI_NS.route("/dashboard/watchlist/")

@UI_NS.route("/dashboard/watchlist")

@login_required

def userdash_watchlist():

    """ User Dashboard page for a user's watchlist

    """

    watch_list = pagure.lib.query.user_watch_list(

        flask.g.session,

        user=flask.g.fas_user.username,

        exclude_groups=pagure_config.get("EXCLUDE_GROUP_INDEX"),

    )

    user = _get_user(username=flask.g.fas_user.username)

    userdash_counts, search_data = get_userdash_common(user)

    return flask.render_template(

        "userdash_watchlist.html",

        username=flask.g.fas_user.username,

        user=user,

        select="watchlist",

        watch_list=watch_list,

        userdash_counts=userdash_counts,

        search_data=search_data,

    )

def index_auth():

    """ Front page for authenticated user.

    """

    user = _get_user(username=flask.g.fas_user.username)

    acl = flask.request.args.get("acl", "").strip().lower() or None

    repopage = flask.request.args.get("repopage", 1)

    try:

        repopage = int(repopage)

        if repopage < 1:

            repopage = 1

    except ValueError:

        repopage = 1

    limit = pagure_config["ITEM_PER_PAGE"]

    # PROJECTS

    start = limit * (repopage - 1)

    repos = pagure.lib.query.search_projects(

        flask.g.session,

        username=flask.g.fas_user.username,

        exclude_groups=pagure_config.get("EXCLUDE_GROUP_INDEX"),

        fork=False,

        private=flask.g.fas_user.username,

        start=start,

        limit=limit,

    )

    if repos and acl:

        repos = _filter_acls(repos, acl, user)

    repos_length = pagure.lib.query.search_projects(

        flask.g.session,

        username=flask.g.fas_user.username,

        exclude_groups=pagure_config.get("EXCLUDE_GROUP_INDEX"),

        fork=False,

        private=flask.g.fas_user.username,

        count=True,

    )

    total_repo_page = int(

        ceil(repos_length / float(limit)) if repos_length > 0 else 1

    )

    # FORKS

    forkpage = flask.request.args.get("forkpage", 1)

    try:

        forkpage = int(forkpage)

        if forkpage < 1:

            forkpage = 1

    except ValueError:

        forkpage = 1

    start = limit * (forkpage - 1)

    forks = pagure.lib.query.search_projects(

        flask.g.session,

        username=flask.g.fas_user.username,

        fork=True,

        private=flask.g.fas_user.username,

        start=start,

        limit=limit,

    )

    forks_length = pagure.lib.query.search_projects(

        flask.g.session,

        username=flask.g.fas_user.username,

        fork=True,

        private=flask.g.fas_user.username,

        start=start,

        limit=limit,

        count=True,

    )

    total_fork_page = int(

        ceil(forks_length / float(limit)) if forks_length > 0 else 1

    )

    watch_list = pagure.lib.query.user_watch_list(

        flask.g.session,

        user=flask.g.fas_user.username,

        exclude_groups=pagure_config.get("EXCLUDE_GROUP_INDEX"),

    )

    return flask.render_template(

        "userdash_projects.html",

        username=flask.g.fas_user.username,

        user=user,

        forks=forks,

        repos=repos,

        watch_list=watch_list,

        repopage=repopage,

        repos_length=repos_length,

        total_repo_page=total_repo_page,

        forkpage=forkpage,

        forks_length=forks_length,

        total_fork_page=total_fork_page,

    )

@UI_NS.route("/search/")

@UI_NS.route("/search")

def search():

    """ Search this pagure instance for projects or users.

    """

    stype = flask.request.args.get("type", "projects")

    term = flask.request.args.get("term")

    page = flask.request.args.get("page", 1)

    direct = is_true(flask.request.values.get("direct", False))

    try:

        page = int(page)

        if page < 1:

            page = 1

    except ValueError:

        page = 1

    if direct:

        return flask.redirect(flask.url_for("ui_ns.view_repo", repo="") + term)

    if stype == "projects":

        return flask.redirect(

            flask.url_for("ui_ns.view_projects", pattern=term)

        )

    elif stype == "projects_forks":

        return flask.redirect(

            flask.url_for("view_projects", pattern=term, forks=True)

        )

    elif stype == "groups":

        return flask.redirect(flask.url_for("ui_ns.view_group", group=term))

    else:

        return flask.redirect(flask.url_for("ui_ns.view_users", username=term))

@UI_NS.route("/users/")

@UI_NS.route("/users")

@UI_NS.route("/users/<username>")</username>

def view_users(username=None):

    """ Present the list of users.

    """

    page = flask.request.args.get("page", 1)

    try:

        page = int(page)

        if page < 1:

            page = 1

    except ValueError:

        page = 1

    users = pagure.lib.query.search_user(flask.g.session, pattern=username)

    private = False

    # Condition to check non-authorized user should't be able to access private

    # project of other users

    if authenticated() and username == flask.g.fas_user.username:

        private = flask.g.fas_user.username

    limit = pagure_config["ITEM_PER_PAGE"]

    start = limit * (page - 1)

    end = limit * page

    users_length = len(users)

    users = users[start:end]

    total_page = int(ceil(users_length / float(limit)))

    for user in users:

        repos_length = pagure.lib.query.search_projects(

            flask.g.session,

            username=user.user,

            fork=False,

            count=True,

            private=private,

        )

        forks_length = pagure.lib.query.search_projects(

            flask.g.session,

            username=user.user,

            fork=True,

            count=True,

            private=private,

        )

        user.repos_length = repos_length

        user.forks_length = forks_length

    return flask.render_template(

        "user_list.html",

        users=users,

        users_length=users_length,

        total_page=total_page,

        page=page,

        select="users",

    )

@UI_NS.route("/projects/")

@UI_NS.route("/projects")

@UI_NS.route("/projects/<pattern>")</pattern>

@UI_NS.route("/projects/<namespace>/<pattern>")</pattern></namespace>

def view_projects(pattern=None, namespace=None):

    """ Present the list of projects.

    """

    forks = flask.request.args.get("forks")

    page = flask.request.args.get("page", 1)

    try:

        page = int(page)

        if page < 1:

            page = 1

    except ValueError:

        page = 1

    select = "projects"

    # If forks is specified, we want both forks and projects

    if is_true(forks):

        forks = None

        select = "projects_forks"

    else:

        forks = False

    private = False

    if authenticated():

        private = flask.g.fas_user.username

    limit = pagure_config["ITEM_PER_PAGE"]

    start = limit * (page - 1)

    projects = pagure.lib.query.search_projects(

        flask.g.session,

        pattern=pattern,

        namespace=namespace,

        fork=forks,

        start=start,

        limit=limit,

        private=private,

    )

    if len(projects) == 1:

        flask.flash("Only one result found, redirecting you to it")

        return flask.redirect(

            flask.url_for(

                "ui_ns.view_repo",

                repo=projects[0].name,

                namespace=projects[0].namespace,

                username=projects[0].user.username

                if projects[0].is_fork

                else None,

            )

        )

    projects_length = pagure.lib.query.search_projects(

        flask.g.session,

        pattern=pattern,

        namespace=namespace,

        fork=forks,

        count=True,

        private=private,

    )

    total_page = int(ceil(projects_length / float(limit)))

    if namespace in pagure_config["ALLOWED_PREFIX"]:

        namespace = None

    return flask.render_template(

        "index.html",

        namespace=namespace,

        repos=projects,

        repos_length=projects_length,

        total_page=total_page,

        page=page,

        select=select,

    )

def get_userprofile_common(user):

    userprofile_counts = {}

    userprofile_counts["repos_length"] = pagure.lib.query.search_projects(

        flask.g.session,

        username=user.username,

        fork=False,

        exclude_groups=None,

        private=False,

        count=True,

    )

    userprofile_counts["forks_length"] = pagure.lib.query.search_projects(

        flask.g.session,

        username=user.username,

        fork=True,

        private=False,

        count=True,

    )

    return userprofile_counts

@UI_NS.route("/user/<username>/")</username>

@UI_NS.route("/user/<username>")</username>

def view_user(username):

    """ Front page of a specific user.

    """

    user = _get_user(username=username)

    # public profile, so never show private repos,

    # even if the user is viewing themself

    private = False

    owned_repos = pagure.lib.query.list_users_projects(

        flask.g.session,

        username=username,

        exclude_groups=None,

        fork=False,

        private=private,

        limit=6,

        acls=["main admin"],

    )

    userprofile_common = get_userprofile_common(user)

    return flask.render_template(

        "userprofile_overview.html",

        username=username,

        user=user,

        owned_repos=owned_repos,

        repos_length=userprofile_common["repos_length"],

        forks_length=userprofile_common["forks_length"],

        select="overview",

    )

@UI_NS.route("/user/<username>/projects/")</username>

@UI_NS.route("/user/<username>/projects")</username>

def userprofile_projects(username):

    """ Public Profile view of a user's projects.

    """

    user = _get_user(username=username)

    repopage = flask.request.args.get("repopage", 1)

    try:

        repopage = int(repopage)

        if repopage < 1:

            repopage = 1

    except ValueError:

        repopage = 1

    limit = pagure_config["ITEM_PER_PAGE"]

    repo_start = limit * (repopage - 1)

    repos = pagure.lib.query.search_projects(

        flask.g.session,

        username=username,

        fork=False,

        exclude_groups=pagure_config.get("EXCLUDE_GROUP_INDEX"),

        start=repo_start,

        limit=limit,

        private=False,

    )

    userprofile_common = get_userprofile_common(user)

    total_page_repos = int(

        ceil(userprofile_common["repos_length"] / float(limit))

    )

    return flask.render_template(

        "userprofile_projects.html",

        username=username,

        user=user,

        repos=repos,

        total_page_repos=total_page_repos,

        repopage=repopage,

        repos_length=userprofile_common["repos_length"],

        forks_length=userprofile_common["forks_length"],

        select="projects",

    )

@UI_NS.route("/user/<username>/forks/")</username>

@UI_NS.route("/user/<username>/forks")</username>

def userprofile_forks(username):

    """ Public Profile view of a user's forks.

    """

    user = _get_user(username=username)

    forkpage = flask.request.args.get("forkpage", 1)

    try:

        forkpage = int(forkpage)

        if forkpage < 1:

            forkpage = 1

    except ValueError:

        forkpage = 1

    limit = pagure_config["ITEM_PER_PAGE"]

    fork_start = limit * (forkpage - 1)

    forks = pagure.lib.query.search_projects(

        flask.g.session,

        username=username,

        fork=True,

        start=fork_start,

        limit=limit,

        private=False,

    )

    userprofile_common = get_userprofile_common(user)

    total_page_forks = int(

        ceil(userprofile_common["forks_length"] / float(limit))

    )

    return flask.render_template(

        "userprofile_forks.html",

        username=username,

        user=user,

        forks=forks,

        total_page_forks=total_page_forks,

        forkpage=forkpage,

        repos_length=userprofile_common["repos_length"],

        forks_length=userprofile_common["forks_length"],

        select="forks",

    )

# original view_user()

@UI_NS.route("/user2/<username>/")</username>

@UI_NS.route("/user2/<username>")</username>

def view_user2(username):

    """ Front page of a specific user.

    """

    user = _get_user(username=username)

    acl = flask.request.args.get("acl", "").strip().lower() or None

    repopage = flask.request.args.get("repopage", 1)

    try:

        repopage = int(repopage)

        if repopage < 1:

            repopage = 1

    except ValueError:

        repopage = 1

    forkpage = flask.request.args.get("forkpage", 1)

    try:

        forkpage = int(forkpage)

        if forkpage < 1:

            forkpage = 1

    except ValueError:

        forkpage = 1

    limit = pagure_config["ITEM_PER_PAGE"]

    repo_start = limit * (repopage - 1)

    fork_start = limit * (forkpage - 1)

    private = False

    if authenticated() and username == flask.g.fas_user.username:

        private = flask.g.fas_user.username

    repos = pagure.lib.query.search_projects(

        flask.g.session,

        username=username,

        fork=False,

        exclude_groups=pagure_config.get("EXCLUDE_GROUP_INDEX"),

        start=repo_start,

        limit=limit,

        private=private,

    )

    if repos and acl:

        repos = _filter_acls(repos, acl, user)

    repos_length = pagure.lib.query.search_projects(

        flask.g.session,

        username=username,

        fork=False,

        exclude_groups=pagure_config.get("EXCLUDE_GROUP_INDEX"),

        private=private,

        count=True,

    )

    forks = pagure.lib.query.search_projects(

        flask.g.session,

        username=username,

        fork=True,

        start=fork_start,

        limit=limit,

        private=private,

    )

    forks_length = pagure.lib.query.search_projects(

        flask.g.session,

        username=username,

        fork=True,

        private=private,

        count=True,

    )

    total_page_repos = int(ceil(repos_length / float(limit)))

    total_page_forks = int(ceil(forks_length / float(limit)))

    return flask.render_template(

        "userprofile_overview.html",