from formencode import htmlfill

from operator import itemgetter

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

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

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

    HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import Group

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.forms import ReposGroupForm

log = logging.getLogger(__name__)

class ReposGroupsController(BaseController):

    """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('repos_group', 'repos_groups')

    def __load_defaults(self):

        c.repo_groups = [('', '')]

        parents_link = lambda k: h.literal('»'.join(

                                    map(lambda k: k.group_name,

                                        k.parents + [k])

                                    )

                                )

        c.repo_groups.extend([(x.group_id, parents_link(x)) for \

                                            x in self.sa.query(Group).all()])

        c.repo_groups = sorted(c.repo_groups,

                               key=lambda t: t[1].split('»')[0])

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

    @HasPermissionAnyDecorator('hg.admin')

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

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

        # url('repos_groups')

        sk = lambda g:g.parents[0].group_name if g.parents else g.group_name

        c.groups = sorted(Group.query().all(), key=sk)

        return render('admin/repos_groups/repos_groups_show.html')

    @HasPermissionAnyDecorator('hg.admin')

    def create(self):

        """POST /repos_groups: Create a new item"""

        # url('repos_groups')

        self.__load_defaults()

        repos_group_model = ReposGroupModel()

        repos_group_form = ReposGroupForm(available_groups=

                                          c.repo_groups_choices)()

        try:

            form_result = repos_group_form.to_python(dict(request.POST))

            repos_group_model.create(form_result)

            h.flash(_('created repos group %s') \

            #TODO: in futureaction_logger(, '', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/repos_groups/repos_groups_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during creation of repos group %s') \

        return redirect(url('repos_groups'))

    @HasPermissionAnyDecorator('hg.admin')

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

        """GET /repos_groups/new: Form to create a new item"""

        # url('new_repos_group')

        self.__load_defaults()

        return render('admin/repos_groups/repos_groups_add.html')

    @HasPermissionAnyDecorator('hg.admin')

    def update(self, id):

        """PUT /repos_groups/id: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('repos_group', id=ID),

        #           method='put')

        # url('repos_group', id=ID)

    @HasPermissionAnyDecorator('hg.admin')

    def delete(self, id):

        """DELETE /repos_groups/id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repos_group', id=ID),

        #           method='delete')

        # url('repos_group', id=ID)

        repos_group_model = ReposGroupModel()

        gr = Group.get(id)

        repos = gr.repositories.all()

        if repos:

            h.flash(_('This group contains %s repositores and cannot be '

                      'deleted' % len(repos)),

                    category='error')

            return redirect(url('repos_groups'))

        try:

            repos_group_model.delete(id)

            h.flash(_('removed repos group %s' % gr.group_name), category='success')

            #TODO: in futureaction_logger(, '', '', '', self.sa)

        #overwrite our cached list with current filter

        gr_filter = [r.repo_name for r in c.group_repos]

        c.cached_repo_list = self.scm_model.get_repos(all_repos=gr_filter)

        if c.sort_by.startswith('-'):

            c.repos_list = sorted(c.cached_repo_list, key=itemgetter(sort_key),

                                  reverse=True)

        else:

            c.repos_list = sorted(c.cached_repo_list, key=itemgetter(sort_key),

                                  reverse=False)

        c.repo_cnt = len(c.repos_list)

        c.groups = self.sa.query(Group).order_by(Group.group_name)\

            .filter(Group.group_parent_id == id).all()

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

    @HasPermissionAnyDecorator('hg.admin')

    def edit(self, id, format='html'):

        """GET /repos_groups/id/edit: Form to edit an existing item"""

        # url('edit_repos_group', id=ID)

            old_ugname = None

            if edit:

                old_ugname = UsersGroup.get(

                            old_data.get('users_group_id')).users_group_name

            if old_ugname != value or not edit:

                if UsersGroup.get_by_group_name(value, cache=False,

                                               case_insensitive=True):

                    raise formencode.Invalid(_('This users group '

                                               'already exists') , value,

                                             state)

            if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:

                raise formencode.Invalid(_('Group name may only contain '

                                           'alphanumeric characters '

                                           'underscores, periods or dashes '

                                           'and must begin with alphanumeric '

                                           'character'), value, state)

    return _ValidUsersGroup

def ValidReposGroup(edit, old_data):

    class _ValidReposGroup(formencode.validators.FancyValidator):

        def validate_python(self, value, state):

            #TODO WRITE VALIDATIONS

            # slugify repo group just in case :)

            slug = repo_name_slug(group_name)

    return _ValidReposGroup

class ValidPassword(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        if value:

            if value.get('password'):

                try:

                    value['password'] = get_crypt_password(value['password'])

                except UnicodeEncodeError:

                    e_dict = {'password':_('Invalid characters in password')}

                    raise formencode.Invalid('', value, state, error_dict=e_dict)

            if value.get('password_confirmation'):

                try:

                    value['password_confirmation'] = \

                        get_crypt_password(value['password_confirmation'])

                except UnicodeEncodeError:

                    e_dict = {'password_confirmation':_('Invalid characters in password')}

                    raise formencode.Invalid('', value, state, error_dict=e_dict)

            if value.get('new_password'):

def UsersGroupForm(edit=False, old_data={}, available_members=[]):

    class _UsersGroupForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        users_group_name = All(UnicodeString(strip=True, min=1, not_empty=True),

                       ValidUsersGroup(edit, old_data))

        users_group_active = StringBoolean(if_missing=False)

        if edit:

            users_group_members = OneOf(available_members, hideList=False,

                                        testValueList=True,

                                        if_missing=None, not_empty=False)

    return _UsersGroupForm

def ReposGroupForm(edit=False, old_data={}, available_groups=[]):

    class _ReposGroupForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

                               SlugifyName())

                                                not_empty=True)

                                        testValueList=True,

                                        if_missing=None, not_empty=False)

        chained_validators = [ValidReposGroup(edit, old_data)]

    return _ReposGroupForm

def RegisterForm(edit=False, old_data={}):

    class _RegisterForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        username = All(ValidUsername(edit, old_data),

                       UnicodeString(strip=True, min=1, not_empty=True))

        password = All(UnicodeString(strip=True, min=6, not_empty=True))

        password_confirmation = All(UnicodeString(strip=True, min=6, not_empty=True))

        active = StringBoolean(if_missing=False)

        name = UnicodeString(strip=True, min=1, not_empty=True)

        lastname = UnicodeString(strip=True, min=1, not_empty=True)

        email = All(Email(not_empty=True), UniqSystemEmail(old_data))

        chained_validators = [ValidPasswordsMatch, ValidPassword]

    return _RegisterForm

    users groups model for RhodeCode

    :created_on: Jan 25, 2011

    :author: marcink

    :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# 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/>.

import os

import logging

import traceback

from pylons.i18n.translation import _

from vcs.utils.lazy import LazyProperty

from rhodecode.model import BaseModel

from rhodecode.model.caching_query import FromCache

from rhodecode.model.db import Group, RhodeCodeUi

log = logging.getLogger(__name__)

class ReposGroupModel(BaseModel):

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

        q = RhodeCodeUi.get_by_key('/').one()

        return q.ui_value

    def __create_group(self, group_name, parent_id):

        """

        makes repositories group on filesystem

        :param repo_name:

        :param parent_id:

        """

        if parent_id:

            paths = Group.get(parent_id).full_path.split(Group.url_sep())

            parent_path = os.sep.join(paths)

        else:

            parent_path = ''

        create_path = os.path.join(self.repos_path, parent_path, group_name)

        log.debug('creating new group in %s', create_path)

        if os.path.isdir(create_path):

            raise Exception('That directory already exists !')

        os.makedirs(create_path)

        """

        Renames a group on filesystem

        :param group_name:

        """

    def __delete_group(self, group):

        """

        Deletes a group from a filesystem

        :param group: instance of group from database

        """

        paths = group.full_path.split(Group.url_sep())

        paths = os.sep.join(paths)

        rm_path = os.path.join(self.repos_path, paths)

        os.rmdir(rm_path)

    def create(self, form_data):

        try:

            new_repos_group = Group()

            new_repos_group.group_description = \

            self.sa.add(new_repos_group)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def update(self, repos_group_id, form_data):

        try:

            repos_group = Group.get(repos_group_id)

            self.sa.add(repos_group)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def delete(self, users_group_id):

        try:

            users_group = Group.get(users_group_id)

            self.sa.delete(users_group)

            self.__delete_group(users_group)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    »

    ${_('add new repos group')}

</%def>

<%def name="page_nav()">

    ${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}       

    </div>

    <!-- end box / title -->

    ${h.form(url('repos_groups'))}

    <div class="form">

        <!-- fields -->

        <div class="fields">

             <div class="field">

                <div class="label">

                    <label for="users_group_name">${_('Group name')}:</label>

                </div>

                <div class="input">

                </div>

             </div>

            <div class="buttons">

              ${h.submit('save','save',class_="ui-button")}

            </div>             

        </div>

    </div>

    ${h.end_form()}

</div>    

</%def>