import json
from unittest.mock import MagicMock
from unittest.mock import patch

import application

from ows_accounting.constants import header
from ows_accounting.validation import access


def _mock_handler():
    """Mock handler
    """

    return 'Not decorated.'


def test_verify_grass_header_required():
    """Test verify_grass_header.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 1234,
        header.GRASS_ACCOUNT_TYPE: 'vendor'
    }
    test_args = {
        'account_id': 1234,
        'account_type': 'vendor'
    }
    with application.app.test_request_context(
            headers=test_header, data=test_args):
        actual = access.verify_grass_header(True)(_mock_handler)
        assert actual() == 'Not decorated.'


def test_verify_grass_header_missing_required():
    """Test verify_grass_header failed.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 'test account id'
    }
    with application.app.test_request_context(headers=test_header):
        actual = access.verify_grass_header(True)(_mock_handler)
        assert actual().status == '400 BAD REQUEST'
        actual_error_json = json.loads(
            actual().response.pop().decode('utf-8'))
        assert actual_error_json == json.loads(
            '{"code": "bad_grass_request_error", '
            '"message": "Incomplete Grass Headers"}')


def test_verify_grass_header_wrong_account_type_required():
    """Test verify_grass_header failed.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 88377,
        header.GRASS_ACCOUNT_TYPE: 'label'
    }
    with application.app.test_request_context(headers=test_header):
        actual = access.verify_grass_header(True)(_mock_handler)
        assert actual().status == '400 BAD REQUEST'
        actual_error_json = json.loads(
            actual().response.pop().decode('utf-8'))
        assert actual_error_json == json.loads(
            '{"code": "bad_grass_request_error", '
            '"message": "Invalid Grass Account Type"}')


def test_verify_grass_header_not_required():
    """Test verify_grass_header if grass headers are not required and no
    missing header.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: '88377',
        header.GRASS_ACCOUNT_TYPE: 'vendor'
    }
    with application.app.test_request_context(headers=test_header):
        actual = access.verify_grass_header()(_mock_handler)
        assert actual() == 'Not decorated.'


def test_verify_grass_header_not_required_missing_all_headers():
    """Test verify_grass_header if grass headers are not required and missing
    all headers.
    """

    test_header = {}
    with application.app.test_request_context(headers=test_header):
        actual = access.verify_grass_header()(_mock_handler)
        assert actual() == 'Not decorated.'


def test_verify_grass_header_missing_not_required():
    """Test verify_grass_header failed if one of the grass headers and grass
    headers are not required.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 'test account id'
    }
    with application.app.test_request_context(headers=test_header):
        actual = access.verify_grass_header()(_mock_handler)
        assert actual().status == '400 BAD REQUEST'
        actual_error_json = json.loads(
            actual().response.pop().decode('utf-8'))
        assert actual_error_json == json.loads(
            '{"code": "bad_grass_request_error", '
            '"message": "Incomplete Grass Headers"}')


def test_verify_grass_header_wrong_account_type_not_required():
    """Test verify_grass_header failed if grass headers not required and there
    are headers but the account type is wrong.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: '88377',
        header.GRASS_ACCOUNT_TYPE: 'label'
    }
    with application.app.test_request_context(headers=test_header):
        actual = access.verify_grass_header()(_mock_handler)
        assert actual().status == '400 BAD REQUEST'
        actual_error_json = json.loads(
            actual().response.pop().decode('utf-8'))
        assert actual_error_json == json.loads(
            '{"code": "bad_grass_request_error", '
            '"message": "Invalid Grass Account Type"}')


def test_verify_grass_header_wrong_account_id_not_required():
    """Test verify_grass_header failed if grass headers not required and there
    are headers but the account id is wrong.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 'ddd',
        header.GRASS_ACCOUNT_TYPE: 'vendor'
    }
    with application.app.test_request_context(headers=test_header):
        actual = access.verify_grass_header()(_mock_handler)
        assert actual().status == '400 BAD REQUEST'
        actual_error_json = json.loads(
            actual().response.pop().decode('utf-8'))
        assert actual_error_json == json.loads(
            '{"code": "bad_grass_request_error", '
            '"message": "Invalid Grass Account Id"}')


def test_verify_grass_header_accounts_dont_match():
    """Test verify_grass_header failed if account from header
    does not match account from request params.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 'ddd',
        header.GRASS_ACCOUNT_TYPE: 'vendor'
    }
    test_args = {
        'account_id': 1234,
        'account_type': 'not_vendor'
    }
    with application.app.test_request_context(
            headers=test_header, data=test_args):
        actual = access.verify_grass_header(True)(_mock_handler)
        actual_error_json = json.loads(
            actual().response.pop().decode('utf-8'))
        assert actual_error_json == json.loads(
            '{"code": "bad_grass_request_error", '
            '"message": "Invalid Grass Account Id"}')
        assert actual().status == '400 BAD REQUEST'


def test_verify_account_params_case1():
    """Test verify_account_params success when account_id and account_type are
    only provided from grass headers.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 1234,
        header.GRASS_ACCOUNT_TYPE: 'vendor'
    }
    test_args = {}
    with application.app.test_request_context(
            headers=test_header, data=test_args):
        actual = access.verify_account_params(_mock_handler)
        assert actual() == 'Not decorated.'


def test_verify_account_params_case2():
    """Test verify_account_params success when account_id and account_type are
    only provided from request object.
    """

    with application.app.test_request_context(
            '?account_id=1234&account_type=vendor'):
        actual = access.verify_account_params(_mock_handler)
        assert actual() == 'Not decorated.'


def test_verify_account_params_case3():
    """Test verify_account_params success when account_id and account_type are
    provided from request object and also grass header
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 1234,
        header.GRASS_ACCOUNT_TYPE: 'vendor'
    }
    with application.app.test_request_context(
            '?account_id=1234&account_type=vendor', headers=test_header):
        actual = access.verify_account_params(_mock_handler)
        assert actual() == 'Not decorated.'


def test_verify_account_params_account_id_not_equal():
    """Test verify_account_params success when account_id and account_type are
    provided from request object and also grass header
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 333,
        header.GRASS_ACCOUNT_TYPE: 'vendor'
    }
    with application.app.test_request_context(
            '?account_id=1234&account_type=vendor', headers=test_header):
        actual = access.verify_account_params(_mock_handler)
        assert actual().status == '403 FORBIDDEN'
        actual_error_json = json.loads(
            actual().response.pop().decode('utf-8'))
        assert actual_error_json == json.loads(
            '{"code": "authorization_error", '
            '"message": "User is forbidden"}')


def test_verify_account_params_account_type_not_equal():
    """Test verify_account_params success when account_id and account_type are
    provided from request object and also grass header
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 1234,
        header.GRASS_ACCOUNT_TYPE: 'label'
    }
    with application.app.test_request_context(
            '?account_id=1234&account_type=vendor', headers=test_header):
        actual = access.verify_account_params(_mock_handler)
        assert actual().status == '403 FORBIDDEN'
        actual_error_json = json.loads(
            actual().response.pop().decode('utf-8'))
        assert actual_error_json == json.loads(
            '{"code": "authorization_error", '
            '"message": "User is forbidden"}')


@patch('ows_accounting.validation.access.period')
def test_verify_periods_params_periods_not_found(mock_period_model):
    """Test verify_periods_params.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 1234,
        header.GRASS_ACCOUNT_TYPE: 'label'
    }
    mock_response = MagicMock()
    mock_response.message = [200, 201, 201]
    mock_response.status = 200
    mock_period_model.get_available_accounting_periods.return_value \
        = mock_response

    with application.app.test_request_context(
            '?periods=202', headers=test_header):
        actual = access.verify_periods_params(_mock_handler)
        assert actual().status == '404 NOT FOUND'


@patch('ows_accounting.validation.access.period')
def test_verify_periods_params_periods(mock_period_model):
    """Test verify_periods_params.
    """

    test_header = {
        header.GRASS_ACCOUNT_ID: 1234,
        header.GRASS_ACCOUNT_TYPE: 'label'
    }
    mock_response = MagicMock()
    mock_response.message = [200, 201, 201]
    mock_response.status = 200
    mock_period_model.get_available_accounting_periods.return_value \
        = mock_response

    with application.app.test_request_context(
            '?periods=201', headers=test_header):
        actual = access.verify_periods_params(_mock_handler)
        assert actual() == 'Not decorated.'


def test_verify_orchard_user_header():
    """Test verify_orchard_user_header succeed."""
    test_header = {'Orchard-User-Id': 'oa:1234'}
    with application.app.test_request_context(
            '/test', headers=test_header):
        actual = access.verify_orchard_user_header(_mock_handler)
        assert actual() == 'Not decorated.'


def test_verify_orchard_user_header_missing():
    """Test verify_orchard_user_header with missing header."""
    with application.app.test_request_context(
            '/test', headers={}):
        actual = access.verify_orchard_user_header(_mock_handler)
        assert actual().status == '400 BAD REQUEST'


def test_verify_orchard_user_header_invalid():
    """Test verify_orchard_user_header with bad header value."""
    test_header = {'Orchard-User-Id': 'dummy'}
    with application.app.test_request_context(
            '/test', headers=test_header):
        actual = access.verify_orchard_user_header(_mock_handler)
        assert actual().status == '400 BAD REQUEST'