import asyncio
import inspect
import os

import pytest

from sanic.app import Sanic
from sanic.blueprints import Blueprint
from sanic.constants import HTTP_METHODS
from sanic.exceptions import NotFound, ServerError, InvalidUsage
from sanic.request import Request
from sanic.response import text, json
from sanic.views import CompositionView


# ------------------------------------------------------------ #
#  GET
# ------------------------------------------------------------ #

@pytest.fixture(scope='module')
def static_file_directory():
    """The static directory to serve"""
    current_file = inspect.getfile(inspect.currentframe())
    current_directory = os.path.dirname(os.path.abspath(current_file))
    static_directory = os.path.join(current_directory, 'static')
    return static_directory


def get_file_path(static_file_directory, file_name):
    return os.path.join(static_file_directory, file_name)


def get_file_content(static_file_directory, file_name):
    """The content of the static file to check"""
    with open(get_file_path(static_file_directory, file_name), 'rb') as file:
        return file.read()


@pytest.mark.parametrize('method', HTTP_METHODS)
def test_versioned_routes_get(app, method):
    bp = Blueprint('test_text')

    method = method.lower()

    func = getattr(bp, method)
    if callable(func):
        @func('/{}'.format(method), version=1)
        def handler(request):
            return text('OK')
    else:
        print(func)
        raise Exception("{} is not callable".format(func))

    app.blueprint(bp)

    client_method = getattr(app.test_client, method)

    request, response = client_method('/v1/{}'.format(method))
    assert response.status == 200


def test_bp(app):
    bp = Blueprint('test_text')

    @bp.route('/')
    def handler(request):
        return text('Hello')

    app.blueprint(bp)
    request, response = app.test_client.get('/')
    assert app.is_request_stream is False

    assert response.text == 'Hello'


def test_bp_strict_slash(app):
    bp = Blueprint('test_text')

    @bp.get('/get', strict_slashes=True)
    def get_handler(request):
        return text('OK')

    @bp.post('/post/', strict_slashes=True)
    def post_handler(request):
        return text('OK')

    app.blueprint(bp)

    request, response = app.test_client.get('/get')
    assert response.text == 'OK'
    assert response.json is None

    request, response = app.test_client.get('/get/')
    assert response.status == 404

    request, response = app.test_client.post('/post/')
    assert response.text == 'OK'

    request, response = app.test_client.post('/post')
    assert response.status == 404


def test_bp_strict_slash_default_value(app):
    bp = Blueprint('test_text', strict_slashes=True)

    @bp.get('/get')
    def get_handler(request):
        return text('OK')

    @bp.post('/post/')
    def post_handler(request):
        return text('OK')

    app.blueprint(bp)

    request, response = app.test_client.get('/get/')
    assert response.status == 404

    request, response = app.test_client.post('/post')
    assert response.status == 404


def test_bp_strict_slash_without_passing_default_value(app):
    bp = Blueprint('test_text')

    @bp.get('/get')
    def get_handler(request):
        return text('OK')

    @bp.post('/post/')
    def post_handler(request):
        return text('OK')

    app.blueprint(bp)

    request, response = app.test_client.get('/get/')
    assert response.text == 'OK'

    request, response = app.test_client.post('/post')
    assert response.text == 'OK'


def test_bp_strict_slash_default_value_can_be_overwritten(app):
    bp = Blueprint('test_text', strict_slashes=True)

    @bp.get('/get', strict_slashes=False)
    def get_handler(request):
        return text('OK')

    @bp.post('/post/', strict_slashes=False)
    def post_handler(request):
        return text('OK')

    app.blueprint(bp)

    request, response = app.test_client.get('/get/')
    assert response.text == 'OK'

    request, response = app.test_client.post('/post')
    assert response.text == 'OK'


def test_bp_with_url_prefix(app):
    bp = Blueprint('test_text', url_prefix='/test1')

    @bp.route('/')
    def handler(request):
        return text('Hello')

    app.blueprint(bp)
    request, response = app.test_client.get('/test1/')

    assert response.text == 'Hello'


def test_several_bp_with_url_prefix(app):
    bp = Blueprint('test_text', url_prefix='/test1')
    bp2 = Blueprint('test_text2', url_prefix='/test2')

    @bp.route('/')
    def handler(request):
        return text('Hello')

    @bp2.route('/')
    def handler2(request):
        return text('Hello2')

    app.blueprint(bp)
    app.blueprint(bp2)
    request, response = app.test_client.get('/test1/')
    assert response.text == 'Hello'

    request, response = app.test_client.get('/test2/')
    assert response.text == 'Hello2'


def test_bp_with_host(app):
    bp = Blueprint('test_bp_host', url_prefix='/test1', host="example.com")

    @bp.route('/')
    def handler1(request):
        return text('Hello')

    @bp.route('/', host="sub.example.com")
    def handler2(request):
        return text('Hello subdomain!')

    app.blueprint(bp)
    headers = {"Host": "example.com"}
    request, response = app.test_client.get(
        '/test1/',
        headers=headers)
    assert response.text == 'Hello'

    headers = {"Host": "sub.example.com"}
    request, response = app.test_client.get(
        '/test1/',
        headers=headers)

    assert response.text == 'Hello subdomain!'


def test_several_bp_with_host(app):
    bp = Blueprint('test_text',
                   url_prefix='/test',
                   host="example.com")
    bp2 = Blueprint('test_text2',
                    url_prefix='/test',
                    host="sub.example.com")

    @bp.route('/')
    def handler(request):
        return text('Hello')

    @bp2.route('/')
    def handler1(request):
        return text('Hello2')

    @bp2.route('/other/')
    def handler2(request):
        return text('Hello3')

    app.blueprint(bp)
    app.blueprint(bp2)

    assert bp.host == "example.com"
    headers = {"Host": "example.com"}
    request, response = app.test_client.get(
        '/test/',
        headers=headers)
    assert response.text == 'Hello'

    assert bp2.host == "sub.example.com"
    headers = {"Host": "sub.example.com"}
    request, response = app.test_client.get(
        '/test/',
        headers=headers)

    assert response.text == 'Hello2'
    request, response = app.test_client.get(
        '/test/other/',
        headers=headers)
    assert response.text == 'Hello3'


def test_bp_middleware(app):
    blueprint = Blueprint('test_middleware')

    @blueprint.middleware('response')
    async def process_response(request, response):
        return text('OK')

    @app.route('/')
    async def handler(request):
        return text('FAIL')

    app.blueprint(blueprint)

    request, response = app.test_client.get('/')

    assert response.status == 200
    assert response.text == 'OK'


def test_bp_exception_handler(app):
    blueprint = Blueprint('test_middleware')

    @blueprint.route('/1')
    def handler_1(request):
        raise InvalidUsage("OK")

    @blueprint.route('/2')
    def handler_2(request):
        raise ServerError("OK")

    @blueprint.route('/3')
    def handler_3(request):
        raise NotFound("OK")

    @blueprint.exception(NotFound, ServerError)
    def handler_exception(request, exception):
        return text("OK")

    app.blueprint(blueprint)

    request, response = app.test_client.get('/1')
    assert response.status == 400

    request, response = app.test_client.get('/2')
    assert response.status == 200
    assert response.text == 'OK'

    request, response = app.test_client.get('/3')
    assert response.status == 200


def test_bp_listeners(app):
    blueprint = Blueprint('test_middleware')

    order = []

    @blueprint.listener('before_server_start')
    def handler_1(sanic, loop):
        order.append(1)

    @blueprint.listener('after_server_start')
    def handler_2(sanic, loop):
        order.append(2)

    @blueprint.listener('after_server_start')
    def handler_3(sanic, loop):
        order.append(3)

    @blueprint.listener('before_server_stop')
    def handler_4(sanic, loop):
        order.append(5)

    @blueprint.listener('before_server_stop')
    def handler_5(sanic, loop):
        order.append(4)

    @blueprint.listener('after_server_stop')
    def handler_6(sanic, loop):
        order.append(6)

    app.blueprint(blueprint)

    request, response = app.test_client.get('/')

    assert order == [1, 2, 3, 4, 5, 6]


def test_bp_static(app):
    current_file = inspect.getfile(inspect.currentframe())
    with open(current_file, 'rb') as file:
        current_file_contents = file.read()

    blueprint = Blueprint('test_static')

    blueprint.static('/testing.file', current_file)

    app.blueprint(blueprint)

    request, response = app.test_client.get('/testing.file')
    assert response.status == 200
    assert response.body == current_file_contents


@pytest.mark.parametrize('file_name', ['test.html'])
def test_bp_static_content_type(app, file_name):
    # This is done here, since no other test loads a file here
    current_file = inspect.getfile(inspect.currentframe())
    current_directory = os.path.dirname(os.path.abspath(current_file))
    static_directory = os.path.join(current_directory, 'static')

    blueprint = Blueprint('test_static')
    blueprint.static(
        '/testing.file',
        get_file_path(static_directory, file_name),
        content_type='text/html; charset=utf-8'
    )

    app.blueprint(blueprint)

    request, response = app.test_client.get('/testing.file')
    assert response.status == 200
    assert response.body == get_file_content(static_directory, file_name)
    assert response.headers['Content-Type'] == 'text/html; charset=utf-8'


def test_bp_shorthand(app):
    blueprint = Blueprint('test_shorhand_routes')
    ev = asyncio.Event()

    @blueprint.get('/get')
    def handler(request):
        assert request.stream is None
        return text('OK')

    @blueprint.put('/put')
    def put_handler(request):
        assert request.stream is None
        return text('OK')

    @blueprint.post('/post')
    def post_handler(request):
        assert request.stream is None
        return text('OK')

    @blueprint.head('/head')
    def head_handler(request):
        assert request.stream is None
        return text('OK')

    @blueprint.options('/options')
    def options_handler(request):
        assert request.stream is None
        return text('OK')

    @blueprint.patch('/patch')
    def patch_handler(request):
        assert request.stream is None
        return text('OK')

    @blueprint.delete('/delete')
    def delete_handler(request):
        assert request.stream is None
        return text('OK')

    @blueprint.websocket('/ws/', strict_slashes=True)
    async def websocket_handler(request, ws):
        assert request.stream is None
        ev.set()

    app.blueprint(blueprint)

    assert app.is_request_stream is False

    request, response = app.test_client.get('/get')
    assert response.text == 'OK'

    request, response = app.test_client.post('/get')
    assert response.status == 405

    request, response = app.test_client.put('/put')
    assert response.text == 'OK'

    request, response = app.test_client.get('/post')
    assert response.status == 405

    request, response = app.test_client.post('/post')
    assert response.text == 'OK'

    request, response = app.test_client.get('/post')
    assert response.status == 405

    request, response = app.test_client.head('/head')
    assert response.status == 200

    request, response = app.test_client.get('/head')
    assert response.status == 405

    request, response = app.test_client.options('/options')
    assert response.text == 'OK'

    request, response = app.test_client.get('/options')
    assert response.status == 405

    request, response = app.test_client.patch('/patch')
    assert response.text == 'OK'

    request, response = app.test_client.get('/patch')
    assert response.status == 405

    request, response = app.test_client.delete('/delete')
    assert response.text == 'OK'

    request, response = app.test_client.get('/delete')
    assert response.status == 405

    request, response = app.test_client.get('/ws/', headers={
        'Upgrade': 'websocket',
        'Connection': 'upgrade',
        'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ==',
        'Sec-WebSocket-Version': '13'})
    assert response.status == 101
    assert ev.is_set()


def test_bp_group(app):
    deep_0 = Blueprint('deep_0', url_prefix='/deep')
    deep_1 = Blueprint('deep_1', url_prefix='/deep1')

    @deep_0.route('/')
    def handler(request):
        return text('D0_OK')

    @deep_1.route('/bottom')
    def bottom_handler(request):
        return text('D1B_OK')

    mid_0 = Blueprint.group(deep_0, deep_1, url_prefix='/mid')
    mid_1 = Blueprint('mid_tier', url_prefix='/mid1')

    @mid_1.route('/')
    def handler1(request):
        return text('M1_OK')

    top = Blueprint.group(mid_0, mid_1)

    app.blueprint(top)

    @app.route('/')
    def handler2(request):
        return text('TOP_OK')

    request, response = app.test_client.get('/')
    assert response.text == 'TOP_OK'

    request, response = app.test_client.get('/mid1')
    assert response.text == 'M1_OK'

    request, response = app.test_client.get('/mid/deep')
    assert response.text == 'D0_OK'

    request, response = app.test_client.get('/mid/deep1/bottom')
    assert response.text == 'D1B_OK'


def test_bp_group_with_default_url_prefix(app):
    from sanic.response import json
    bp_resources = Blueprint('bp_resources')

    @bp_resources.get('/')
    def list_resources_handler(request):
        resource = {}
        return json([resource])

    bp_resource = Blueprint('bp_resource', url_prefix='/<resource_id>')

    @bp_resource.get('/')
    def get_resource_hander(request, resource_id):
        resource = {'resource_id': resource_id}
        return json(resource)

    bp_resources_group = Blueprint.group(bp_resources, bp_resource,
                                         url_prefix='/resources')
    bp_api_v1 = Blueprint('bp_api_v1')

    @bp_api_v1.get('/info')
    def api_v1_info(request):
        return text('api_version: v1')

    bp_api_v1_group = Blueprint.group(bp_api_v1, bp_resources_group,
                                      url_prefix='/v1')
    bp_api_group = Blueprint.group(bp_api_v1_group, url_prefix='/api')
    app.blueprint(bp_api_group)

    request, response = app.test_client.get('/api/v1/info')
    assert response.text == 'api_version: v1'

    request, response = app.test_client.get('/api/v1/resources')
    assert response.json == [{}]

    from uuid import uuid4
    resource_id = str(uuid4())
    request, response = app.test_client.get(
        '/api/v1/resources/{0}'.format(resource_id))
    assert response.json == {'resource_id': resource_id}


def test_blueprint_middleware_with_args(app: Sanic):
    bp = Blueprint(name="with_args_bp", url_prefix="/wa")

    @bp.middleware
    def middleware_with_no_tag(request: Request):
        if request.headers.get("content-type") == "application/json":
            request.headers["accepts"] = "plain/text"
        else:
            request.headers["accepts"] = "application/json"

    @bp.route("/")
    def default_route(request):
        if request.headers.get("accepts") == "application/json":
            return json({"test": "value"})
        else:
            return text("value")

    app.blueprint(bp)

    _, response = app.test_client.get("/wa", headers={"content-type": "application/json"})
    assert response.text == "value"

    _, response = app.test_client.get("/wa", headers={"content-type": "plain/text"})
    assert response.json.get("test") == "value"
    d = {}


@pytest.mark.parametrize('file_name',
                         ['test.file'])
def test_static_blueprint_name(app: Sanic, static_file_directory, file_name):
    current_file = inspect.getfile(inspect.currentframe())
    with open(current_file, 'rb') as file:
        current_file_contents = file.read()

    bp = Blueprint(name="static", url_prefix="/static", strict_slashes=False)

    bp.static(
        "/test.file/",
        get_file_path(static_file_directory, file_name),
        name="static.testing",
        strict_slashes=True)

    app.blueprint(bp)

    uri = app.url_for('static', name='static.testing')
    assert uri == "/static/test.file"

    _, response = app.test_client.get("/static/test.file")
    assert response.status == 404

    _, response = app.test_client.get("/static/test.file/")
    assert response.status == 200


def test_route_handler_add(app: Sanic):
    view = CompositionView()

    async def get_handler(request):
        return json({
            "response": "OK"
        })

    view.add(["GET"], get_handler, stream=False)

    async def default_handler(request):
        return text("OK")

    bp = Blueprint(name="handler", url_prefix="/handler")
    bp.add_route(
        default_handler,
        uri="/default/",
        strict_slashes=True)

    bp.add_route(view, uri="/view", name="test")

    app.blueprint(bp)

    _, response = app.test_client.get("/handler/default/")
    assert response.text == "OK"

    _, response = app.test_client.get("/handler/view")
    assert response.json["response"] == "OK"


def test_websocket_route(app: Sanic):
    event = asyncio.Event()

    async def websocket_handler(request, ws):
        assert ws.subprotocol is None
        event.set()

    bp = Blueprint(name="handler", url_prefix="/ws")
    bp.add_websocket_route(websocket_handler, "/test", name="test")

    app.blueprint(bp)

    _, response = app.test_client.get("/ws/test", headers={
        'Upgrade': 'websocket',
        'Connection': 'upgrade',
        'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ==',
        'Sec-WebSocket-Version': '13'
    })
    assert response.status == 101
    assert event.is_set()


def test_duplicate_blueprint(app):
    bp_name = 'bp'
    bp = Blueprint(bp_name)
    bp1 = Blueprint(bp_name)

    app.blueprint(bp)

    with pytest.raises(AssertionError) as excinfo:
        app.blueprint(bp1)

    assert str(excinfo.value) == (
        'A blueprint with the name "{}" is already registered.  '
        'Blueprint names must be unique.'
    ).format(bp_name)


@pytest.mark.parametrize('debug', [True, False, None])
def test_register_blueprint(app, debug):
    bp = Blueprint('bp')

    app.debug = debug
    with pytest.warns(DeprecationWarning) as record:
        app.register_blueprint(bp)
    
    assert record[0].message.args[0] == (
        "Use of register_blueprint will be deprecated in "
        "version 1.0.  Please use the blueprint method"
        " instead"
    )