# -*- coding: utf-8; -*-

from unittest.mock import patch

import colander

from wuttaweb.views import common as mod
from tests.util import WebTestCase


class TestCommonView(WebTestCase):

    def make_view(self):
        return mod.CommonView(self.request)

    def test_includeme(self):
        self.pyramid_config.include('wuttaweb.views.common')

    def test_forbidden_view(self):
        view = self.make_view()
        context = view.forbidden_view()
        self.assertEqual(context['index_title'], self.app.get_title())

    def test_notfound_view(self):
        view = self.make_view()
        context = view.notfound_view()
        self.assertEqual(context['index_title'], self.app.get_title())

    def test_home(self):
        self.pyramid_config.add_route('setup', '/setup')
        self.pyramid_config.add_route('login', '/login')
        model = self.app.model
        view = self.make_view()

        # if no users then home page will redirect
        response = view.home(session=self.session)
        self.assertEqual(response.status_code, 302)

        # so add a user
        user = model.User(username='foo')
        self.session.add(user)
        self.session.commit()

        # now we see the home page
        context = view.home(session=self.session)
        self.assertEqual(context['index_title'], self.app.get_title())

        # but if configured, anons will be redirected to login
        self.config.setdefault('wuttaweb.home_redirect_to_login', 'true')
        response = view.home(session=self.session)
        self.assertEqual(response.status_code, 302)

        # now only an auth'ed user can see home page
        self.request.user = user
        context = view.home(session=self.session)
        self.assertEqual(context['index_title'], self.app.get_title())

    def test_feedback_make_schema(self):
        view = self.make_view()
        schema = view.feedback_make_schema()
        self.assertIsInstance(schema, colander.Schema)
        self.assertIn('message', schema)

    def test_feedback(self):
        self.pyramid_config.add_route('users.view', '/users/{uuid}')
        model = self.app.model
        user = model.User(username='barney')
        self.session.add(user)
        self.session.commit()

        view = self.make_view()
        with patch.object(view, 'feedback_send') as feedback_send:

            # basic send, no user
            self.request.client_addr = '127.0.0.1'
            self.request.method = 'POST'
            self.request.POST = {
                'referrer': '/foo',
                'user_name': "Barney Rubble",
                'message': "hello world",
            }
            context = view.feedback()
            self.assertEqual(context, {'ok': True})
            feedback_send.assert_called_once()

            # reset
            feedback_send.reset_mock()

            # basic send, with user
            self.request.user = user
            self.request.POST['user_uuid'] = user.uuid
            with patch.object(mod, 'Session', return_value=self.session):
                context = view.feedback()
            self.assertEqual(context, {'ok': True})
            feedback_send.assert_called_once()

            # reset
            self.request.user = None
            feedback_send.reset_mock()

            # invalid form data
            self.request.POST = {'message': 'hello world'}
            context = view.feedback()
            self.assertEqual(list(context), ['error'])
            self.assertIn('Required', context['error'])
            feedback_send.assert_not_called()

            # error on send
            self.request.POST = {
                'referrer': '/foo',
                'user_name': "Barney Rubble",
                'message': "hello world",
            }
            feedback_send.side_effect = RuntimeError
            context = view.feedback()
            feedback_send.assert_called_once()
            self.assertEqual(list(context), ['error'])
            self.assertIn('RuntimeError', context['error'])

    def test_setup(self):
        self.pyramid_config.add_route('home', '/')
        self.pyramid_config.add_route('login', '/login')
        model = self.app.model
        auth = self.app.get_auth_handler()
        view = self.make_view()

        # at first, can see the setup page
        self.assertEqual(self.session.query(model.User).count(), 0)
        context = view.setup(session=self.session)
        self.assertEqual(context['index_title'], self.app.get_title())

        # so add a user
        user = model.User(username='foo')
        self.session.add(user)
        self.session.commit()

        # once user exists it will always redirect
        response = view.setup(session=self.session)
        self.assertEqual(response.status_code, 302)

        # delete that user
        self.session.delete(user)
        self.session.commit()

        # so we can see the setup page again
        context = view.setup(session=self.session)
        self.assertEqual(context['index_title'], self.app.get_title())

        # and finally, post data to create admin user
        self.request.method = 'POST'
        self.request.POST = {
            'username': 'barney',
            '__start__': 'password:mapping',
            'password': 'testpass',
            'password-confirm': 'testpass',
            '__end__': 'password:mapping',
            'first_name': "Barney",
            'last_name': "Rubble",
        }
        response = view.setup(session=self.session)
        # nb. redirects on success
        self.assertEqual(response.status_code, 302)
        barney = self.session.query(model.User).one()
        self.assertEqual(barney.username, 'barney')
        self.assertTrue(auth.check_user_password(barney, 'testpass'))
        admin = auth.get_role_administrator(self.session)
        self.assertIn(admin, barney.roles)
        self.assertIsNotNone(barney.person)
        person = barney.person
        self.assertEqual(person.first_name, "Barney")
        self.assertEqual(person.last_name, "Rubble")
        self.assertEqual(person.full_name, "Barney Rubble")