import os

import re

import sys

import datetime

from django.conf import settings

from django.template import Template, Context, TemplateDoesNotExist

from django.utils.html import escape

from django.http import HttpResponse, HttpResponseServerError, HttpResponseNotFound

from django.utils.encoding import smart_unicode

HIDDEN_SETTINGS = re.compile('SECRET|PASSWORD|PROFANITIES_LIST')

def linebreak_iter(template_source):

    yield 0

    p = template_source.find('\n')

    while p >= 0:

        yield p+1

        p = template_source.find('\n', p+1)

    yield len(template_source) + 1

def get_template_exception_info(exc_type, exc_value, tb):

    origin, (start, end) = exc_value.source

    template_source = origin.reload()

    context_lines = 10

    line = 0

    upto = 0

    source_lines = []

    before = during = after = ""

    for num, next in enumerate(linebreak_iter(template_source)):

        if start >= upto and end <= next:

            line = num

            before = escape(template_source[upto:start])

            during = escape(template_source[start:end])

            after = escape(template_source[end:next])

        source_lines.append( (num, escape(template_source[upto:next])) )

        upto = next

    total = len(source_lines)

    top = max(1, line - context_lines)

    bottom = min(total, line + 1 + context_lines)

    template_info = {

        'message': exc_value.args[0],

        'source_lines': source_lines[top:bottom],

        'before': before,

        'during': during,

        'after': after,

        'top': top,

        'bottom': bottom,

        'total': total,

        'line': line,

        'name': origin.name,

    }

    exc_info = hasattr(exc_value, 'exc_info') and exc_value.exc_info or (exc_type, exc_value, tb)

    return exc_info + (template_info,)

def get_safe_settings():

    "Returns a dictionary of the settings module, with sensitive settings blurred out."

    settings_dict = {}

    for k in dir(settings):

        if k.isupper():

            if HIDDEN_SETTINGS.search(k):

                settings_dict[k] = '********************'

            else:

                settings_dict[k] = getattr(settings, k)

    return settings_dict

def technical_500_response(request, exc_type, exc_value, tb):

    """

    Create a technical server error response. The last three arguments are

    the values returned from sys.exc_info() and friends.

    """

    html = get_traceback_html(request, exc_type, exc_value, tb)

    return HttpResponseServerError(html, mimetype='text/html')

def get_traceback_html(request, exc_type, exc_value, tb):

    "Return HTML code for traceback."

    template_info = None

    template_does_not_exist = False

    loader_debug_info = None

    # Handle deprecated string exceptions

    if isinstance(exc_type, basestring):

        exc_value = Exception('Deprecated String Exception: %r' % exc_type)

        exc_type = type(exc_value)

    if issubclass(exc_type, TemplateDoesNotExist):

        from django.template.loader import template_source_loaders

        template_does_not_exist = True

        loader_debug_info = []

        for loader in template_source_loaders:

            try:

                source_list_func = getattr(__import__(loader.__module__, {}, {}, ['get_template_sources']), 'get_template_sources')

                # NOTE: This assumes exc_value is the name of the template that

                # the loader attempted to load.

                template_list = [{'name': t, 'exists': os.path.exists(t)} \

                    for t in source_list_func(str(exc_value))]

            except (ImportError, AttributeError):

                template_list = []

            loader_debug_info.append({

                'loader': loader.__module__ + '.' + loader.__name__,

                'templates': template_list,

            })

    if settings.TEMPLATE_DEBUG and hasattr(exc_value, 'source'):

        exc_type, exc_value, tb, template_info = get_template_exception_info(exc_type, exc_value, tb)

    frames = []

    while tb is not None:

        # support for __traceback_hide__ which is used by a few libraries

        # to hide internal frames.

        if tb.tb_frame.f_locals.get('__traceback_hide__'):

            tb = tb.tb_next

            continue

        filename = tb.tb_frame.f_code.co_filename

        function = tb.tb_frame.f_code.co_name

        lineno = tb.tb_lineno - 1

        loader = tb.tb_frame.f_globals.get('__loader__')

        module_name = tb.tb_frame.f_globals.get('__name__')

        pre_context_lineno, pre_context, context_line, post_context = _get_lines_from_file(filename, lineno, 7, loader, module_name)

        if pre_context_lineno is not None:

            frames.append({

                'tb': tb,

                'filename': filename,

                'function': function,

                'lineno': lineno + 1,

                'vars': tb.tb_frame.f_locals.items(),

                'id': id(tb),

                'pre_context': pre_context,

                'context_line': context_line,

                'post_context': post_context,

                'pre_context_lineno': pre_context_lineno + 1,

            })

        tb = tb.tb_next

    if not frames:

        frames = [{

            'filename': '<unknown>',

            'function': '?',

            'lineno': '?',

        }]

    unicode_hint = ''

    if issubclass(exc_type, UnicodeError):

        start = getattr(exc_value, 'start', None)

        end = getattr(exc_value, 'end', None)

        if start is not None and end is not None:

            unicode_str = exc_value.args[1]

            unicode_hint = smart_unicode(unicode_str[max(start-5, 0):min(end+5, len(unicode_str))], 'ascii', errors='replace')

    from django import get_version

    t = Template(TECHNICAL_500_TEMPLATE, name='Technical 500 template')

    c = Context({

        'exception_type': exc_type.__name__,

        'exception_value': smart_unicode(exc_value, errors='replace'),

        'unicode_hint': unicode_hint,

        'frames': frames,

        'lastframe': frames[-1],

        'request': request,

        'request_protocol': request.is_secure() and "https" or "http",

        'settings': get_safe_settings(),

        'sys_executable': sys.executable,

        'sys_version_info': '%d.%d.%d' % sys.version_info[0:3],

        'server_time': datetime.datetime.now(),

        'django_version_info': get_version(),

        'sys_path' : sys.path,

        'template_info': template_info,

        'template_does_not_exist': template_does_not_exist,

        'loader_debug_info': loader_debug_info,

    })

    return t.render(c)

def technical_404_response(request, exception):

    "Create a technical 404 error response. The exception should be the Http404."

    try:

        tried = exception.args[0]['tried']

    except (IndexError, TypeError):

        tried = []

    else:

        if not tried:

            # tried exists but is an empty list. The URLconf must've been empty.

            return empty_urlconf(request)

    t = Template(TECHNICAL_404_TEMPLATE, name='Technical 404 template')

    c = Context({

        'root_urlconf': settings.ROOT_URLCONF,

        'request_path': request.path[1:], # Trim leading slash

        'urlpatterns': tried,

        'reason': str(exception),

        'request': request,

        'request_protocol': request.is_secure() and "https" or "http",

        'settings': get_safe_settings(),

    })

    return HttpResponseNotFound(t.render(c), mimetype='text/html')

def empty_urlconf(request):

    "Create an empty URLconf 404 error response."

    t = Template(EMPTY_URLCONF_TEMPLATE, name='Empty URLConf template')

    c = Context({

        'project_name': settings.SETTINGS_MODULE.split('.')[0]

    })

    return HttpResponse(t.render(c), mimetype='text/html')

def _get_lines_from_file(filename, lineno, context_lines, loader=None, module_name=None):

    """

    Returns context_lines before and after lineno from file.

    Returns (pre_context_lineno, pre_context, context_line, post_context).

    """

    source = None

    if loader is not None and hasattr(loader, "get_source"):

        source = loader.get_source(module_name)

        if source is not None:

            source = source.splitlines()

    if source is None:

        try:

            f = open(filename)

            try:

                source = f.readlines()

            finally:

                f.close()

        except (OSError, IOError):

            pass

    if source is None:

        return None, [], None, []

    encoding = 'ascii'

    for line in source[:2]:

        # File coding may be specified. Match pattern from PEP-263

        # (http://www.python.org/dev/peps/pep-0263/)

        match = re.search(r'coding[:=]\s*([-\w.]+)', line)

        if match:

            encoding = match.group(1)

            break

    source = [unicode(sline, encoding, 'replace') for sline in source]

    lower_bound = max(0, lineno - context_lines)

    upper_bound = lineno + context_lines

    pre_context = [line.strip('\n') for line in source[lower_bound:lineno]]

    context_line = source[lineno].strip('\n')

    post_context = [line.strip('\n') for line in source[lineno+1:upper_bound]]

    return lower_bound, pre_context, context_line, post_context

#

# Templates are embedded in the file so that we know the error handler will

# always work even if the template loader is broken.

#

TECHNICAL_500_TEMPLATE = """

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html lang="en">

<head>

  <meta http-equiv="content-type" content="text/html; charset=utf-8">

  <meta name="robots" content="NONE,NOARCHIVE">

  <title>{{ exception_type }} at {{ request.path|escape }}</title>

  <style type="text/css">

    html * { padding:0; margin:0; }

    body * { padding:10px 20px; }

    body * * { padding:0; }

    body { font:small sans-serif; }

    body>div { border-bottom:1px solid #ddd; }

    h1 { font-weight:normal; }

    h2 { margin-bottom:.8em; }

    h2 span { font-size:80%; color:#666; font-weight:normal; }

    h3 { margin:1em 0 .5em 0; }

    h4 { margin:0 0 .5em 0; font-weight: normal; }

    table { border:1px solid #ccc; border-collapse: collapse; width:100%; background:white; }

    tbody td, tbody th { vertical-align:top; padding:2px 3px; }

    thead th { padding:1px 6px 1px 3px; background:#fefefe; text-align:left; font-weight:normal; font-size:11px; border:1px solid #ddd; }

    tbody th { width:12em; text-align:right; color:#666; padding-right:.5em; }

    table.vars { margin:5px 0 2px 40px; }

    table.vars td, table.req td { font-family:monospace; }

    table td.code { width:100%; }

    table td.code div { overflow:hidden; }

    table.source th { color:#666; }

    table.source td { font-family:monospace; white-space:pre; border-bottom:1px solid #eee; }

    ul.traceback { list-style-type:none; }

    ul.traceback li.frame { margin-bottom:1em; }

    div.context { margin: 10px 0; }

    div.context ol { padding-left:30px; margin:0 10px; list-style-position: inside; }

    div.context ol li { font-family:monospace; white-space:pre; color:#666; cursor:pointer; }

    div.context ol.context-line li { color:black; background-color:#ccc; }

    div.context ol.context-line li span { float: right; }

    div.commands { margin-left: 40px; }

    div.commands a { color:black; text-decoration:none; }

    #summary { background: #ffc; }

    #summary h2 { font-weight: normal; color: #666; }

    #explanation { background:#eee; }

    #template, #template-not-exist { background:#f6f6f6; }

    #template-not-exist ul { margin: 0 0 0 20px; }

    #unicode-hint { background:#eee; }

    #traceback { background:#eee; }

    #requestinfo { background:#f6f6f6; padding-left:120px; }

    #summary table { border:none; background:transparent; }

    #requestinfo h2, #requestinfo h3 { position:relative; margin-left:-100px; }

    #requestinfo h3 { margin-bottom:-1em; }

    .error { background: #ffc; }

    .specific { color:#cc3300; font-weight:bold; }

    h2 span.commands { font-size:.7em;}

    span.commands a:link {color:#5E5694;}

  </style>

  <script type="text/javascript">

  //<!--

    function getElementsByClassName(oElm, strTagName, strClassName){

        // Written by Jonathan Snook, http://www.snook.ca/jon; Add-ons by Robert Nyman, http://www.robertnyman.com

        var arrElements = (strTagName == "*" && document.all)? document.all :

        oElm.getElementsByTagName(strTagName);

        var arrReturnElements = new Array();

        strClassName = strClassName.replace(/\-/g, "\\-");

        var oRegExp = new RegExp("(^|\\s)" + strClassName + "(\\s|$)");

        var oElement;

        for(var i=0; i<arrElements.length; i++){

            oElement = arrElements[i];

            if(oRegExp.test(oElement.className)){

                arrReturnElements.push(oElement);

            }

        }

        return (arrReturnElements)

    }

    function hideAll(elems) {

      for (var e = 0; e < elems.length; e++) {

        elems[e].style.display = 'none';

      }

    }

    window.onload = function() {

      hideAll(getElementsByClassName(document, 'table', 'vars'));

      hideAll(getElementsByClassName(document, 'ol', 'pre-context'));

      hideAll(getElementsByClassName(document, 'ol', 'post-context'));

      hideAll(getElementsByClassName(document, 'div', 'pastebin'));

    }

    function toggle() {

      for (var i = 0; i < arguments.length; i++) {

        var e = document.getElementById(arguments[i]);

        if (e) {

          e.style.display = e.style.display == 'none' ? 'block' : 'none';

        }

      }

      return false;

    }

    function varToggle(link, id) {

      toggle('v' + id);

      var s = link.getElementsByTagName('span')[0];

      var uarr = String.fromCharCode(0x25b6);

      var darr = String.fromCharCode(0x25bc);

      s.innerHTML = s.innerHTML == uarr ? darr : uarr;

      return false;

    }

    function switchPastebinFriendly(link) {

      s1 = "Switch to copy-and-paste view";

      s2 = "Switch back to interactive view";

      link.innerHTML = link.innerHTML == s1 ? s2 : s1;

      toggle('browserTraceback', 'pastebinTraceback');

      return false;

    }

    //-->

  </script>

</head>

<body>

<div id="summary">

  <h1>{{ exception_type }} at {{ request.path|escape }}</h1>

  <h2>{{ exception_value|escape }}</h2>

  <table class="meta">

    <tr>

      <th>Request Method:</th>

      <td>{{ request.META.REQUEST_METHOD }}</td>

    </tr>

    <tr>

      <th>Request URL:</th>

      <td>{{ request_protocol }}://{{ request.META.HTTP_HOST }}{{ request.path|escape }}</td>

    </tr>

    <tr>

      <th>Exception Type:</th>

      <td>{{ exception_type }}</td>

    </tr>

    <tr>

      <th>Exception Value:</th>

      <td>{{ exception_value|escape }}</td>

    </tr>

    <tr>

      <th>Exception Location:</th>

      <td>{{ lastframe.filename|escape }} in {{ lastframe.function|escape }}, line {{ lastframe.lineno }}</td>

    </tr>

    <tr>

      <th>Python Executable:</th>

      <td>{{ sys_executable|escape }}</td>

    </tr>

    <tr>

      <th>Python Version:</th>

      <td>{{ sys_version_info }}</td>

    </tr>

    <tr>

      <th>Python Path:</th>

      <td>{{ sys_path }}</td>

    </tr>

    <tr>

      <th>Server time:</th>

      <td>{{server_time|date:"r"}}</td>

    </tr>

  </table>

</div>

{% if unicode_hint %}

<div id="unicode-hint">

    <h2>Unicode error hint</h2>

    <p>The string that could not be encoded/decoded was: <strong>{{ unicode_hint|escape }}</strong></p>

</div>

{% endif %}

{% if template_does_not_exist %}

<div id="template-not-exist">

    <h2>Template-loader postmortem</h2>

    {% if loader_debug_info %}

        <p>Django tried loading these templates, in this order:</p>

        <ul>

        {% for loader in loader_debug_info %}

            <li>Using loader <code>{{ loader.loader }}</code>:

                <ul>{% for t in loader.templates %}<li><code>{{ t.name }}</code> (File {% if t.exists %}exists{% else %}does not exist{% endif %})</li>{% endfor %}</ul>

            </li>

        {% endfor %}

        </ul>

    {% else %}

        <p>Django couldn't find any templates because your <code>TEMPLATE_LOADERS</code> setting is empty!</p>

    {% endif %}

</div>

{% endif %}

{% if template_info %}

<div id="template">

   <h2>Template error</h2>

   <p>In template <code>{{ template_info.name }}</code>, error at line <strong>{{ template_info.line }}</strong></p>

   <h3>{{ template_info.message }}</h3>

   <table class="source{% if template_info.top %} cut-top{% endif %}{% ifnotequal template_info.bottom template_info.total %} cut-bottom{% endifnotequal %}">

   {% for source_line in template_info.source_lines %}

   {% ifequal source_line.0 template_info.line %}

       <tr class="error"><th>{{ source_line.0 }}</th>

       <td>{{ template_info.before }}<span class="specific">{{ template_info.during }}</span>{{ template_info.after }}</td></tr>

   {% else %}

      <tr><th>{{ source_line.0 }}</th>

      <td>{{ source_line.1 }}</td></tr>

   {% endifequal %}

   {% endfor %}

   </table>

</div>

{% endif %}

<div id="traceback">

  <h2>Traceback <span class="commands"><a href="#" onclick="return switchPastebinFriendly(this);">Switch to copy-and-paste view</a></span></h2>

  {% autoescape off %}

  <div id="browserTraceback">

    <ul class="traceback">

      {% for frame in frames %}

        <li class="frame">

          <code>{{ frame.filename|escape }}</code> in <code>{{ frame.function|escape }}</code>

          {% if frame.context_line %}

            <div class="context" id="c{{ frame.id }}">

              {% if frame.pre_context %}

                <ol start="{{ frame.pre_context_lineno }}" class="pre-context" id="pre{{ frame.id }}">{% for line in frame.pre_context %}{% if line %}<li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')">{{ line|escape }}</li>{% endif %}{% endfor %}</ol>

              {% endif %}

              <ol start="{{ frame.lineno }}" class="context-line"><li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')">{{ frame.context_line|escape }} <span>...</span></li></ol>

              {% if frame.post_context %}

                <ol start='{{ frame.lineno|add:"1" }}' class="post-context" id="post{{ frame.id }}">{% for line in frame.post_context %}{% if line %}<li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')">{{ line|escape }}</li>{% endif %}{% endfor %}</ol>

              {% endif %}

            </div>

          {% endif %}

          {% if frame.vars %}

            <div class="commands">

                <a href="#" onclick="return varToggle(this, '{{ frame.id }}')"><span>&#x25b6;</span> Local vars</a>

            </div>

            <table class="vars" id="v{{ frame.id }}">

              <thead>

                <tr>

                  <th>Variable</th>

                  <th>Value</th>

                </tr>

              </thead>

              <tbody>

                {% for var in frame.vars|dictsort:"0" %}

                  <tr>

                    <td>{{ var.0|escape }}</td>

                    <td class="code"><div>{{ var.1|pprint|escape }}</div></td>

                  </tr>

                {% endfor %}

              </tbody>

            </table>

          {% endif %}

        </li>

      {% endfor %}

    </ul>

  </div>

  {% endautoescape %}

  <form action="http://dpaste.com/" name="pasteform" id="pasteform" method="post">

  <div id="pastebinTraceback" class="pastebin">

    <input type="hidden" name="language" value="PythonConsole">

    <input type="hidden" name="title" value="{{ exception_type|escape }} at {{ request.path|escape }}">

    <input type="hidden" name="source" value="Django Dpaste Agent">

    <input type="hidden" name="poster" value="Django">

    <textarea name="content" id="traceback_area" cols="140" rows="25">

Environment:

Request Method: {{ request.META.REQUEST_METHOD }}

Request URL: {{ request_protocol }}://{{ request.META.HTTP_HOST }}{{ request.path|escape }}

Django Version: {{ django_version_info }}

Python Version: {{ sys_version_info }}

Installed Applications:

{{ settings.INSTALLED_APPS|pprint }}

Installed Middleware:

{{ settings.MIDDLEWARE_CLASSES|pprint }}

{% if template_does_not_exist %}Template Loader Error:

{% if loader_debug_info %}Django tried loading these templates, in this order:

{% for loader in loader_debug_info %}Using loader {{ loader.loader }}:

{% for t in loader.templates %}{{ t.name }} (File {% if t.exists %}exists{% else %}does not exist{% endif %})

{% endfor %}{% endfor %}

{% else %}Django couldn't find any templates because your TEMPLATE_LOADERS setting is empty!

{% endif %}

{% endif %}{% if template_info %}

Template error:

In template {{ template_info.name }}, error at line {{ template_info.line }}

   {{ template_info.message }}{% for source_line in template_info.source_lines %}{% ifequal source_line.0 template_info.line %}

   {{ source_line.0 }} : {{ template_info.before }} {{ template_info.during }} {{ template_info.after }}

{% else %}

   {{ source_line.0 }} : {{ source_line.1 }}

{% endifequal %}{% endfor %}{% endif %}

Traceback:

{% for frame in frames %}File "{{ frame.filename|escape }}" in {{ frame.function|escape }}

{% if frame.context_line %}  {{ frame.lineno }}. {{ frame.context_line|escape }}{% endif %}

{% endfor %}

Exception Type: {{ exception_type|escape }} at {{ request.path|escape }}

Exception Value: {{ exception_value|escape }}

</textarea>

  <br><br>