from pylons.error import handle_mako_error

from pylons_app.config.routing import make_map

from pylons_app.lib.auth import set_available_permissions, set_base_path

from pylons_app.lib.utils import repo2db_mapper, make_ui, set_hg_app_config

from pylons_app.model import init_model

from pylons_app.model.hg_model import _get_repos_cached_initial

from sqlalchemy import engine_from_config

import logging

import os

import pylons_app.lib.app_globals as app_globals

import pylons_app.lib.helpers

log = logging.getLogger(__name__)

def load_environment(global_conf, app_conf, initial=False):

    """Configure the Pylons environment via the ``pylons.config``

    object

    """

    config = PylonsConfig()

    # Pylons paths

    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

    paths = dict(root=root,

                 controllers=os.path.join(root, 'controllers'),

                 static_files=os.path.join(root, 'public'),

                 templates=[os.path.join(root, 'templates')])

    # Initialize config with the basic options

    config.init_app(global_conf, app_conf, package='pylons_app', paths=paths)

    config['routes.map'] = make_map(config)

    config['pylons.app_globals'] = app_globals.Globals(config)

    config['pylons.h'] = pylons_app.lib.helpers

    # Setup cache object as early as possible

    import pylons

    pylons.cache._push_object(config['pylons.app_globals'].cache)

    # Create the Mako TemplateLookup, with the default auto-escaping

    config['pylons.app_globals'].mako_lookup = TemplateLookup(

        directories=paths['templates'],

        error_handler=handle_mako_error,

        module_directory=os.path.join(app_conf['cache_dir'], 'templates'),

        input_encoding='utf-8', default_filters=['escape'],

        imports=['from webhelpers.html import escape'])

    #sets the c attribute access when don't existing attribute are accessed

    config['pylons.strict_tmpl_context'] = True

    #MULTIPLE DB configs

    # Setup the SQLAlchemy database engine

        #use query time debugging.

        from pylons_app.lib.timerproxy import TimerProxy

        sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.',

                                                            proxy=TimerProxy())

    else:

        sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.')

    init_model(sa_engine_db1)

    #init baseui

    config['pylons.app_globals'].baseui = make_ui('db')

    repo2db_mapper(_get_repos_cached_initial(config['pylons.app_globals'], initial))

    set_available_permissions(config)

    set_base_path(config)

    set_hg_app_config(config)

    # CONFIGURATION OPTIONS HERE (note: all config options will override

    # any Pylons config options)

    return config

        super(ChangesetController, self).__before__()

    def index(self, revision):

        hg_model = HgModel()

        try:

            c.changeset = hg_model.get_repo(c.repo_name).get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

            return redirect(url('hg_home'))

        else:

            try:

                c.changeset_old = c.changeset.parents[0]

            except IndexError:

                c.changeset_old = None

            c.changes = []

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '')

                if filenode_old.is_binary or node.is_binary:

                    diff = 'binary file'

                else:    

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).as_html()

                cs1 = None

                cs2 = node.last_changeset.raw_id                                        

                c.changes.append(('added', node, diff, cs1, cs2))

            for node in c.changeset.changed:

                filenode_old = c.changeset_old.get_node(node.path)

                if filenode_old.is_binary or node.is_binary:

                    diff = 'binary file'

                else:    

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).as_html()

                cs1 = filenode_old.last_changeset.raw_id

                cs2 = node.last_changeset.raw_id                    

                c.changes.append(('changed', node, diff, cs1, cs2))

            for node in c.changeset.removed:

                c.changes.append(('removed', node, None, None, None))            

        return render('changeset/changeset.html')

    def raw_changeset(self,revision):

        hg_model = HgModel()

        try:

            c.changeset = hg_model.get_repo(c.repo_name).get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

            return redirect(url('hg_home'))

        else:

            try:

                c.changeset_old = c.changeset.parents[0]

            except IndexError:

                c.changeset_old = None

            c.changes = []

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '')

                if filenode_old.is_binary or node.is_binary:

                    diff = 'binary file'

                else:    

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).raw_diff()

                cs1 = None

                cs2 = node.last_changeset.raw_id                                        

                c.changes.append(('added', node, diff, cs1, cs2))

            for node in c.changeset.changed:

                filenode_old = c.changeset_old.get_node(node.path)

                if filenode_old.is_binary or node.is_binary:

                    diff = 'binary file'

                else:    

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).raw_diff()

                cs1 = filenode_old.last_changeset.raw_id

                cs2 = node.last_changeset.raw_id                    

                c.changes.append(('changed', node, diff, cs1, cs2))      

        response.content_type = 'text/plain'

        parent = True if len(c.changeset.parents) > 0 else False

        c.parent_tmpl = 'Parent  %s' % c.changeset.parents[0]._hex if parent else ''

        c.diffs = ''

        for x in c.changes:

            c.diffs += x[2]

        return render('changeset/raw_changeset.html')

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('Changeset')}

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(u'Home',h.url('/'))}

    »

    ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}

    »

    ${_('Changeset')} - r${c.changeset.revision}:${c.changeset.raw_id}

</%def>

<%def name="page_nav()">

    ${self.menu('changelog')}     

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <div class="table">

    <div id="changeset_content">

		<div class="container">

			<div class="left">

				<div class="date">${_('Date')}: ${c.changeset.date}</div>

				<div class="author">${_('Author')}: ${c.changeset.author}</div>

				<div class="message">${h.wrap_paragraphs(c.changeset.message)}</div>

			</div>	

			<div class="right">

				<span class="logtags">

					<span class="branchtag">${c.changeset.branch}</span>

					%for tag in c.changeset.tags:

						<span class="tagtag">${tag}</span>

					%endfor

				</span>					

				%if len(c.changeset.parents)>1:

				<div class="merge">		

				${_('merge')}

				<img alt="merge" src="/images/icons/arrow_join.png">

				</div>

				%endif						

				%for p_cs in reversed(c.changeset.parents):

					<div class="parent">${_('Parent')} ${p_cs.revision}: ${h.link_to(p_cs.raw_id,

						h.url('changeset_home',repo_name=c.repo_name,revision=p_cs.raw_id),title=p_cs.message)}

					</div>

				%endfor								

			</div>		

		</div>

		<span style="font-size:1.1em;font-weight: bold">${_('Files affected')}</span>

	    <div class="cs_files">

				%for change,filenode,diff,cs1,cs2 in c.changes:

					<div class="cs_${change}">${h.link_to(filenode.path,h.url.current(anchor='CHANGE-%s'%filenode.path))}</div>

				%endfor

		</div>		    

    </div>

	%for change,filenode,diff,cs1,cs2 in c.changes:

		%if change !='removed':

		<div style="clear:both;height:10px"></div>

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

			<div id="${'CHANGE-%s'%filenode.path}" class="code-header">

				<div>

					<span>

						${h.link_to_if(change!='removed',filenode.path,h.url('files_home',repo_name=c.repo_name,

						revision=filenode.changeset.raw_id,f_path=filenode.path))}

					</span>

					%if 1:

					&raquo; <span>${h.link_to(_('diff'),

					h.url('files_diff_home',repo_name=c.repo_name,f_path=filenode.path,diff2=cs2,diff1=cs1,diff='diff'))}</span>

# HG changeset patch

# Date ${"%d %d" % c.changeset._ctx.date()}

# Node ID ${c.changeset._hex}

# ${c.parent_tmpl}

${c.changeset.message}

${c.diffs|n}

"""Pylons application test package

This package assumes the Pylons environment is already loaded, such as

when this script is imported from the `nosetests --with-pylons=test.ini`

command.

This module initializes the application via ``websetup`` (`paster

setup-app`) and provides the base testing objects.

"""

from unittest import TestCase

from paste.deploy import loadapp

from paste.script.appinstall import SetupCommand

from pylons import config, url

from routes.util import URLGenerator

from webtest import TestApp

import os

from pylons_app.model import meta

import pylons.test

__all__ = ['environ', 'url', 'TestController']

# Invoke websetup with the current config file

SetupCommand('setup-app').run([pylons.test.pylonsapp.config['__file__']])

environ = {}

class TestController(TestCase):

    def __init__(self, *args, **kwargs):

        wsgiapp = pylons.test.pylonsapp

        config = wsgiapp.config

        self.app = TestApp(wsgiapp)

        url._push_object(URLGenerator(config['routes.map'], environ))

        self.sa = meta.Session

        TestCase.__init__(self, *args, **kwargs)

    def log_user(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_admin',

                                  'password':'test'})

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        assert response.session['hg_app_user'].username == 'test_admin', 'wrong logged in user'

        return response.follow()        

from pylons_app.tests import *

class TestSearchController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='search', action='index'))

        print response.body

        assert 'class="small" id="q" name="q" type="text"' in response.body,'Search box content error'

        # Test response...

    def test_empty_search(self):

        self.log_user()

"""Setup the pylons_app application"""

from os.path import dirname as dn, join as jn

from pylons_app.config.environment import load_environment

from pylons_app.lib.db_manage import DbManage

import datetime

from time import mktime

import logging

import os

import sys

log = logging.getLogger(__name__)

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

sys.path.append(ROOT)

def setup_app(command, conf, vars):

    """Place any commands to setup pylons_app here"""

    log_sql = True

    tests = False

    dbname = os.path.split(conf['sqlalchemy.db1.url'])[-1]

    filename = os.path.split(conf.filename)[-1]

    if filename == 'tests.ini':

        uniq_suffix = str(int(mktime(datetime.datetime.now().timetuple())))

        REPO_TEST_PATH = '/tmp/hg_app_test_%s' % uniq_suffix

        if not os.path.isdir(REPO_TEST_PATH):

            os.mkdir(REPO_TEST_PATH)

        tests = True    

    dbmanage = DbManage(log_sql, dbname, tests)

    dbmanage.create_tables(override=True)

    dbmanage.config_prompt(REPO_TEST_PATH)

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    load_environment(conf.global_conf, conf.local_conf, initial=True)