"""The base Controller API

Provides the BaseController class for subclassing.

"""

import logging

import time

import traceback

from paste.auth.basic import AuthBasicAuthenticator

from paste.httpexceptions import HTTPUnauthorized, HTTPForbidden

from paste.httpheaders import WWW_AUTHENTICATE, AUTHORIZATION

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

from pylons.controllers import WSGIController

from pylons.controllers.util import redirect

from pylons.templating import render_mako as render

from rhodecode import __version__, BACKENDS

from rhodecode.lib.utils2 import str2bool, safe_unicode, AttributeDict,\

    safe_str, safe_int

from rhodecode.lib.auth import AuthUser, get_container_username, authfunc,\

    HasPermissionAnyMiddleware, CookieStoreWrapper

from rhodecode.lib.utils import get_repo_slug

from rhodecode.model import meta

from rhodecode.model.db import Repository, RhodeCodeUi, User, RhodeCodeSetting

from rhodecode.model.notification import NotificationModel

from rhodecode.model.scm import ScmModel

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

def _filter_proxy(ip):

    """

    client, and each successive proxy that passed the request adding the IP

    address where it received the request from.

    :param ip:

    """

    if ',' in ip:

        _ips = ip.split(',')

        _first_ip = _ips[0].strip()

        log.debug('Got multiple IPs %s, using %s' % (','.join(_ips), _first_ip))

        return _first_ip

    return ip

def _get_ip_addr(environ):

    proxy_key = 'HTTP_X_REAL_IP'

    proxy_key2 = 'HTTP_X_FORWARDED_FOR'

    def_key = 'REMOTE_ADDR'

    ip = environ.get(proxy_key)

    if ip:

        return _filter_proxy(ip)

    ip = environ.get(proxy_key2)

    if ip:

        return _filter_proxy(ip)

    ip = environ.get(def_key, '0.0.0.0')

    return _filter_proxy(ip)

def _get_access_path(environ):

    path = environ.get('PATH_INFO')

    org_req = environ.get('pylons.original_request')

    if org_req:

        path = org_req.environ.get('PATH_INFO')

    return path

class BasicAuth(AuthBasicAuthenticator):

    def __init__(self, realm, authfunc, auth_http_code=None):

        self.realm = realm

        self.authfunc = authfunc

        self._rc_auth_http_code = auth_http_code

    def build_authentication(self):

        head = WWW_AUTHENTICATE.tuples('Basic realm="%s"' % self.realm)

        if self._rc_auth_http_code and self._rc_auth_http_code == '403':

"""

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

from __future__ import with_statement

import os

import sys

import logging

from rhodecode.model.scm import ScmModel

from rhodecode.lib.utils import BasePasterCommand, repo2db_mapper

# fix rhodecode import

from os.path import dirname as dn

rc_path = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(rc_path)

log = logging.getLogger(__name__)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Rescan default location for new repositories"

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        rm_obsolete = self.options.delete_obsolete

        log.info('Now scanning root location for new repos...')

        added, removed = repo2db_mapper(ScmModel().repo_scan(),

                                        remove_obsolete=rm_obsolete)

    def update_parser(self):

        self.parser.add_option('--delete-obsolete',

                          action='store_true',

                          help="Use this flag do delete repositories that are "

                          "present in RhodeCode database but not on the filesystem",

                          )

import re

import os

import time

import datetime

from subprocess import Popen, PIPE

from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.utils.paths import abspath

ALIASES = ['hg', 'git']

def get_scm(path, search_up=False, explicit_alias=None):

    """

    Returns one of alias from ``ALIASES`` (in order of precedence same as

    shortcuts given in ``ALIASES``) and top working dir path for the given

    argument. If no scm-specific directory is found or more than one scm is

    found at that directory, ``VCSError`` is raised.

    :param search_up: if set to ``True``, this function would try to

      move up to parent directory every time no scm is recognized for the

      currently checked path. Default: ``False``.

    :param explicit_alias: can be one of available backend aliases, when given

      it will return given explicit alias in repositories under more than one

      version control, if explicit_alias is different than found it will raise

      VCSError

    """

    if not os.path.isdir(path):

        raise VCSError("Given path %s is not a directory" % path)

    def get_scms(path):

        return [(scm, path) for scm in get_scms_for_path(path)]

    found_scms = get_scms(path)

    while not found_scms and search_up:

        newpath = abspath(path, '..')

        if newpath == path:

            break

        path = newpath

        found_scms = get_scms(path)

    if len(found_scms) > 1:

        for scm in found_scms:

            if scm[0] == explicit_alias:

                return scm

        raise VCSError('More than one [%s] scm found at given path %s'

    if len(found_scms) is 0:

        raise VCSError('No scm found at given path %s' % path)

    return found_scms[0]

def get_scms_for_path(path):

    """

    Returns all scm's found at the given path. If no scm is recognized

    - empty list is returned.

    :param path: path to directory which should be checked. May be callable.

    :raises VCSError: if given ``path`` is not a directory

    """

    from rhodecode.lib.vcs.backends import get_backend

    if hasattr(path, '__call__'):

        path = path()

    if not os.path.isdir(path):

        raise VCSError("Given path %r is not a directory" % path)

    result = []

    for key in ALIASES:

        dirname = os.path.join(path, '.' + key)

        if os.path.isdir(dirname):

            result.append(key)

            continue

        dirname = os.path.join(path, 'rm__.' + key)

        if os.path.isdir(dirname):

            return result

        # We still need to check if it's not bare repository as

        # bare repos don't have working directories

        try:

            get_backend(key)(path)

            result.append(key)

            continue

        except RepositoryError:

            # Wrong backend

            pass

        except VCSError:

            # No backend at all

            pass

    return result

def run_command(cmd, *args):

    """

</%def>

<%def name="page_nav()">

    ${self.menu('repositories')}

</%def>

<%def name="main()">

${self.context_bar('showpullrequest')}

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <h3 class="${'closed' if c.pull_request.is_closed() else ''}">

        <img src="${h.url('/images/icons/flag_status_%s.png' % str(c.pull_request.last_review_status))}" />

        ${_('Title')}: ${c.pull_request.title}

        %if c.pull_request.is_closed():

            (${_('Closed')})

        %endif

    </h3>

    <div class="form">

      <div id="summary" class="fields">

         <div class="field">

          <div class="label-summary">

              <label>${_('Review status')}:</label>

          </div>

          <div class="input">

            <div class="changeset-status-container" style="float:none;clear:both">

            %if c.current_changeset_status:

              <div title="${_('Pull request status')}" class="changeset-status-lbl">

                %if c.pull_request.is_closed():

                    ${_('Closed')},

                %endif

                ${h.changeset_status_lbl(c.current_changeset_status)}

              </div>

              <div class="changeset-status-ico" style="padding:1px 4px"><img src="${h.url('/images/icons/flag_status_%s.png' % c.current_changeset_status)}" /></div>

            %endif

            </div>

          </div>

         </div>

         <div class="field">

          <div class="label-summary">

              <label>${_('Still not reviewed by')}:</label>

          </div>

          <div class="input">

            % if len(c.pull_request_pending_reviewers) > 0:

            %else:

                <div>${_('Pull request was reviewed by all reviewers')}</div>

            %endif

          </div>

         </div>

         <div class="field">

          <div class="label-summary">

              <label>${_('Origin repository')}:</label>

          </div>

          <div class="input">

              <div>

             ##%if h.is_hg(c.pull_request.org_repo):

             ##  <img class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="${h.url('/images/icons/hgicon.png')}"/>

             ##%elif h.is_git(c.pull_request.org_repo):

             ##  <img class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="${h.url('/images/icons/giticon.png')}"/>

             ##%endif

              <span class="spantag">${c.pull_request.org_ref_parts[0]}: ${c.pull_request.org_ref_parts[1]}</span>

              <span><a href="${h.url('summary_home', repo_name=c.pull_request.org_repo.repo_name)}">${c.pull_request.org_repo.clone_url()}</a></span>

              </div>

          </div>

         </div>

         <div class="field">

          <div class="label-summary">

              <label>${_('Description')}:</label>

          </div>

          <div class="input">

              <div style="white-space:pre-wrap">${h.literal(c.pull_request.description)}</div>

          </div>

         </div>

         <div class="field">

          <div class="label-summary">

              <label>${_('Created on')}:</label>

          </div>

          <div class="input">

              <div>${h.fmt_date(c.pull_request.created_on)}</div>

          </div>

         </div>

      </div>

    </div>

    <div style="overflow: auto;">

      ##DIFF

      <div class="table" style="float:left;clear:none">

          <div id="body" class="diffblock">

              <div style="white-space:pre-wrap;padding:5px">${_('Compare view')}</div>

          </div>

          <div id="changeset_compare_view_content">

              ##CS