#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import asyncio
import pytest

from sanic.blueprints import Blueprint
from sanic.response import text
from sanic.exceptions import URLBuildError
from sanic.constants import HTTP_METHODS


# ------------------------------------------------------------ #
#  UTF-8
# ------------------------------------------------------------ #

@pytest.mark.parametrize('method', HTTP_METHODS)
def test_versioned_named_routes_get(app, method):
    bp = Blueprint('test_bp', url_prefix='/bp')

    method = method.lower()
    route_name = 'route_{}'.format(method)
    route_name2 = 'route2_{}'.format(method)

    func = getattr(app, method)
    if callable(func):
        @func('/{}'.format(method), version=1, name=route_name)
        def handler(request):
            return text('OK')
    else:
        print(func)
        raise

    func = getattr(bp, method)
    if callable(func):
        @func('/{}'.format(method), version=1, name=route_name2)
        def handler2(request):
            return text('OK')

    else:
        print(func)
        raise

    app.blueprint(bp)

    assert app.router.routes_all['/v1/{}'.format(method)].name == route_name

    route = app.router.routes_all['/v1/bp/{}'.format(method)]
    assert route.name == 'test_bp.{}'.format(route_name2)

    assert app.url_for(route_name) == '/v1/{}'.format(method)
    url = app.url_for('test_bp.{}'.format(route_name2))
    assert url == '/v1/bp/{}'.format(method)
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_shorthand_default_routes_get(app):

    @app.get('/get')
    def handler(request):
        return text('OK')

    assert app.router.routes_all['/get'].name == 'handler'
    assert app.url_for('handler') == '/get'


def test_shorthand_named_routes_get(app):
    bp = Blueprint('test_bp', url_prefix='/bp')

    @app.get('/get', name='route_get')
    def handler(request):
        return text('OK')

    @bp.get('/get', name='route_bp')
    def handler2(request):
        return text('Blueprint')

    app.blueprint(bp)

    assert app.router.routes_all['/get'].name == 'route_get'
    assert app.url_for('route_get') == '/get'
    with pytest.raises(URLBuildError):
        app.url_for('handler')

    assert app.router.routes_all['/bp/get'].name == 'test_bp.route_bp'
    assert app.url_for('test_bp.route_bp') == '/bp/get'
    with pytest.raises(URLBuildError):
        app.url_for('test_bp.handler2')


def test_shorthand_named_routes_post(app):

    @app.post('/post', name='route_name')
    def handler(request):
        return text('OK')

    assert app.router.routes_all['/post'].name == 'route_name'
    assert app.url_for('route_name') == '/post'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_shorthand_named_routes_put(app):

    @app.put('/put', name='route_put')
    def handler(request):
        assert request.stream is None
        return text('OK')

    assert app.is_request_stream is False
    assert app.router.routes_all['/put'].name == 'route_put'
    assert app.url_for('route_put') == '/put'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_shorthand_named_routes_delete(app):

    @app.delete('/delete', name='route_delete')
    def handler(request):
        assert request.stream is None
        return text('OK')

    assert app.is_request_stream is False
    assert app.router.routes_all['/delete'].name == 'route_delete'
    assert app.url_for('route_delete') == '/delete'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_shorthand_named_routes_patch(app):

    @app.patch('/patch', name='route_patch')
    def handler(request):
        assert request.stream is None
        return text('OK')

    assert app.is_request_stream is False
    assert app.router.routes_all['/patch'].name == 'route_patch'
    assert app.url_for('route_patch') == '/patch'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_shorthand_named_routes_head(app):

    @app.head('/head', name='route_head')
    def handler(request):
        assert request.stream is None
        return text('OK')

    assert app.is_request_stream is False
    assert app.router.routes_all['/head'].name == 'route_head'
    assert app.url_for('route_head') == '/head'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_shorthand_named_routes_options(app):

    @app.options('/options', name='route_options')
    def handler(request):
        assert request.stream is None
        return text('OK')

    assert app.is_request_stream is False
    assert app.router.routes_all['/options'].name == 'route_options'
    assert app.url_for('route_options') == '/options'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_named_static_routes(app):

    @app.route('/test', name='route_test')
    async def handler1(request):
        return text('OK1')

    @app.route('/pizazz', name='route_pizazz')
    async def handler2(request):
        return text('OK2')

    assert app.router.routes_all['/test'].name == 'route_test'
    assert app.router.routes_static['/test'].name == 'route_test'
    assert app.url_for('route_test') == '/test'
    with pytest.raises(URLBuildError):
        app.url_for('handler1')

    assert app.router.routes_all['/pizazz'].name == 'route_pizazz'
    assert app.router.routes_static['/pizazz'].name == 'route_pizazz'
    assert app.url_for('route_pizazz') == '/pizazz'
    with pytest.raises(URLBuildError):
        app.url_for('handler2')


def test_named_dynamic_route(app):
    results = []

    @app.route('/folder/<name>', name='route_dynamic')
    async def handler(request, name):
        results.append(name)
        return text('OK')

    assert app.router.routes_all['/folder/<name>'].name == 'route_dynamic'
    assert app.url_for('route_dynamic', name='test') == '/folder/test'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_dynamic_named_route_regex(app):

    @app.route('/folder/<folder_id:[A-Za-z0-9]{0,4}>', name='route_re')
    async def handler(request, folder_id):
        return text('OK')

    route = app.router.routes_all['/folder/<folder_id:[A-Za-z0-9]{0,4}>']
    assert route.name == 'route_re'
    assert app.url_for('route_re', folder_id='test') == '/folder/test'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_dynamic_named_route_path(app):

    @app.route('/<path:path>/info', name='route_dynamic_path')
    async def handler(request, path):
        return text('OK')

    route = app.router.routes_all['/<path:path>/info']
    assert route.name == 'route_dynamic_path'
    assert app.url_for('route_dynamic_path', path='path/1') == '/path/1/info'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_dynamic_named_route_unhashable(app):

    @app.route('/folder/<unhashable:[A-Za-z0-9/]+>/end/',
               name='route_unhashable')
    async def handler(request, unhashable):
        return text('OK')

    route = app.router.routes_all['/folder/<unhashable:[A-Za-z0-9/]+>/end/']
    assert route.name == 'route_unhashable'
    url = app.url_for('route_unhashable', unhashable='test/asdf')
    assert url == '/folder/test/asdf/end'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_websocket_named_route(app):
    ev = asyncio.Event()

    @app.websocket('/ws', name='route_ws')
    async def handler(request, ws):
        assert ws.subprotocol is None
        ev.set()

    assert app.router.routes_all['/ws'].name == 'route_ws'
    assert app.url_for('route_ws') == '/ws'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_websocket_named_route_with_subprotocols(app):
    results = []

    @app.websocket('/ws', subprotocols=['foo', 'bar'], name='route_ws')
    async def handler(request, ws):
        results.append(ws.subprotocol)

    assert app.router.routes_all['/ws'].name == 'route_ws'
    assert app.url_for('route_ws') == '/ws'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_static_add_named_route(app):

    async def handler1(request):
        return text('OK1')

    async def handler2(request):
        return text('OK2')

    app.add_route(handler1, '/test', name='route_test')
    app.add_route(handler2, '/test2', name='route_test2')

    assert app.router.routes_all['/test'].name == 'route_test'
    assert app.router.routes_static['/test'].name == 'route_test'
    assert app.url_for('route_test') == '/test'
    with pytest.raises(URLBuildError):
        app.url_for('handler1')

    assert app.router.routes_all['/test2'].name == 'route_test2'
    assert app.router.routes_static['/test2'].name == 'route_test2'
    assert app.url_for('route_test2') == '/test2'
    with pytest.raises(URLBuildError):
        app.url_for('handler2')


def test_dynamic_add_named_route(app):
    results = []

    async def handler(request, name):
        results.append(name)
        return text('OK')

    app.add_route(handler, '/folder/<name>', name='route_dynamic')
    assert app.router.routes_all['/folder/<name>'].name == 'route_dynamic'
    assert app.url_for('route_dynamic', name='test') == '/folder/test'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_dynamic_add_named_route_unhashable(app):

    async def handler(request, unhashable):
        return text('OK')

    app.add_route(handler, '/folder/<unhashable:[A-Za-z0-9/]+>/end/',
                  name='route_unhashable')
    route = app.router.routes_all['/folder/<unhashable:[A-Za-z0-9/]+>/end/']
    assert route.name == 'route_unhashable'
    url = app.url_for('route_unhashable', unhashable='folder1')
    assert url == '/folder/folder1/end'
    with pytest.raises(URLBuildError):
        app.url_for('handler')


def test_overload_routes(app):

    @app.route('/overload', methods=['GET'], name='route_first')
    async def handler1(request):
        return text('OK1')

    @app.route('/overload', methods=['POST', 'PUT'], name='route_second')
    async def handler2(request):
        return text('OK2')

    request, response = app.test_client.get(app.url_for('route_first'))
    assert response.text == 'OK1'

    request, response = app.test_client.post(app.url_for('route_first'))
    assert response.text == 'OK2'

    request, response = app.test_client.put(app.url_for('route_first'))
    assert response.text == 'OK2'

    request, response = app.test_client.get(app.url_for('route_second'))
    assert response.text == 'OK1'

    request, response = app.test_client.post(app.url_for('route_second'))
    assert response.text == 'OK2'

    request, response = app.test_client.put(app.url_for('route_second'))
    assert response.text == 'OK2'

    assert app.router.routes_all['/overload'].name == 'route_first'
    with pytest.raises(URLBuildError):
        app.url_for('handler1')

    assert app.url_for('route_first') == '/overload'
    assert app.url_for('route_second') == app.url_for('route_first')