# -*- coding: utf-8 -*-
from __future__ import absolute_import

from typing import Any, Dict, Iterable
import logging

from django.conf import settings
from django.test import override_settings
from django.template import Template, Context
from django.template.loader import get_template

from zerver.models import get_user_profile_by_email
from zerver.lib.test_helpers import get_all_templates, ZulipTestCase

class get_form_value(object):
    def __init__(self, value):
        # type: (Any) -> None
        self._value = value

    def value(self):
        # type: () -> Any
        return self._value


class DummyForm(dict):
    pass


class TemplateTestCase(ZulipTestCase):
    """
    Tests that backend template rendering doesn't crash.

    This renders all the Zulip backend templates, passing dummy data
    as the context, which allows us to verify whether any of the
    templates are broken enough to not render at all (no verification
    is done that the output looks right).  Please see `get_context`
    function documentation for more information.
    """
    @override_settings(TERMS_OF_SERVICE=None)
    def test_templates(self):
        # type: () -> None

        # Just add the templates whose context has a conflict with other
        # templates' context in `defer`.
        defer = ['analytics/activity.html']
        skip = defer + ['tests/test_markdown.html', 'zerver/terms.html']
        templates = [t for t in get_all_templates() if t not in skip]
        self.render_templates(templates, self.get_context())

        # Test the deferred templates with updated context.
        update = {'data': [('one', 'two')]}
        self.render_templates(defer, self.get_context(**update))

    def render_templates(self, templates, context):
        # type: (Iterable[Template], Dict[str, Any]) -> None
        for template in templates:
            template = get_template(template)
            try:
                template.render(context)
            except Exception:
                logging.error("Exception while rendering '{}'".format(template.template.name))
                raise

    def get_context(self, **kwargs):
        # type: (**Any) -> Dict[str, Any]
        """Get the dummy context for shallow testing.

        The context returned will always contain a parameter called
        `shallow_tested`, which tells the signal receiver that the
        test was not rendered in an actual logical test (so we can
        still do coverage reporting on which templates have a logical
        test).

        Note: `context` just holds dummy values used to make the test
        pass. This context only ensures that the templates do not
        throw a 500 error when rendered using dummy data.  If new
        required parameters are added to a template, this test will
        fail; the usual fix is to just update the context below to add
        the new parameter to the dummy data.

        :param kwargs: Keyword arguments can be used to update the base
            context.

        """
        email = "hamlet@zulip.com"
        user_profile = get_user_profile_by_email(email)

        context = dict(
            shallow_tested=True,
            user_profile=user_profile,
            user=user_profile,
            product_name='testing',
            form=DummyForm(
                full_name=get_form_value('John Doe'),
                terms=get_form_value(True),
                email=get_form_value(email),
            ),
            current_url=lambda: 'www.zulip.com',
            integrations_dict={},
            referrer=dict(
                full_name='John Doe',
                realm=dict(name='zulip.com'),
            ),
            uid='uid',
            token='token',
            message_count=0,
            messages=[dict(header='Header')],
            new_streams=dict(html=''),
            data=dict(title='Title'),
        )

        context.update(kwargs)
        return context

    def test_markdown_in_template(self):
        # type: () -> None
        template = get_template("tests/test_markdown.html")
        context = {
            'markdown_test_file': "zerver/tests/markdown/test_markdown.md"
        }
        content = template.render(context)

        content_sans_whitespace = content.replace(" ", "").replace('\n', '')
        self.assertEqual(content_sans_whitespace,
                         'header<h1>Hello!</h1><p>Thisissome<em>boldtext</em>.</p>footer')

    def test_custom_tos_template(self):
        # type: () -> None
        response = self.client_get("/terms/")
        self.assertEqual(response.status_code, 200)
        self.assert_in_response(u"Thanks for using our products and services (\"Services\"). ", response)
        self.assert_in_response(u"By using our Services, you are agreeing to these terms", response)