#==============================================================================

def gravatar(email_address, cls='', size=30):

    """return html element of the gravatar

    This method will return an <img> with the resolution double the size (for

    retina screens) of the image. If the url returned from gravatar_url is

    empty then we fallback to using an icon.

    """

    src = gravatar_url(email_address, size * 2)

    if src:

        # here it makes sense to use style="width: ..." (instead of, say, a

        # stylesheet) because we using this to generate a high-res (retina) size

        html = ('<img alt="" class="{cls}" style="width: {size}px; height: {size}px" src="{src}"/>'

            .format(cls=cls, size=size, src=src))

    else:

        # if src is empty then there was no gravatar, so we use a font icon

        html = ("""<i class="icon-user {cls}" style="font-size: {size}px;"></i>"""

            .format(cls=cls, size=size, src=src))

    return literal(html)

    # doh, we need to re-import those to mock it later

    from pylons import url

    from pylons import tmpl_context as c

    if not c.visual.use_gravatar:

        return ""

    _def = 'anonymous@kallithea-scm.org'  # default gravatar

    email_address = email_address or _def

    if email_address == _def:

    parsed_url = urlparse.urlparse(url.current(qualified=True))

    url = (c.visual.gravatar_url or User.DEFAULT_GRAVATAR_URL ) \

               .replace('{email}', email_address) \

               .replace('{md5email}', hashlib.md5(safe_str(email_address).lower()).hexdigest()) \

               .replace('{netloc}', parsed_url.netloc) \

               .replace('{scheme}', parsed_url.scheme) \

               .replace('{size}', safe_str(size))

    return url

class Page(_Page):

    """

    Custom pager to match rendering style with YUI paginator

    """

    def _get_pos(self, cur_page, max_page, items):

        edge = (items / 2) + 1

        if (cur_page <= edge):

            radius = max(items / 2, items - cur_page)

        elif (max_page - cur_page) < edge:

            radius = (items - 1) - (max_page - cur_page)

        else:

            radius = items / 2

        Gets all repositories that user have at least read access

        :param user:

        """

        from kallithea.lib.auth import AuthUser

        user = self._get_user(user)

        repos = AuthUser(user_id=user.user_id).permissions['repositories']

        access_check = lambda r: r[1] in ['repository.read',

                                          'repository.write',

                                          'repository.admin']

        repos = [x[0] for x in filter(access_check, repos.items())]

        return Repository.query().filter(Repository.repo_name.in_(repos))

    def get_users_js(self):

        users = self.sa.query(User) \

            .filter(User.active == True) \

            .order_by(User.name, User.lastname) \

            .all()

        return json.dumps([

            {

                'id': u.user_id,

                'fname': h.escape(u.name),

                'lname': h.escape(u.lastname),

                'nname': u.username,

                'gravatar_size': 14,

            } for u in users]

        )

    def get_user_groups_js(self):

        user_groups = self.sa.query(UserGroup) \

            .filter(UserGroup.users_group_active == True) \

            .order_by(UserGroup.users_group_name) \

            .options(subqueryload(UserGroup.members)) \

            .all()

        user_groups = UserGroupList(user_groups, perm_set=['usergroup.read',

                                                           'usergroup.write',

                                                           'usergroup.admin'])

        return json.dumps([

            {

                'id': gr.users_group_id,

                'grname': gr.users_group_name,

                'grmembers': len(gr.members),

            } for gr in user_groups]

        )

    @classmethod

    def _render_datatable(cls, tmpl, *args, **kwargs):

        import kallithea

    // Case insensitive matching

    var query = sQuery.toLowerCase();

    var i = 0;

    var l = myGroups.length;

    var matches = [];

    // Match against each name of each group

    for (; i < l; i++) {

        var matched_group = myGroups[i];

        if (matched_group.grname.toLowerCase().indexOf(query) > -1) {

            matches[matches.length] = matched_group;

        }

    }

    return matches;

};

// Helper highlight function for the formatter

var autocompleteHighlightMatch = function (full, snippet, matchindex) {

    return full.substring(0, matchindex)

        + "<span class='match'>"

        + full.substr(matchindex, snippet.length)

        + "</span>" + full.substring(matchindex + snippet.length);

};

var gravatar = function(gravatar_lnk, size, cssclass) {

        return '<i class="icon-user {1}" style="font-size: {0}px;"></i>'.format(size, cssclass);

    }

    return '<img alt="" class="{2}" style="width: {0}px; height: {0}px" src="{1}"/>'.format(size, gravatar_lnk, cssclass);

}

var autocompleteGravatar = function(res, gravatar_lnk, size, group) {

    var elem;

    if (group !== undefined) {

        elem = '<i class="perm-gravatar-ac icon-users"></i>';

    } else {

        elem = gravatar(gravatar_lnk, size, "perm-gravatar-ac");

    }

    return '<div class="ac-container-wrap">{0}{1}</div>'.format(elem, res);

}

// Custom formatter to highlight the matching letters

var autocompleteFormatter = function (oResultData, sQuery, sResultMatch) {

    var query = sQuery.toLowerCase();

    // group

    if (oResultData.grname != undefined) {

        var grname = oResultData.grname;

        var grmembers = oResultData.grmembers;

        var grnameMatchIndex = grname.toLowerCase().indexOf(query);

          %if editable:

          <div class='ac'>

            <div class="reviewer_ac">

               ${h.text('user', class_='yui-ac-input',placeholder=_('Type name of reviewer to add'))}

               <div id="reviewers_container"></div>

            </div>

          </div>

          %endif

        </div>

        %if not c.pull_request_reviewers:

        <div class="pr-details-title">${_('Potential Reviewers')}</div>

        <div style="margin: 10px 0 10px 10px; max-width: 250px">

          <div>

            ${_('Click to add the repository owner as reviewer:')}

          </div>

          <ul style="margin-top: 10px">

            %for u in [c.pull_request.other_repo.user]:

              <li>

                <a class="missing_reviewer missing_reviewer_${u.user_id}"

                  user_id="${u.user_id}"

                  fname="${u.name}"

                  lname="${u.lastname}"

                  nname="${u.username}"

                  gravatar_size="14"

                  title="Click to add reviewer to the list, then Save Changes.">${u.full_name}</a>

              </li>

            %endfor

          </ul>

        </div>

        %endif

    </div>

    <div class="form" style="clear:both">

      <div class="fields">

        %if editable:

          <div class="buttons">

            ${h.submit('pr-form-save',_('Save Changes'),class_="btn btn-small")}

            ${h.submit('pr-form-clone',_('Save Updates as New Pull Request'),class_="btn btn-small",disabled='disabled')}

            ${h.reset('pr-form-reset',_('Cancel Changes'),class_="btn btn-small")}

          </div>

        %endif

      </div>

    </div>

  ${h.end_form()}

</div>

<div class="box">

    <div class="title">