"""

import logging

import traceback

import formencode.htmlfill

from sqlalchemy.sql.expression import or_

from tg import request, response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPForbidden, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired

from kallithea.lib.base import BaseController, jsonify, render

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int, safe_unicode, time_to_datetime

from kallithea.lib.vcs.exceptions import NodeNotChangedError, VCSError

from kallithea.model.db import Gist

from kallithea.model.forms import GistForm

from kallithea.model.gist import GistModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class GistsController(BaseController):

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

    def __load_defaults(self, extra_values=None):

        c.lifetime_values = [

            (str(-1), _('Forever')),

            (str(5), _('5 minutes')),

            (str(60), _('1 hour')),

            (str(60 * 24), _('1 day')),

            (str(60 * 24 * 30), _('1 month')),

        ]

        if extra_values:

            c.lifetime_values.append(extra_values)

        c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]

    @LoginRequired(allow_default_user=True)

    def index(self):

        not_default_user = not request.authuser.is_default_user

        c.show_private = request.GET.get('private') and not_default_user

        c.show_public = request.GET.get('public') and not_default_user

        gists = Gist().query() \

            .filter_by(is_expired=False) \

            .order_by(Gist.created_on.desc())

        # MY private

        if c.show_private and not c.show_public:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE) \

                             .filter(Gist.owner_id == request.authuser.user_id)

        # MY public

        elif c.show_public and not c.show_private:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC) \

                             .filter(Gist.owner_id == request.authuser.user_id)

        # MY public+private

        elif c.show_private and c.show_public:

            gists = gists.filter(or_(Gist.gist_type == Gist.GIST_PUBLIC,

                                     Gist.gist_type == Gist.GIST_PRIVATE)) \

                             .filter(Gist.owner_id == request.authuser.user_id)

        # default show ALL public gists

        if not c.show_public and not c.show_private:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)

        c.gists = gists

        p = safe_int(request.GET.get('page'), 1)

        return render('admin/gists/index.html')

    @LoginRequired()

    def create(self):

        self.__load_defaults()

        gist_form = GistForm([x[0] for x in c.lifetime_values])()

        try:

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

            # TODO: multiple files support, from the form

            filename = form_result['filename'] or Gist.DEFAULT_FILENAME

            nodes = {

                filename: {

                    'content': form_result['content'],

                    'lexer': form_result['mimetype']  # None is autodetect

                }

            }

            _public = form_result['public']

            gist_type = Gist.GIST_PUBLIC if _public else Gist.GIST_PRIVATE

            gist = GistModel().create(

                description=form_result['description'],

                owner=request.authuser.user_id,

                ip_addr=request.ip_addr,

                gist_mapping=nodes,

                gist_type=gist_type,

                lifetime=form_result['lifetime']

            )

            Session().commit()

            new_gist_id = gist.gist_access_id

        except formencode.Invalid as errors:

            defaults = errors.value

            return formencode.htmlfill.render(

                render('admin/gists/new.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception as e:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during gist creation'), category='error')

            raise HTTPFound(location=url('new_gist'))

        raise HTTPFound(location=url('gist', gist_id=new_gist_id))

    @LoginRequired()

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

        self.__load_defaults()

        if rev and selected is None:

            selected = 'rev:%s:%s' % (rev, rev)

            specials = [(selected, '%s: %s' % (_("Changeset"), rev[:12]))]

        # prio 3: most recent peer branch

        if peers and not selected:

            selected = peers[0][0]

        # prio 4: tip revision

        if not selected:

            if h.is_hg(repo):

                if tipbranch:

                    selected = 'branch:%s:%s' % (tipbranch, tiprev)

                else:

                    selected = 'tag:null:' + repo.EMPTY_CHANGESET

                    tags.append((selected, 'null'))

            else:

                if 'master' in repo.branches:

                    selected = 'branch:master:%s' % repo.branches['master']

                else:

                    k, v = repo.branches.items()[0]

                    selected = 'branch:%s:%s' % (k, v)

        groups = [(specials, _("Special")),

                  (peers, _("Peer branches")),

                  (bookmarks, _("Bookmarks")),

                  (branches, _("Branches")),

                  (tags, _("Tags")),

                  ]

        return [g for g in groups if g[0]], selected

    def _is_allowed_to_change_status(self, pull_request):

        if pull_request.is_closed():

            return False

        owner = request.authuser.user_id == pull_request.owner_id

        reviewer = PullRequestReviewer.query() \

            .filter(PullRequestReviewer.pull_request == pull_request) \

            .filter(PullRequestReviewer.user_id == request.authuser.user_id) \

            .count() != 0

        return request.authuser.admin or owner or reviewer

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def show_all(self, repo_name):

        c.from_ = request.GET.get('from_') or ''

        c.closed = request.GET.get('closed') or ''

        p = safe_int(request.GET.get('page'), 1)

        q = PullRequest.query(include_closed=c.closed, sorted=True)

        if c.from_:

            q = q.filter_by(org_repo=c.db_repo)

        else:

            q = q.filter_by(other_repo=c.db_repo)

        c.pull_requests = q.all()

        return render('/pullrequests/pullrequest_show_all.html')

    @LoginRequired()

    def show_my(self):

        c.closed = request.GET.get('closed') or ''

        c.my_pull_requests = PullRequest.query(

            include_closed=c.closed,

            sorted=True,

        ).filter_by(owner_id=request.authuser.user_id).all()

        c.participate_in_pull_requests = []

        c.participate_in_pull_requests_todo = []

        done_status = set([ChangesetStatus.STATUS_APPROVED, ChangesetStatus.STATUS_REJECTED])

        for pr in PullRequest.query(

            include_closed=c.closed,

            reviewer_id=request.authuser.user_id,

            sorted=True,

        ):

            status = pr.user_review_status(request.authuser.user_id) # very inefficient!!!

            if status in done_status:

                c.participate_in_pull_requests.append(pr)

            else:

                c.participate_in_pull_requests_todo.append(pr)

        return render('/pullrequests/pullrequest_show_my.html')

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    def index(self):

        org_repo = c.db_repo

        org_scm_instance = org_repo.scm_instance

        try:

            org_scm_instance.get_changeset()

        except EmptyRepositoryError as e:

            h.flash(_('There are no changesets yet'),

                    category='warning')

            raise HTTPFound(location=url('summary_home', repo_name=org_repo.repo_name))

        org_rev = request.GET.get('rev_end')

        # rev_start is not directly useful - its parent could however be used

        # as default for other and thus give a simple compare view

        rev_start = request.GET.get('rev_start')

        other_rev = None

        if rev_start:

            starters = org_repo.get_changeset(rev_start).parents

            if starters:

        ${_('Private Gists for User %s') % request.authuser.username}

    %elif c.show_public:

        ${_('Public Gists for User %s') % request.authuser.username}

    %else:

        ${_('Public Gists')}

    %endif

    - ${c.gists_pager.item_count}

</%def>

<%block name="header_menu">

    ${self.menu('gists')}

</%block>

<%def name="main()">

<div class="panel panel-primary">

    <div class="panel-heading clearfix">

        <div class="pull-left">

            ${self.breadcrumbs()}

        </div>

        %if request.authuser.username != 'default':

        <div class="pull-right">

             <a href="${h.url('new_gist')}" class="btn btn-success btn-xs"><i class="icon-plus"></i>${_('Create New Gist')}</a>

        </div>

        %endif

    </div>

    <div class="panel-body">

      %if c.gists_pager.item_count>0:

        % for gist in c.gists_pager:

          <div class="gist-item clearfix">

            ${h.gravatar_div(gist.owner.email, size=28)}

            <span title="${gist.owner.full_contact}" class="user">

                <b>${h.person(gist.owner.full_contact)}</b> /

                <b><a href="${h.url('gist',gist_id=gist.gist_access_id)}">gist: ${gist.gist_access_id}</a></b>

            </span>

            <div>

                ${_('Created')} ${h.age(gist.created_on)} /

                <span class="text-muted">

                  %if gist.gist_expires == -1:

                   ${_('Expires')}: ${_('Never')}

                  %else:

                   ${_('Expires')}: ${h.age(h.time_to_datetime(gist.gist_expires))}

                  %endif

                </span>

            </div>

            <div class="text-muted">${gist.gist_description}</div>

          </div>

        % endfor

      %else:

        <div>${_('There are no gists yet')}</div>

      %endif

    </div>

</div>

</%def>

        ${h.urlify_text(pr.title or _("(no title)"), pr.org_repo.repo_name, pr.url())}

        %if pr.is_closed():

          <span class="pr-closed-tag">${_('Closed')}</span>

        %endif

        </a>

      </td>

      <td>

        ${pr.owner.full_name_and_username}

      </td>

      <td>

        <span data-toggle="tooltip" title="${h.fmt_date(pr.created_on)}">

          ${h.age(pr.created_on)}

        </span>

      </td>

      <td>

        <% org_ref_name=pr.org_ref.rsplit(':', 2)[-2] %>

        <a href="${h.url('summary_home', repo_name=pr.org_repo.repo_name, anchor=org_ref_name)}">

          ${pr.org_repo.repo_name}#${org_ref_name}

        </a>

      </td>

      <td>

        <% other_ref_name=pr.other_ref.rsplit(':', 2)[-2] %>

        <a href="${h.url('summary_home', repo_name=pr.other_repo.repo_name, anchor=other_ref_name)}">

          ${pr.other_repo.repo_name}#${other_ref_name}

        </a>

      </td>

      <td>

        %if pr.owner_id == request.authuser.user_id:

          ${h.form(url('pullrequest_delete', repo_name=pr.other_repo.repo_name, pull_request_id=pr.pull_request_id))}

          <button type="submit" class="btn btn-link btn-xs"

                  id="remove_${pr.pull_request_id}"

                  name="remove_${pr.pull_request_id}"

                  title="${_('Delete Pull Request')}"

                  onclick="return confirm('${_('Confirm to delete this pull request')}')

                      && ((${len(pr.comments)} == 0) ||

                          confirm('${_('Confirm again to delete this pull request with %s comments') % len(pr.comments)}'))

                      ">

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

          </button>

          ${h.end_form()}

        %endif

      </td>

    </tr>

% endfor

  </table>

</div>

%if hasattr(pullrequests, 'pager'):

%endif

</%def>