"""Test handlers."""
import codecs
import json
from unittest.mock import MagicMock
from unittest.mock import patch

import pytest
from territories import handlers
from territories import response
from territories.db import db_init


@pytest.fixture(autouse=True)
def _db_setup(db_fixture):
    """Set up database with data for all handler tests."""
    db_init.data_backfill()


@patch('territories.handlers.g', spec=['log'])
def test_exception_handler(mock_g, app_context):
    """Verify exception_Handler returns 500 status code and json payload."""
    message = (
        'The server encountered an internal error '
        'and was unable to complete your request.')
    mock_error = MagicMock()
    server_response = handlers.exception_handler(mock_error)
    mock_g.log.exception.assert_called_with(mock_error)

    # assert status code is 500
    assert server_response.status_code == 500

    # assert json payload
    response_message = json.loads(server_response.data.decode())
    assert response_message['message'] == message
    assert response_message['code'] == response.ERROR_CODE_INTERNAL_ERROR


def test_get_standards(fixture_client, header_fixture):
    """Verify /standards endpoint returns standards list."""
    result = fixture_client.get('/standards', headers=header_fixture)
    assert result.status_code == 200
    json_data = json.loads(codecs.utf_8_decode(result.data)[0])
    assert len(json_data) == 2


@pytest.mark.parametrize('standard', ['Orch_1_2016', 'ISO_3166_1_2016'])
def test_get_territories(standard, fixture_client, header_fixture):
    """Verify /territory endpoint returns territories for a given standard."""
    result = fixture_client.get(
        '/territory/{0}'.format(standard), headers=header_fixture)
    assert result.status_code == 200


def test_get_territories_not_found(fixture_client, header_fixture):
    """Verify /territory endpoint returns 404 for non-existing standard."""
    result = fixture_client.get(
        '/territory/Westeros_1', headers=header_fixture)
    assert result.status_code == 404


@pytest.mark.parametrize('payload,output,territories', [
    ('Orch_1_2016', 'ISO_3166_1_2016', 'US'),
    ('Orch_1_2016', 'ISO_3166_1_2016', 'AN'),
    ('ISO_3166_1_2016', 'Orch_1_2016', 'US'),
    ('ISO_3166_1_2016', 'Orch_1_2016', 'BQ'),
])
def test_conversion_success(
        payload, output, territories, fixture_client, header_fixture):
    """Verify /conversion endpoint returns valid response."""
    url = '/conversion/{0}/{1}?territory_code_a2={2}'.format(
        payload, output, territories)
    result = fixture_client.get(url, headers=header_fixture)
    assert result.status_code == 200


@pytest.mark.parametrize('payload,output,territories', [
    ('Orch_1_2016', 'ISO_3166_1_2016', 'ZZ'),
    ('ISO_3166_1_2016', 'Orch_1_2016', 'YY'),
])
def test_conversion_invalid_country(
        payload, output, territories, fixture_client, header_fixture):
    """Verify /conversion endpoint returns 404 for non-existing territories."""
    url = '/conversion/{0}/{1}?territory_code_a2={2}'.format(
        payload, output, territories)
    result = fixture_client.get(url, headers=header_fixture)
    assert result.status_code == 404


def test_conversion_invalid_standard(fixture_client, header_fixture):
    """Verify /conversion endpoint returns 404 for non-existing standard."""
    result = fixture_client.get(
        '/conversion/Westeros_1/Middle-earth_2?territory_code_a2=US',
        headers=header_fixture)
    assert result.status_code == 404


@pytest.mark.parametrize('standard,territories', [
    ('Orch_1_2016', 'US'),
    ('ISO_3166_1_2016', 'BQ'),
])
def test_complement(standard, territories, fixture_client, header_fixture):
    """Verify /complement endpoint returns valid response."""
    result = fixture_client.get(
        '/complement/{0}?territory_code_a2={1}'.format(standard, territories),
        headers=header_fixture)
    assert result.status_code == 200
    json_data = json.loads(codecs.utf_8_decode(result.data)[0])
    assert len(json_data)


def test_complement_worldwide(fixture_client, header_fixture):
    """Verify /complement endpoint returns valid response for worldwide."""
    standard = 'Orch_1_2016'

    result = fixture_client.get(
        '/territory/{0}'.format(standard), headers=header_fixture)
    json_data = json.loads(codecs.utf_8_decode(result.data)[0])
    territories = ','.join(
        [ter['territory_code_a2'] for ter in json_data['items']])

    url = '/complement/{0}?territory_code_a2={1}'.format(standard, territories)
    result = fixture_client.get(url, headers=header_fixture)
    assert result.status_code == 200
    json_data = json.loads(codecs.utf_8_decode(result.data)[0])
    assert len(json_data['items']) == 0


def test_complement_not_found(fixture_client, header_fixture):
    """Verify /complement endpoint returns 400 response for invalid territory."""
    result = fixture_client.get(
        '/complement/Orch_1_2016?territory_code_a2=ZZ', headers=header_fixture)
    assert result.status_code == 400


def test_complement_invalid_standard(fixture_client, header_fixture):
    """Verify /conversion endpoint returns 404 for non-existing standard."""
    result = fixture_client.get(
        '/complement/Westeros_1/Middle-earth_2?territory_code_a2=US',
        headers=header_fixture)
    assert result.status_code == 404


def test_complement_empty_territories(fixture_client, header_fixture):
    """Verify /complement endpoint returns all territories for empty territory_code_a2."""
    result = fixture_client.get(
        '/complement/Orch_1_2016?territory_code_a2=',
        headers=header_fixture)
    assert result.status_code == 200
    json_data = json.loads(codecs.utf_8_decode(result.data)[0])

    worldwide = fixture_client.get(
        '/territory/Orch_1_2016', headers=header_fixture)
    worldwide_json = json.loads(codecs.utf_8_decode(worldwide.data)[0])

    assert len(json_data['items']) == len(worldwide_json['items'])