"""Test handlers."""

import json
from unittest.mock import Mock
from unittest.mock import patch

import pytest

from api import handlers
from api.application import app

test_client = None


def setup_module(module):
    """Set up the Flask test client."""
    app.testing = True
    module.test_client = app.test_client()


def teardown_module(module):
    """Tear down the Flask test client."""
    module.test_client = None
    app.testing = False


@pytest.fixture
def invalid_grass_headers():
    """Return invalid Grass headers."""
    return {
        'Grass-Account-Type': 'foo',
        'Grass-Account-Id': '123'}


@pytest.fixture
def valid_grass_headers():
    """Return valid Grass headers."""
    return {
        'Grass-Account-Type': 'vendor',
        'Grass-Account-Id': '123'}


def assert_ok(result):
    """Assert OK response.

    Args:
        result (Response): Flask response.
    """
    assert result.status_code == 200
    assert result.data == b'{"status": "ok"}'


def test_hello(monkeypatch):
    """Test healthcheck endpoint."""
    # Mock handlers.healthcheck.status function
    healthcheck_status_mock = Mock(return_value=Mock(
        message={'status': 'ok'}, errors=None, status=200))
    monkeypatch.setattr(
        handlers.healthcheck, 'status', healthcheck_status_mock)

    # Asserts
    assert_ok(test_client.get('/'))
    assert_ok(test_client.get('/hello'))
    assert healthcheck_status_mock.call_count == 2


def test_hello_db(monkeypatch):
    """Test DB healthcheck endpoint."""
    # Mock handlers.healthcheck.db_status function
    healthcheck_db_status_mock = Mock(return_value=Mock(
        message={'status': 'ok'}, errors=None, status=200))
    monkeypatch.setattr(
        handlers.healthcheck, 'db_status', healthcheck_db_status_mock)

    # Asserts
    assert_ok(test_client.get('/hello_db'))
    assert healthcheck_db_status_mock.called


@patch('api.handlers.config.ENVIRONMENT', 'qa')
def test_get_release_profit_loss_ok(
        monkeypatch, valid_grass_headers):
    """Test /release/<upc>/profit-loss endpoint with valid headers."""
    # Fixtures
    revenue_projection_status = 200
    revenue_projection_message = ['foobar']
    fixture_upc = '888812345678'

    get_revenue_and_projection_mock = Mock(
        return_value=Mock(
            status=revenue_projection_status,
            message=revenue_projection_message,
            errors=None))
    monkeypatch.setattr(
        handlers.film_transparency, 'get_revenue_and_projection',
        get_revenue_and_projection_mock)

    result = test_client.get(
        '/release/{upc}/profit-loss'.format(upc=fixture_upc),
        headers=valid_grass_headers)

    expected_data = json.dumps(revenue_projection_message)

    # Asserts
    assert result.status_code == 200
    assert result.data == expected_data.encode('utf8')


def test_get_release_profit_loss_dev_ok(
        monkeypatch):
    """Test /release/<upc>/profit-loss endpoint with valid headers."""
    # Fixtures
    revenue_projection_status = 200
    revenue_projection_message = ['foobar']
    fixture_upc = '888812345678'

    get_revenue_and_projection_mock = Mock(
        return_value=Mock(
            status=revenue_projection_status,
            message=revenue_projection_message,
            errors=None))
    monkeypatch.setattr(
        handlers.film_transparency, 'get_revenue_and_projection',
        get_revenue_and_projection_mock)

    result = test_client.get(
        '/release/{upc}/profit-loss'.format(upc=fixture_upc))

    expected_data = json.dumps(revenue_projection_message)

    # Asserts
    assert result.status_code == 200
    assert result.data == expected_data.encode('utf8')
    get_revenue_and_projection_mock.assert_called_once_with(fixture_upc)


@patch('api.handlers.config.ENVIRONMENT', 'qa')
def test_get_release_profit_loss_invalid_headers(
        monkeypatch, invalid_grass_headers):
    """Test /release/<upc>/profit-loss endpoint with invalid headers."""
    # Fixtures
    fixture_status = 400
    fixture_message = 'Bad request'
    fixture_upc = 888812345678
    fixture_errors = dict(
        code=handlers.response.ERROR_CODE_GRASS_VALIDATION_ERROR,
        message=fixture_message)

    # Mocking handlers.response.create_error_response function
    create_error_response_mock = Mock(return_value=Mock(
        status=fixture_status,
        message=None,
        errors=fixture_errors))
    monkeypatch.setattr(
        handlers.response, 'create_error_response', create_error_response_mock)

    result = test_client.get(
        '/release/{upc}/profit-loss'.format(upc=fixture_upc),
        headers=invalid_grass_headers)

    # Asserts
    assert result.status_code == fixture_status
    assert json.loads(result.data.decode('utf8')) == fixture_errors
    create_error_response_mock.assert_called_once_with(
        handlers.response.ERROR_CODE_GRASS_VALIDATION_ERROR,
        fixture_message)


@patch('api.handlers.config.ENVIRONMENT', 'qa')
def test_get_vendor_releases(
        monkeypatch, valid_grass_headers):
    """Test /vendor/<vendor_id>/releases endpoint with valid headers."""
    # Fixtures
    fixture_vendor_id = '12345'
    get_releases_status = 200
    get_releases_message = [659265745943, 527508425413, 524542551341]

    get_releases_mock = Mock(
        return_value=Mock(
            status=get_releases_status,
            message=get_releases_message,
            errors=None))
    monkeypatch.setattr(
        handlers.film_transparency, 'get_releases',
        get_releases_mock)

    result = test_client.get(
        '/vendor/{vendor_id}/releases'.format(vendor_id=fixture_vendor_id),
        headers=valid_grass_headers)

    expected_data = json.dumps(get_releases_message)

    # Asserts
    assert result.status_code == 200
    assert result.data == expected_data.encode('utf8')