import logging

import traceback

import formencode

from formencode import htmlfill

from webob.exc import HTTPInternalServerError, HTTPForbidden

from pylons import request, session, tmpl_context as c, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from sqlalchemy.exc import IntegrityError

import rhodecode

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator, HasRepoPermissionAllDecorator, NotAnonymous,\

    HasPermissionAny, HasReposGroupPermissionAny, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import action_logger, repo_name_slug

from rhodecode.lib.helpers import get_token

from rhodecode.model.meta import Session

from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup,\

    RhodeCodeSetting, RepositoryField

from rhodecode.model.forms import RepoForm, RepoFieldForm, RepoPermsForm

from rhodecode.model.repo import RepoModel

from rhodecode.lib.compat import json

from sqlalchemy.sql.expression import func

from rhodecode.lib.exceptions import AttachedForksError

from rhodecode.lib.utils2 import safe_int

log = logging.getLogger(__name__)

class ReposController(BaseRepoController):

    """

    REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('repo', 'repos')

    @LoginRequired()

    def __before__(self):

        super(ReposController, self).__before__()

    def __load_defaults(self):

        acl_groups = RepoGroupList(RepoGroup.query().all(),

                               perm_set=['group.write', 'group.admin'])

        c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)

        c.in_public_journal = UserFollowing.query()\

            .filter(UserFollowing.user_id == c.default_user_id)\

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        if c.repo_info.stats:

            # this is on what revision we ended up so we add +1 for count

            last_rev = c.repo_info.stats.stat_on_revision + 1

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() if repo.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        c.repo_fields = RepositoryField.query()\

            .filter(RepositoryField.repository == db_repo).all()

        defaults = RepoModel()._get_defaults(repo_name)

        c.repos_list = [('', _('--REMOVE FORK--'))]

                    if x.repo_id != c.repo_info.repo_id]

        defaults['id_fork_of'] = db_repo.fork.repo_id if db_repo.fork else ''

        return defaults

    @HasPermissionAllDecorator('hg.admin')

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

        """GET /repos: All items in the collection"""

        # url('repos')

        c.repos_list = Repository.query()\

                        .order_by(func.lower(Repository.repo_name))\

                        .all()

        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,

                                                   admin=True,

                                                   super_user_actions=True)

        #json used to render the grid

        c.data = json.dumps(repos_data)

        return render('admin/repos/repos.html')

    @NotAnonymous()

    def create(self):

        :param perm_set: list of permissions to check

        :param perm_checker: callable to check permissions against

        """

        self.obj_list = obj_list

        self.obj_attr = obj_attr

        self.perm_set = perm_set

        self.perm_checker = perm_checker

    def __len__(self):

        return len(self.obj_list)

    def __repr__(self):

        return '<%s (%s)>' % (self.__class__.__name__, self.__len__())

    def __iter__(self):

        for db_obj in self.obj_list:

            # check permission at this level

            name = getattr(db_obj, self.obj_attr, None)

            if not self.perm_checker(*self.perm_set)(name, self.__class__.__name__):

                continue

            yield db_obj

class RepoGroupList(_PermCheckIterator):

    def __init__(self, db_repo_group_list, perm_set=None):

        if not perm_set:

            perm_set = ['group.read', 'group.write', 'group.admin']

        super(RepoGroupList, self).__init__(obj_list=db_repo_group_list,

                    obj_attr='group_name', perm_set=perm_set,

                    perm_checker=HasReposGroupPermissionAny)

class UserGroupList(_PermCheckIterator):

    def __init__(self, db_user_group_list, perm_set=None):

        if not perm_set:

            perm_set = ['usergroup.read', 'usergroup.write', 'usergroup.admin']

        super(UserGroupList, self).__init__(obj_list=db_user_group_list,

                    obj_attr='users_group_name', perm_set=perm_set,

                    perm_checker=HasUserGroupPermissionAny)

class ScmModel(BaseModel):

    """