from kallithea.model.db import User, UserEmailMap, UserIpMap, UserToPerm

from kallithea.model.forms import UserForm, CustomDefaultPermissionsForm

from kallithea.model.user import UserModel

from kallithea.model.meta import Session

from kallithea.lib.utils import action_logger

from kallithea.lib.compat import json

from kallithea.lib.utils2 import datetime_to_time, safe_int

log = logging.getLogger(__name__)

class UsersController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

        super(UsersController, self).__before__()

        c.available_permissions = config['available_permissions']

        c.EXTERN_TYPE_INTERNAL = kallithea.EXTERN_TYPE_INTERNAL

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

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

        # url('users')

        c.users_list = User.query().order_by(User.username)\

                        .filter(User.username != User.DEFAULT_USER)\

                        .order_by(func.lower(User.username))\

                        .all()

        users_data = []

        total_records = len(c.users_list)

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        grav_tmpl = lambda user_email, size: (

                template.get_def("user_gravatar")

                .render(user_email, size, _=_, h=h, c=c))

        username = lambda user_id, username: (

                template.get_def("user_name")

                .render(user_id, username, _=_, h=h, c=c))

        user_actions = lambda user_id, username: (

                template.get_def("user_actions")

                .render(user_id, username, _=_, h=h, c=c))

        for user in c.users_list:

            users_data.append({

                "raw_name": user.username,

                "username": username(user.user_id, user.username),

                "firstname": user.name,

                "lastname": user.lastname,

                "last_login": h.fmt_date(user.last_login),

                "last_login_raw": datetime_to_time(user.last_login),

                "active": h.boolicon(user.active),

                "admin": h.boolicon(user.admin),

                "extern_type": user.extern_type,

                "extern_name": user.extern_name,

                "action": user_actions(user.user_id, user.username),

            })

        c.data = json.dumps({

            "totalRecords": total_records,

            "startIndex": 0,

            "sort": None,

            "dir": "asc",

            "records": users_data

        })

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

    def create(self):

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

        # url('users')

        c.default_extern_type = auth_modules.auth_internal.KallitheaAuthPlugin.name

        user_model = UserModel()

        user_form = UserForm()()

        try:

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

            user = user_model.create(form_result)

            usr = form_result['username']

            action_logger(self.authuser, 'admin_created_user:%s' % usr,

                          None, self.ip_addr, self.sa)

            h.flash(h.literal(_('Created user %s') % h.link_to(h.escape(usr), url('edit_user', id=user.user_id))),

                    category='success')

            Session().commit()

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/users/user_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except UserCreationError, e:

            h.flash(e, 'error')

        except Exception:

            c.url_prev = url('files_home', repo_name=c.repo_name,

                         revision=prev_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_prev += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_prev = '#'

        # next link

        try:

            next_rev = c.db_repo_scm_instance.get_changeset(cur_rev).next(c.branch)

            c.url_next = url('files_home', repo_name=c.repo_name,

                     revision=next_rev.raw_id, f_path=f_path)

            if c.branch:

                c.url_next += '?branch=%s' % c.branch

        except (ChangesetDoesNotExistError, VCSError):

            c.url_next = '#'

        # files or dirs

        try:

            c.file = c.changeset.get_node(f_path)

            if c.file.is_file():

                c.load_full_history = False

                file_last_cs = c.file.last_changeset

                c.file_changeset = (c.changeset

                                    if c.changeset.revision < file_last_cs.revision

                                    else file_last_cs)

                #determine if we're on branch head

                _branches = c.db_repo_scm_instance.branches

                c.on_branch_head = revision in _branches.keys() + _branches.values()

                _hist = []

                c.file_history = []

                if c.load_full_history:

                    c.file_history, _hist = self._get_node_history(c.changeset, f_path)

                c.authors = []

                for a in set([x.author for x in _hist]):

                    c.authors.append((h.email(a), h.person(a)))

            else:

                c.authors = c.file_history = []

        except RepositoryError, e:

            h.flash(safe_str(e), category='error')

            raise HTTPNotFound()

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return render('files/files_ypjax.html')

        # TODO: tags and bookmarks?

                              _('%s at %s') % (c.changeset.branch, h.short_id(c.changeset.raw_id)))] + \

            [(n, b) for b, n in c.db_repo_scm_instance.branches.items()]

        if c.db_repo_scm_instance.closed_branches:

            prefix = _('(closed)') + ' '

            c.revision_options += [('-', '-')] + \

                [(n, prefix + b) for b, n in c.db_repo_scm_instance.closed_branches.items()]

        return render('files/files.html')

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    @jsonify

    def history(self, repo_name, revision, f_path):

        changeset = self.__get_cs(revision)

        f_path = f_path

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, f_path)

            res = []

            for obj in file_history:

                res.append({

                    'text': obj[1],

                    'children': [{'id': o[0], 'text': o[1]} for o in obj[0]]

                })

            data = {

                'more': False,

                'results': res

            }

            return data

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def authors(self, repo_name, revision, f_path):

        changeset = self.__get_cs(revision)

        f_path = f_path

        _file = changeset.get_node(f_path)

        if _file.is_file():

            file_history, _hist = self._get_node_history(changeset, f_path)

            c.authors = []

            for a in set([x.author for x in _hist]):

                c.authors.append((h.email(a), h.person(a)))

            return render('files/files_history_box.html')

    @LoginRequired()

            password = defaults.get('password')

            email = defaults.get('email')

            def get_password():

                password = getpass.getpass('Specify admin password '

                                           '(min 6 chars):')

                confirm = getpass.getpass('Confirm password:')

                if password != confirm:

                    log.error('passwords mismatch')

                    return False

                if len(password) < 6:

                    log.error('password is to short use at least 6 characters')

                    return False

                return password

            if username is None:

                username = raw_input('Specify admin username:')

            if password is None:

                password = get_password()

                if not password:

                    #second try

                    password = get_password()

                    if not password:

                        sys.exit()

            if email is None:

                email = raw_input('Specify admin email:')

            self.create_user(username, password, email, True)

        else:

            log.info('creating admin and regular test users')

            from kallithea.tests import TEST_USER_ADMIN_LOGIN, \

            TEST_USER_ADMIN_PASS, TEST_USER_ADMIN_EMAIL, \

            TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS, \

            TEST_USER_REGULAR_EMAIL, TEST_USER_REGULAR2_LOGIN, \

            TEST_USER_REGULAR2_PASS, TEST_USER_REGULAR2_EMAIL

            self.create_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS,

                             TEST_USER_ADMIN_EMAIL, True)

            self.create_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,

                             TEST_USER_REGULAR_EMAIL, False)

            self.create_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS,

                             TEST_USER_REGULAR2_EMAIL, False)

    def create_ui_settings(self, repo_store_path):

        """

        Creates ui settings, fills out hooks

        """

        #HOOKS

        hooks1_key = Ui.HOOK_UPDATE

        hooks1_ = self.sa.query(Ui)\

            .filter(Ui.ui_key == hooks1_key).scalar()

        hooks1 = Ui() if hooks1_ is None else hooks1_

        hooks1.ui_section = 'hooks'

        hooks1.ui_key = hooks1_key

        hooks1.ui_value = 'hg update >&2'

        hooks1.ui_active = False

        self.sa.add(hooks1)

        hooks2_key = Ui.HOOK_REPO_SIZE

        hooks2_ = self.sa.query(Ui)\

            .filter(Ui.ui_key == hooks2_key).scalar()

        hooks2 = Ui() if hooks2_ is None else hooks2_

        hooks2.ui_section = 'hooks'

        hooks2.ui_key = hooks2_key

        hooks2.ui_value = 'python:kallithea.lib.hooks.repo_size'

        self.sa.add(hooks2)

        hooks3 = Ui()

        hooks3.ui_section = 'hooks'

        hooks3.ui_key = Ui.HOOK_PUSH

        hooks3.ui_value = 'python:kallithea.lib.hooks.log_push_action'

        self.sa.add(hooks3)

        hooks4 = Ui()

        hooks4.ui_section = 'hooks'

        hooks4.ui_key = Ui.HOOK_PRE_PUSH

        hooks4.ui_value = 'python:kallithea.lib.hooks.pre_push'

        self.sa.add(hooks4)

        hooks5 = Ui()

        hooks5.ui_section = 'hooks'

        hooks5.ui_key = Ui.HOOK_PULL

        hooks5.ui_value = 'python:kallithea.lib.hooks.log_pull_action'

        self.sa.add(hooks5)

        hooks6 = Ui()

        hooks6.ui_section = 'hooks'

        hooks6.ui_key = Ui.HOOK_PRE_PULL

        hooks6.ui_value = 'python:kallithea.lib.hooks.pre_pull'

        self.sa.add(hooks6)

        # enable largefiles

    NotEmpty, IPAddress, CIDR, String, FancyValidator

log = logging.getLogger(__name__)

class _Missing(object):

    pass

Missing = _Missing()

class StateObj(object):

    """

    this is needed to translate the messages using _() in validators

    """

    _ = staticmethod(_)

def M(self, key, state=None, **kwargs):

    """

    returns string from self.message based on given key,

    passed kw params are used to substitute %(named)s params inside

    translated strings

    :param msg:

    :param state:

    """

    if state is None:

        state = StateObj()

    else:

        state._ = staticmethod(_)

    #inject validator into state object

    return self.message(key, state, **kwargs)

def UniqueListFromString():

    class _UniqueListFromString(formencode.FancyValidator):

        """

        Split value on ',' and make unique while preserving order

        """

        messages = dict(

            empty=_('Value cannot be an empty list'),

            missing_value=_('Value cannot be an empty list'),

        )

        def _to_python(self, value, state):

            value = aslist(value, ',')

            seen = set()

            return [c for c in value if not (c in seen or seen.add(c))]

        def empty_value(self, value):

            return []

    return _UniqueListFromString

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

    class _validator(formencode.validators.FancyValidator):

        messages = {

            'username_exists': _(u'Username "%(username)s" already exists'),

            'system_invalid_username':

                _(u'Username "%(username)s" is forbidden'),

            'invalid_username':

                _(u'Username may only contain alphanumeric characters '

                    'underscores, periods or dashes and must begin with '

                    'alphanumeric character or underscore')

        }

        def validate_python(self, value, state):

            if value in ['default', 'new_user']:

                msg = M(self, 'system_invalid_username', state, username=value)

                raise formencode.Invalid(msg, value, state)

            #check if user is unique

            old_un = None

            if edit:

                old_un = User.get(old_data.get('user_id')).username

            if old_un != value or not edit:

                if User.get_by_username(value, case_insensitive=True):

                    msg = M(self, 'username_exists', state, username=value)

                    raise formencode.Invalid(msg, value, state)

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

                msg = M(self, 'invalid_username', state)

                raise formencode.Invalid(msg, value, state)

    return _validator

def ValidRegex(msg=None):

    class _validator(formencode.validators.Regex):

        messages = dict(invalid=msg or _('The input is not valid'))

    return _validator

def ValidRepoUser():

    class _validator(formencode.validators.FancyValidator):

        messages = {

            'invalid_username': _(u'Username %(username)s is not valid')

    // create event for hide button

    $form.find('.hide-inline-form').click(function(e) {

        var newtr = e.currentTarget.parentNode.parentNode.parentNode.parentNode.parentNode;

        if($(newtr).next().hasClass('inline-comments-button')){

            $(newtr).next().show();

        }

        $(newtr).remove();

        $(parent_tr).removeClass('form-open');

        $(parent_tr).removeClass('hl-comment');

    });

    return $form

};

/**

 * Inject inline comment for an given TR. This tr should always be a .line .

 * The form will be inject after any comments.

 */

var injectInlineForm = function(tr){

    var $tr = $(tr);

    if(!$tr.hasClass('line')){

        return

    }

    var submit_url = AJAX_COMMENT_URL;

    var $td = $tr.find('.code');

    if($tr.hasClass('form-open') || $tr.hasClass('context') || $td.hasClass('no-comment')){

        return

    }

    $tr.addClass('form-open hl-comment');

    var $node = $tr.parent().parent().parent().find('.full_f_path');

    var f_path = $node.attr('path');

    var lineno = _getLineNo(tr);

    var $form = _createInlineForm(tr, f_path, lineno, submit_url);

    var $parent = $tr;

    while ($parent.next().hasClass('inline-comments')){

        var $parent = $parent.next();

    }

    $form.insertAfter($parent);

    var $overlay = $form.find('.submitting-overlay');

    var $inlineform = $form.find('.inline-form');

    $form.submit(function(e){

        e.preventDefault();

        if(lineno === undefined){

            alert('Error submitting, line ' + lineno + ' not found.');

        }

        if(f_path === undefined){

            alert('Error submitting, file path ' + f_path + ' not found.');

        }

        var text = $('#text_'+lineno).val();

        if(text == ""){

        }

        $overlay.show();

        var success = function(json_data){

            $tr.removeClass('form-open');

            $form.remove();

            _renderInlineComment(json_data);

        };

        var postData = {

                'text': text,

                'f_path': f_path,

                'line': lineno

        };

        ajaxPOST(submit_url, postData, success);

    });

    $('#preview-btn_'+lineno).click(function(e){

        var text = $('#text_'+lineno).val();

        if(!text){

            return

        }

        $('#preview-box_'+lineno).addClass('unloaded');

        $('#preview-box_'+lineno).html(_TM['Loading ...']);

        $('#edit-container_'+lineno).hide();

        $('#edit-btn_'+lineno).show();

        $('#preview-container_'+lineno).show();

        $('#preview-btn_'+lineno).hide();

        var url = pyroutes.url('changeset_comment_preview', {'repo_name': REPO_NAME});

        var post_data = {'text': text};

        ajaxPOST(url, post_data, function(html){

            $('#preview-box_'+lineno).html(html);

            $('#preview-box_'+lineno).removeClass('unloaded');

        })

    })

    $('#edit-btn_'+lineno).click(function(e){

        $('#edit-container_'+lineno).show();

        $('#edit-btn_'+lineno).hide();

        $('#preview-container_'+lineno).hide();

        $('#preview-btn_'+lineno).show();

    })

    setTimeout(function(){

        // callbacks

        tooltip_activate();

        MentionsAutoComplete('text_'+lineno, 'mentions_container_'+lineno,

                             _USERS_AC_DATA, _GROUPS_AC_DATA);

//Format is key == name

//    "mark_error_fixed": [ # key

//            "error_id" # list of args

//        ]

//

var PROUTES_MAP = {

}

                    ${op}???

                  %endif

              </div>

              <div class="diff-actions">

                <a href="${h.url('files_diff_2way_home',repo_name=c.cs_repo.repo_name,f_path=h.safe_unicode(filenode_path),diff1=c.a_rev,diff2=c.cs_rev,diff='diff',fulldiff=1)}" class="tooltip" title="${h.tooltip(_('Show full side-by-side diff for this file'))}">

                  <i class="icon-docs"></i>

                </a>

                ${c.ignorews_url(request.GET)}

                ${c.context_url(request.GET)}

              </div>

          </div>

      </div>

        <div class="code-body">

            <div class="full_f_path" path="${h.safe_unicode(filenode_path)}"></div>

            ${diff|n}

            %if filenode_path.rsplit('.')[-1] in ['png', 'gif', 'jpg', 'bmp']:

              <div class="btn btn-image-diff-show">Show images</div>

              %if op == 'M':

                <div id="${h.FID('',filenode_path)}_image-diff" class="btn btn-image-diff-swap" style="display:none">Press to swap images</div>

              %endif

              <div style="font-size: 0">

                %if op == 'M':

                  <img id="${h.FID('',filenode_path)}_image-diff-img-a" class="img-diff img-diff-swapable" style="display:none"

                      realsrc="${h.url('files_raw_home',repo_name=c.a_repo.repo_name,revision=c.a_rev,f_path=filenode_path) if op in 'DM' else ''}" />

                %endif

                %if op in 'AM':

                  <img id="${h.FID('',filenode_path)}_image-diff-img-b" class="img-diff img-diff-swapable" style="display:none"

                      realsrc="${h.url('files_raw_home',repo_name=c.cs_repo.repo_name,revision=c.cs_rev,f_path=filenode_path) if op in 'AM' else ''}" />

                %endif

              </div>

            %endif

        </div>

    </div>

  %endfor

</%def>

<%def name="diff_block_js()">

<script type="text/javascript">

$(document).ready(function(){

    $('.btn-image-diff-show').click(function(e){

        $('.btn-image-diff-show').hide();

        $('.btn-image-diff-swap').show();

        $('.img-diff-swapable')

            .each(function(i,e){

                    $(e).attr('src', $(e).attr('realsrc'));

                })

            .show();

        });

    $('.btn-image-diff-swap').mousedown(function(e){

        $('#'+e.currentTarget.id+'-img-a.img-diff-swapable')

          .before($('#'+e.currentTarget.id+'-img-b.img-diff-swapable'));

    });

    var reset = function(e){

        $('#'+e.currentTarget.id+'-img-a.img-diff-swapable')

          .after($('#'+e.currentTarget.id+'-img-b.img-diff-swapable'));

    };

    $('.btn-image-diff-swap').mouseup(reset);

    $('.btn-image-diff-swap').mouseleave(reset);

});

</script>

</%def>