import copy
import datetime
from functools import wraps
import json
from unittest.mock import MagicMock
from unittest.mock import patch

from owsrequest import flask_request
import pytest

from ows_accounting import api
from ows_accounting import config
from ows_accounting import response
from ows_accounting.constants import error
from ows_accounting.logic import accounting_intervals
from ows_accounting.logic import attachment
from ows_accounting.logic import budget_caps
from ows_accounting.logic import passthrough
from ows_accounting.logic import payment_holds
from ows_accounting.logic import payments
from ows_accounting.logic import period
from ows_accounting.logic import physical_reserves
from ows_accounting.logic import revenue
from ows_accounting.logic import transaction_types
from ows_accounting.logic import vendor_currency
from ows_accounting.models import currency
from ows_accounting.models import ows_contracts
from ows_accounting.utils.request_flask import GrassAccount
from ows_accounting.validation import validators

ALL_TRANSACTION_TYPES = 'all'
CUSTOM_REPORT_TRANSACTION_TYPES = 'AEA,AEV,AL,AS,AV,CE'
PHYSICAL_REPORT_TRANSACTION_TYPES = 'physical'


def _mock_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)

    return wrapper


@pytest.fixture
def fixture_client():
    """Creates an api test client fixture.
    """

    return api.app.test_client()


def test_health(fixture_client):
    """Tests health handler.
    """

    response = fixture_client.get('/hello/')
    assert response.status_code == 200


@patch('ows_accounting.handlers.reports')
def test_get_reports(mock_reports, fixture_client, monkeypatch):
    """Test reports handler.
    """

    monkeypatch.setattr(
        validators, 'validate_periods',
        MagicMock(return_value=response.Response([200, 201, 202])))
    mock_reports.get_reports.return_value = response.Response(
        status=200, message='success')
    result = fixture_client.get(
        '/reports?periods=200&account_id=1234&transaction_types=DT'
        '&file_type=txt&number_format=en_US&account_type=vendor')
    assert result.status_code == 200


def test_get_reports_invalid_period(fixture_client, monkeypatch):
    """Test reports handler error in validation.
    """

    mock_period = MagicMock()
    mock_period.return_value = response.create_error_response(
        message=error.ERROR_MESSAGE_INVALID_PERIOD,
        code=error.ERROR_CODE_INVALID_PERIOD)

    monkeypatch.setattr(validators, 'validate_periods', mock_period)

    result = fixture_client.get(
        '/reports?periods=200&account_id=1234&transaction_types=DT'
        '&file_type=txt&number_format=en_US&account_type=vendor')

    assert result.status_code == 400


@patch('ows_accounting.handlers.reports')
def test_get_reports_no_account_info(mock_reports, fixture_client):
    """Test reports handler.
    """

    result = fixture_client.get('/reports')
    assert result.status_code == 400


@patch('ows_accounting.handlers.reports')
def test_get_report(mock_reports, fixture_client, monkeypatch):
    """Test report handler.
    """

    monkeypatch.setattr(
        validators, 'validate_periods',
        MagicMock(return_value=response.Response([200, 201, 202])))

    mock_reports.get_report.return_value = response.Response(
        status=200, message='success')

    result = fixture_client.get(
        '/report?periods=200&transaction_types=DT&file_type=txt&'
        'number_format=en_US&account_id=18805&account_type=vendor')

    mock_reports.get_report.assert_any_call(
        '18805', 'vendor', '200', 'DT', 'txt', 'en_US')

    assert result.status_code == 302


@patch('ows_accounting.handlers.reports')
def test_get_report_failed(mock_reports, fixture_client, monkeypatch):
    """Test report handler.
    """

    monkeypatch.setattr(
        validators, 'validate_periods',
        MagicMock(return_value=response.Response([200, 201, 202])))

    mock_reports.get_report.return_value = response.Response(
        status=404, message='not_found')

    result = fixture_client.get(
        '/report?periods=200&transaction_types=DT&file_type=txt&'
        'number_format=en_US&account_id=18805&account_type=vendor')

    mock_reports.get_report.assert_any_call(
        '18805', 'vendor', '200', 'DT', 'txt', 'en_US')

    assert result.status_code == 404


@patch('ows_accounting.handlers.reports')
def test_get_report_link(mock_reports, fixture_client, monkeypatch):
    """Test report-link handler.
    """

    monkeypatch.setattr(
        validators, 'validate_periods',
        MagicMock(return_value=response.Response([200, 201, 202])))

    mock_reports.get_report.return_value = response.Response(
        status=200, message='success')

    result = fixture_client.get(
        '/report-link?periods=200&transaction_types=DT&file_type=txt&'
        'number_format=en_US&account_id=18805&account_type=vendor')

    mock_reports.get_report.assert_any_call(
        '18805', 'vendor', '200', 'DT', 'txt', 'en_US')

    assert result.status_code == 200


@patch('ows_accounting.handlers.reports')
def test_get_report_link_failed(mock_reports, fixture_client, monkeypatch):
    """Test report-link handler.
    """

    monkeypatch.setattr(
        validators, 'validate_periods',
        MagicMock(return_value=response.Response([200, 201, 202])))

    mock_reports.get_report.return_value = response.Response(
        status=404, message='not_found')

    result = fixture_client.get(
        '/report-link?periods=200&transaction_types=DT&file_type=txt&'
        'number_format=en_US&account_id=18805&account_type=vendor')

    mock_reports.get_report.assert_any_call(
        '18805', 'vendor', '200', 'DT', 'txt', 'en_US')

    assert result.status_code == 404


@patch('ows_accounting.handlers.reports')
def test_get_report_no_account_info(mock_reports, fixture_client):
    """Test report handler.
    """

    result = fixture_client.get(
        '/report?periods=200&transaction_types=DT&file_type=txt&'
        'number_format=en_US')

    assert not mock_reports.get_report.called
    assert result.status_code == 400


@patch('ows_accounting.handlers.reports')
def test_get_report_has_correct_header(
        mock_reports, fixture_client, monkeypatch):
    """Test report handler.
    """

    monkeypatch.setattr(
        validators, 'validate_periods',
        MagicMock(return_value=response.Response([200, 201, 202])))

    mock_reports.get_report.return_value = response.Response(
        status=200, message='http://some_url')

    result = fixture_client.get(
        '/report?periods=200&transaction_types=DT&file_type=txt&'
        'number_format=en_US&account_id=18805&account_type=vendor')

    mock_reports.get_report.assert_any_call(
        '18805', 'vendor', '200', 'DT', 'txt', 'en_US')

    assert result.status_code == 302
    assert result.headers.get(
        'Access-Control-Allow-Origin') == 'http://some_url'
    assert result.headers.get('Location') == 'http://some_url'


def test_post_report_no_account_info(fixture_client, ows_features_mock):
    """Test post_report handler with missing account info.
    """

    result = fixture_client.post('/report')
    assert result.status_code == 400


@patch('ows_accounting.handlers.reports')
def test_post_report_success(
        mock_reports, fixture_client, valid_get_report_request,
        test_header, monkeypatch):
    """Test post_report handler success."""

    monkeypatch.setattr(
        validators, 'validate_periods', MagicMock(
            return_value=response.Response([200, 201, 202])))

    mock_reports.add_report.return_value = response.Response(
        status=200, message='200 Created')

    result = fixture_client.post(
        '/report', data=json.dumps(valid_get_report_request),
        content_type='application/json', headers=test_header)

    assert result.status_code == 200


@patch('ows_accounting.handlers.datetime')
@patch('ows_accounting.handlers.reports')
def test_post_report_report_version_is_selected_correctly(
        mock_reports, mock_datetime, fixture_client, valid_get_report_request,
        test_header, monkeypatch):
    """Test post_report handler uses correct report version.
    """

    monkeypatch.setattr(
        validators, 'validate_periods', MagicMock(
            return_value=response.Response([200, 201, 202])))

    expected_datetime = datetime.datetime(year=2017, month=1, day=1)
    mock_datetime.datetime.now.return_value = expected_datetime
    expected_default_report_version = 2
    correlation_id = None
    account_id = '1234'
    account_type = 'vendor'
    periods = ['202', '203', '204']
    expected_transaction_types = ['AS', 'S']
    file_format = 'txt'
    number_format = 'en_US'
    email = 'baaa@lamb.com'
    vend_contact_id = 123
    first_name = 'Mary Had'
    last_name = 'A Little Lamb'
    requested_datetime = expected_datetime.strftime("%Y-%m-%d %H:%M:%S")

    request_data = copy.deepcopy(valid_get_report_request)
    request_data['transaction_types'] = 'AS,S'
    fixture_client.post(
        '/report', data=json.dumps(request_data),
        content_type='application/json', headers=test_header)

    mock_reports.add_report.assert_any_call(
        correlation_id, account_id, account_type, periods,
        expected_transaction_types, file_format, number_format, email,
        vend_contact_id, first_name, last_name, requested_datetime,
        expected_default_report_version)


def test_post_reports_invalid_period(
        fixture_client, valid_get_report_request, test_header, monkeypatch,
        ows_features_mock):
    """Test reports handler error in validation.
    """

    mock_period = MagicMock()
    mock_period.return_value = response.create_error_response(
        message=error.ERROR_MESSAGE_INVALID_PERIOD,
        code=error.ERROR_CODE_INVALID_PERIOD)

    monkeypatch.setattr(validators, 'validate_periods', mock_period)

    result = fixture_client.post(
        '/report', data=json.dumps(valid_get_report_request),
        content_type='application/json', headers=test_header)

    assert result.status_code == 400


def test_get_transaction_types_success(
        fixture_client, test_header, monkeypatch, ows_features_mock):
    """Test transaction_types handler.
    """

    monkeypatch.setattr(
        validators, 'validate_periods',
        MagicMock(return_value=response.Response([200, 201, 202])))

    monkeypatch.setattr(
        transaction_types, 'get_transaction_types',
        MagicMock(return_value=response.Response(
            status=200, message='success')))

    result = fixture_client.get(
        '/transaction_types?periods=200', headers=test_header)

    assert result.status_code == 200


def test_get_transaction_types_invalid_period(
        fixture_client, test_header, monkeypatch, ows_features_mock):
    """Test transaction_types handler.
    """

    mock_period = MagicMock()
    mock_period.return_value = response.create_error_response(
        message=error.ERROR_MESSAGE_INVALID_PERIOD,
        code=error.ERROR_CODE_INVALID_PERIOD)

    monkeypatch.setattr(validators, 'validate_periods', mock_period)

    result = fixture_client.get(
        '/transaction_types?periods=200', headers=test_header)

    assert result.status_code == 400


def test_get_transaction_types_invalid_params(
        fixture_client, test_header, monkeypatch, ows_features_mock):
    """Test transaction_types handler with too many params.
    """

    result = fixture_client.get(
        '/transaction_types?periods=200&transaction_types=DT',
        headers=test_header)

    assert result.status_code == 400


@patch(
    'ows_accounting.logic.transaction_types.get_transaction_types',
    return_value=response.Response({'items': []}))
def test_get_transaction_types_no_account_info(
        mock_object, fixture_client, ows_features_mock):
    """Test transaction types handler with missing account info.
    """

    result = fixture_client.get('/transaction_types')
    assert result.status_code == 400


def test_get_revenue_success(
        fixture_client, test_header, monkeypatch, ows_features_mock):
    """Test revenue handler."""
    monkeypatch.setattr(
        revenue, 'get_revenue',
        MagicMock(return_value=response.Response(
            status=200, message='success')))

    result = fixture_client.get(
        '/revenue?recent=5', headers=test_header)

    assert result.status_code == 200


def test_get_revenue_too_many_params(
        fixture_client, test_header, monkeypatch, ows_features_mock):
    """Test revenue handler with too many params."""

    result = fixture_client.get(
        '/revenue?revenue=10&foo=bar',
        headers=test_header)

    assert result.status_code == 400


def test_get_revenue_invalid_recent(
        fixture_client, test_header, ows_features_mock):
    """Test revenue handler with wrong recent param."""

    result = fixture_client.get(
        '/revenue?revenue=something',
        headers=test_header)

    assert result.status_code == 400


@patch(
    'ows_accounting.logic.revenue.get_revenue',
    return_value=response.Response({'foo': 'bar'}))
def test_get_revenue_no_account_info(
        mock_object, fixture_client, ows_features_mock):
    """Test revenue handler with missing account info."""

    result = fixture_client.get('/revenue')
    assert result.status_code == 400


def test_get_payments_success(
        fixture_client, test_header, monkeypatch, ows_features_mock):
    """Test payments handler."""
    monkeypatch.setattr(
        payments, 'get_payments',
        MagicMock(return_value=response.Response(
            status=200, message='success')))

    result = fixture_client.get(
        '/payments?recent=5', headers=test_header)

    assert result.status_code == 200


def test_get_payments_too_many_params(
        fixture_client, test_header, monkeypatch, ows_features_mock):
    """Test payments handler with too many params."""

    result = fixture_client.get(
        '/payments?recent=10&foo=bar',
        headers=test_header)

    assert result.status_code == 400


def test_get_payments_invalid_recent(
        fixture_client, test_header, ows_features_mock):
    """Test payments handler with wrong recent param."""

    result = fixture_client.get(
        '/payments?foo=something',
        headers=test_header)

    assert result.status_code == 400


@patch(
    'ows_accounting.logic.payments.get_payments',
    return_value=response.Response({'foo': 'bar'}))
def test_get_payments_no_account_info(
        mock_object, fixture_client, ows_features_mock):
    """Test payments handler with missing account info."""

    result = fixture_client.get('/payments')
    assert result.status_code == 400


def test_get_active_holds(fixture_client, monkeypatch, hold_active_fixture):
    """Test get_active_holds handler."""
    data = [hold_active_fixture]
    monkeypatch.setattr(
        payment_holds, 'get_all_active_holds',
        MagicMock(return_value=response.Response(data)))

    result = fixture_client.get('/holds/active')
    response_message = json.loads(result.data.decode())
    assert result
    assert response_message == data
    payment_holds.get_all_active_holds.assert_called_with(None, None, None)
    assert payment_holds.get_all_active_holds.call_count == 1


def test_get_active_holds_pagination(
        fixture_client, monkeypatch, hold_active_fixture):
    """Test get_active_holds handler."""
    data = [hold_active_fixture]
    monkeypatch.setattr(
        payment_holds, 'get_all_active_holds',
        MagicMock(return_value=response.Response(data)))

    result = fixture_client.get('/holds/active?limit=10&offset=5')
    response_message = json.loads(result.data.decode())
    assert result
    assert response_message == data
    payment_holds.get_all_active_holds.assert_called_with(10, 5, None)
    assert payment_holds.get_all_active_holds.call_count == 1


def test_get_active_holds_no_data(fixture_client, monkeypatch):
    """Test get_active_holds handler when no active holds exist."""
    monkeypatch.setattr(
        payment_holds, 'get_all_active_holds',
        MagicMock(return_value=response.Response([])))

    result = fixture_client.get('/holds/active')
    response_message = json.loads(result.data.decode())
    assert result
    assert response_message == []
    payment_holds.get_all_active_holds.assert_called_with(None, None, None)
    assert payment_holds.get_all_active_holds.call_count == 1


def test_get_active_holds_with_vendors(
        fixture_client, monkeypatch, hold_active_fixture):
    """Test get_active_holds handler with vendor_ids param."""
    data = [hold_active_fixture]
    monkeypatch.setattr(
        payment_holds, 'get_all_active_holds',
        MagicMock(return_value=response.Response(data)))

    result = fixture_client.get('/holds/active?vendor_ids=1,2')
    response_message = json.loads(result.data.decode())
    assert result
    assert response_message == data
    payment_holds.get_all_active_holds.assert_called_with(None, None, {1, 2})
    assert payment_holds.get_all_active_holds.call_count == 1


def test_get_active_holds_with_invalid_vendors(
        fixture_client, monkeypatch, hold_active_fixture):
    """Test get_active_holds handler with invalid vendor_ids param."""
    data = [hold_active_fixture]
    monkeypatch.setattr(
        payment_holds, 'get_all_active_holds',
        MagicMock(return_value=response.Response(data)))

    result = fixture_client.get('/holds/active?vendor_ids=1,dummy,2')
    assert result.status_code == 400
    assert payment_holds.get_all_active_holds.call_count == 0


def test_get_active_holds_with_all_params(
        fixture_client, monkeypatch, hold_active_fixture):
    """Test get_active_holds handler with all optional params."""
    data = [hold_active_fixture]
    monkeypatch.setattr(
        payment_holds, 'get_all_active_holds',
        MagicMock(return_value=response.Response(data)))

    url = '/holds/active?limit=5&offset=10&vendor_ids=2,7123,2584,8869,7070'
    result = fixture_client.get(url)
    assert result
    payment_holds.get_all_active_holds.assert_called_with(
        5, 10, {2, 7123, 2584, 8869, 7070})
    assert payment_holds.get_all_active_holds.call_count == 1


def test_edit_hold(fixture_client, monkeypatch, hold_active_fixture):
    """Test edit_hold handler."""
    monkeypatch.setattr(
        payment_holds, 'update_hold_by_id',
        MagicMock(return_value=response.Response(hold_active_fixture)))
    put_data = {'description': 'new desc', 'status': 'active'}
    header_data = {'Orchard-User-Id': 'oa:123'}
    result = fixture_client.put(
        '/holds/1', headers=header_data, data=json.dumps(put_data),
        content_type='application/json', )

    response_message = json.loads(result.data.decode())
    assert result
    assert response_message == hold_active_fixture
    payment_holds.update_hold_by_id.assert_called_with(
        1, 'oa:123', 'active', 'new desc')
    assert payment_holds.update_hold_by_id.call_count == 1


def test_edit_hold_error(fixture_client, monkeypatch):
    """Test edit_hold handler when some error from logic."""
    monkeypatch.setattr(
        payment_holds, 'update_hold_by_id',
        MagicMock(return_value=response.create_error_response(
            error.ERROR_CODE_INVALID_REQUEST, 'missing')))
    header_data = {'Orchard-User-Id': 'oa:123'}
    result = fixture_client.put(
        '/holds/1', headers=header_data, content_type='application/json',
        data=json.dumps({}))

    assert result.status_code == 400
    payment_holds.update_hold_by_id.assert_called_with(1, 'oa:123', None, None)
    assert payment_holds.update_hold_by_id.call_count == 1


def test_get_holds_by_id(fixture_client, monkeypatch, hold_active_fixture):
    """Test get_holds_by_id handler."""
    monkeypatch.setattr(
        payment_holds, 'get_holds_by_id',
        MagicMock(return_value=response.Response(hold_active_fixture)))

    result = fixture_client.get('/holds/11')
    response_message = json.loads(result.data.decode())
    assert result
    assert response_message == hold_active_fixture
    payment_holds.get_holds_by_id.assert_called_with(11)
    assert payment_holds.get_holds_by_id.call_count == 1


def test_get_holds_by_id_invalid_id(fixture_client, monkeypatch):
    """Test get_holds_by_id handler with invalid hold_id."""
    monkeypatch.setattr(
        payment_holds, 'get_holds_by_id',
        MagicMock(return_value=response.create_not_found_response(
            'No hold found with this id.')))

    result = fixture_client.get('/holds/1233434534')
    assert result.status_code == 404
    payment_holds.get_holds_by_id.assert_called_with(1233434534)
    assert payment_holds.get_holds_by_id.call_count == 1


def test_get_holds_for_vendor(
        fixture_client, monkeypatch, hold_active_fixture):
    """Test get_holds_for_vendor handler."""
    data = [hold_active_fixture]
    monkeypatch.setattr(
        payment_holds, 'get_holds_by_vendor_id',
        MagicMock(return_value=response.Response(data)))

    result = fixture_client.get('/holds/vendor/7123')
    response_message = json.loads(result.data.decode())
    assert result
    assert response_message == data
    payment_holds.get_holds_by_vendor_id.assert_called_with(7123)
    assert payment_holds.get_holds_by_vendor_id.call_count == 1


def test_get_holds_for_vendor_invalid_vendor(fixture_client, monkeypatch):
    """Test get_holds_for_vendor handler with invalid vendor_id."""
    monkeypatch.setattr(
        payment_holds, 'get_holds_by_vendor_id',
        MagicMock(return_value=response.create_not_found_response(
            'No vendor exist with this id.')))

    result = fixture_client.get('/holds/vendor/1233434534')
    assert result.status_code == 404


def test_create_hold_for_vendor(
        fixture_client, monkeypatch, hold_active_fixture):
    """Test create_hold_for_vendor handler."""
    monkeypatch.setattr(
        payment_holds, 'create_hold_for_vendor',
        MagicMock(return_value=response.Response(hold_active_fixture)))
    put_data = {'description': 'new desc', 'status': 'active'}
    header_data = {'Orchard-User-Id': 'oa:123'}
    result = fixture_client.post(
        '/holds/vendor/7123', headers=header_data, data=json.dumps(put_data),
        content_type='application/json', )

    response_message = json.loads(result.data.decode())
    assert result
    assert response_message == hold_active_fixture
    payment_holds.create_hold_for_vendor.assert_called_with(
        7123, 'oa:123', 'active', 'new desc')
    assert payment_holds.create_hold_for_vendor.call_count == 1


def test_create_hold_for_vendor_error(fixture_client, monkeypatch):
    """Test create_hold_for_vendor handler when some error from logic."""
    monkeypatch.setattr(
        payment_holds, 'create_hold_for_vendor',
        MagicMock(return_value=response.create_error_response(
            error.ERROR_CODE_INVALID_REQUEST, 'missing')))
    header_data = {'Orchard-User-Id': 'oa:123'}
    result = fixture_client.post(
        '/holds/vendor/7123', headers=header_data,
        content_type='application/json', data=json.dumps({}))

    assert result.status_code == 400
    payment_holds.create_hold_for_vendor.assert_not_called()


def test_create_hold_for_invalid_header(fixture_client):
    """Test create_hold_for_vendor handler with invalid header."""
    header_data = {'Grass-Id': 'oa:123'}
    post_data = {'description': 'new desc', 'status': 'active'}
    result = fixture_client.post(
        '/holds/vendor/7123', headers=header_data,
        content_type='application/json', data=json.dumps(post_data))

    assert result.status_code == 400
    response_message = json.loads(result.data.decode())
    assert response_message['message'] == \
        error.ERROR_MESSAGE_INVALID_ORCHARD_USER_HEADERS


def test_create_hold_for_invalid_status(fixture_client):
    """Test create_hold_for_vendor handler with invalid status data."""
    header_data = {'Orchard-User-Id': 'oa:123'}
    post_data = {'description': 'new desc', 'status': 'dummy'}
    result = fixture_client.post(
        '/holds/vendor/7123', headers=header_data,
        content_type='application/json', data=json.dumps(post_data))

    assert result.status_code == 400


def test_get_attachments(
        fixture_client, test_header, monkeypatch, attachments_fixture):
    """Test get_attachments handler."""
    monkeypatch.setattr(
        attachment, 'get_attachments', MagicMock(
            return_value=response.Response(attachments_fixture)))

    result = fixture_client.get(
        '/attachments?periods=216', headers=test_header)
    response_message = json.loads(result.data.decode())
    assert result
    assert response_message == attachments_fixture
    attachment.get_attachments.assert_called_once_with(
        '1234', 'vendor', ['216'])


def test_get_attachments_invalid_account(
        fixture_client, monkeypatch, test_header_subaccount):
    """Test get_attachments for subaccount"""
    result = fixture_client.get(
        '/attachments?periods=216', headers=test_header_subaccount)
    assert result.status_code == 403


@pytest.mark.parametrize('periods, expected_periods, file_name', [
    ('226', ['226'], 'test.csv'),
    ('226,227,228', ['226', '227', '228'], 'test.csv'),
    ('226,227,228', ['226', '227', '228'], 'test.csv(228)'),
])
def test_get_attachment(
        fixture_client, test_header, monkeypatch, attachments_fixture,
        periods, expected_periods, file_name):
    """Test get_attachment handler."""
    attachment_fixture = attachments_fixture[0]
    monkeypatch.setattr(
        attachment, 'get_attachment', MagicMock(
            return_value=response.Response(attachment_fixture)))
    url = '/attachment?periods={periods}&file_name={file_name}'.format(
        periods=periods, file_name=file_name)
    result = fixture_client.get(url, headers=test_header)
    response_message = json.loads(result.data.decode())
    assert result
    assert response_message == attachment_fixture
    attachment.get_attachment.assert_called_once_with(
        '1234', 'vendor', expected_periods, file_name)


def test_get_attachment_invalid_filename(
        fixture_client, monkeypatch, test_header):
    """Test get_attachment for not valid filename"""
    result = fixture_client.get(
        '/attachment?periods=216&file_name=tes%#t.1csv', headers=test_header)
    assert result.status_code == 400


def test_get_attachment_invalid_account(
        fixture_client, monkeypatch, test_header_subaccount):
    """Test get_attachment for subaccount"""
    result = fixture_client.get(
        '/attachment?periods=216&file_name=test.csv',
        headers=test_header_subaccount)
    assert result.status_code == 403


def test_get_accounting_period_success(
        fixture_client, test_header, monkeypatch):
    """Test accounting period handler."""
    monkeypatch.setattr(config, 'ACTIVE_ACCOUNTING_PERIOD', 123)

    result = fixture_client.get('/accounting_period')
    assert result.status_code == 200
    response_message = json.loads(result.get_data(True))
    assert response_message == {'accounting_period': 123}


def test_get_accounting_periods_succcess(
        fixture_client, test_header,
        fixture_monthly_accounting_periods_information, monkeypatch):
    """Test accounting_periods handler."""
    periods_response = response.Response(
        fixture_monthly_accounting_periods_information)

    monkeypatch.setattr(
        period, 'get_all_periods', MagicMock(
            return_value=periods_response))

    result = fixture_client.get('/accounting_periods', headers=test_header)

    assert result.status_code == 200

    response_message = json.loads(result.get_data(True))
    assert response_message == fixture_monthly_accounting_periods_information


def test_get_accounting_periods_no_account_info(fixture_client):
    """Test accounting_periods handler with missing account info."""
    result = fixture_client.get('/accounting_periods')

    assert result.status_code == 400


def test_get_eq_bonus_no_account_info(fixture_client):
    """Test get_eq_bonus handler with missing account info."""
    result = fixture_client.get('/eq_bonus?period_id=233')
    assert result.status_code == 400


@patch('ows_accounting.handlers.passthrough')
def test_get_eq_bonus_correct_header(
        mock_passthrough, fixture_client, test_header):
    """Test get_eq_bonus handler with correct headers."""
    test_data = {'test': 'data'}
    mock_passthrough.get_eq_bonus.return_value = response.Response(
        status=200, message=test_data)
    result = fixture_client.get(
        '/eq_bonus?period_id=233', headers=test_header)
    assert result.status_code == 200
    assert json.loads(result.data.decode()) == test_data
    mock_passthrough.get_eq_bonus.assert_called_with('1234', '233')


@patch('ows_accounting.handlers.passthrough')
def test_get_eq_bonus_correct_header_subaccount_returns_no_data(
        mock_passthrough, fixture_client, test_header_subaccount):
    """Test get_eq_bonus handler with correct headers."""
    test_data = {'test': 'data'}
    mock_passthrough.get_eq_bonus.return_value = response.Response(
        status=200, message=test_data)
    result = fixture_client.get(
        '/eq_bonus?period_id=233', headers=test_header_subaccount)
    assert result.status_code == 200
    assert json.loads(result.data.decode()) == {}
    assert mock_passthrough.get_eq_bonus.call_count == 0


def test_get_eq_bonus_payment_no_account_info(fixture_client):
    """Test get_eq_bonus handler with missing account info."""
    result = fixture_client.get('/eq_bonus_payment?period_id=233')
    assert result.status_code == 400


@patch('ows_accounting.handlers.passthrough')
def test_get_eq_bonus_payment_correct_header(
        mock_passthrough, fixture_client, test_header):
    """Test get_eq_bonus handler with correct headers."""
    test_data = {'test': 'data'}
    mock_passthrough.get_eq_payment_details.return_value = response.Response(
        status=200, message=test_data)
    result = fixture_client.get(
        '/eq_bonus_payment?period_id=233', headers=test_header)
    assert result.status_code == 200
    assert json.loads(result.data.decode()) == test_data
    mock_passthrough.get_eq_payment_details.assert_called_with('1234', '233')


@patch('ows_accounting.handlers.passthrough')
def test_get_eq_bonus_payment_correct_header_subaccount_returns_no_data(
        mock_passthrough, fixture_client, test_header_subaccount):
    """Test get_eq_bonus handler with correct headers."""
    test_data = {'test': 'data'}
    mock_passthrough.get_eq_payment_details.return_value = response.Response(
        status=200, message=test_data)
    result = fixture_client.get(
        '/eq_bonus_payment?period_id=233', headers=test_header_subaccount)
    assert result.status_code == 200
    assert json.loads(result.data.decode()) == []
    assert mock_passthrough.get_eq_payment_details.call_count == 0


def test_get_average_monthly_net_revenue(monkeypatch, fixture_client):
    """Test get_average_monthly_net_revenue route."""
    payload = {
        'average_monthly_net_revenue': 1000
    }

    monkeypatch.setattr(
        revenue,
        'get_average_monthly_net_revenue',
        MagicMock(return_value=response.Response(payload)))

    account_type = 'vendor'
    account_id = 1234
    url = '/{0}/{1}/average-monthly-net-revenue'.format(
        account_type, account_id)

    result = fixture_client.get(url)

    assert result.status_code == 200
    assert json.loads(result.get_data(as_text=True)) == payload


def test_get_average_monthly_net_revenue_invalid_headers_vendor(
        monkeypatch, fixture_client):
    """Test get_average_monthly_net_revenue route with invalid headers."""
    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=('vendor', 4567)))

    account_type = 'vendor'
    account_id = 1234
    url = '/{0}/{1}/average-monthly-net-revenue'.format(
        account_type, account_id)

    result = fixture_client.get(url)

    assert result.status_code == 403


def test_get_average_monthly_net_revenue_invalid_headers_subaccount(
        monkeypatch, fixture_client):
    """Test get_average_monthly_net_revenue route with invalid headers."""
    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=('subaccount', 4567)))

    account_type = 'subaccount'
    account_id = 1234
    url = '/{0}/{1}/average-monthly-net-revenue'.format(
        account_type, account_id)

    result = fixture_client.get(url)

    assert result.status_code == 403


def test_get_budget_caps_success(monkeypatch, fixture_client):
    """Test get_budget_caps route with successful result."""
    payload = {
        'items': [{
            'account_type': 'vendor',
            'account_id': 123,
            'monthly_total_budget': 2500,
            'budget_type': 'white_list'
        }]}

    monkeypatch.setattr(
        budget_caps,
        'get_budget_caps',
        MagicMock(return_value=response.Response(payload)))

    url = '/budget-caps'

    result = fixture_client.get(url)

    assert result.status_code == 200
    assert json.loads(result.get_data(as_text=True)) == payload


def test_get_budget_caps_bad_request(monkeypatch, fixture_client):
    """Test get_budget_caps route with bad request status."""

    monkeypatch.setattr(
        budget_caps,
        'get_budget_caps',
        MagicMock(return_value=response.create_error_response(
            code='error_code_bad_request', message='error_message_bad_request'
        )))

    url = '/budget-caps'

    result = fixture_client.get(url)

    assert result.status_code == 400


def test_get_budget_caps_error(monkeypatch, fixture_client):
    """Test get_budget_caps route with bad request status."""

    monkeypatch.setattr(
        budget_caps,
        'get_budget_caps',
        MagicMock(return_value=response.create_fatal_response(
            message='fatal_error')))

    url = '/budget-caps'

    result = fixture_client.get(url)

    assert result.status_code == 500


def test_get_physical_reserves(monkeypatch, fixture_client):
    """Test get physical reserves."""

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        MagicMock(return_value=True))

    monkeypatch.setattr(
        physical_reserves,
        'get_physical_reserves',
        MagicMock(return_value=response.Response()))

    url = '/get-physical-reserves?vendor_id=1&period_id=1'

    result = fixture_client.get(url)

    assert result.status_code == 200


def test_get_physical_reserves_fail(monkeypatch, fixture_client):
    """Test get physical reserves fails missed parameters."""

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        MagicMock(return_value=True))

    monkeypatch.setattr(
        physical_reserves,
        'get_physical_reserves',
        MagicMock(return_value=response.Response()))

    url = '/get-physical-reserves'

    result = fixture_client.get(url)

    assert result.status_code == 400


def test_get_eq_bonus_for_account_success(monkeypatch, fixture_client):
    """Test get equity bonus for account."""

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        MagicMock(return_value=True))

    monkeypatch.setattr(
        passthrough,
        'get_eq_bonus',
        MagicMock(return_value=response.Response()))

    url = '/vendor/123/eq_bonus'

    result = fixture_client.get(url)

    assert result.status_code == 200


def test_get_eq_bonus_for_account_failure(monkeypatch, fixture_client):
    """Test get equity bonus for account."""

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        MagicMock(return_value=True))

    monkeypatch.setattr(
        passthrough,
        'get_eq_bonus',
        MagicMock(return_value=response.Response()))

    url = '/vendor/cvd/eq_bonus'

    result = fixture_client.get(url)
    assert result.status_code == 404


def test_get_eq_bonus_payment_for_account_success(monkeypatch, fixture_client):
    """Test get equity bonus payment details for account."""

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        MagicMock(return_value=True))

    monkeypatch.setattr(
        passthrough,
        'get_eq_payment_details',
        MagicMock(return_value=response.Response()))

    url = '/vendor/123/eq_bonus_payment'

    result = fixture_client.get(url)

    assert result.status_code == 200


def test_get_eq_bonus_payment_for_account_failure(monkeypatch, fixture_client):
    """Test get equity bonus payment details for account."""

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        MagicMock(return_value=True))

    monkeypatch.setattr(
        passthrough,
        'get_eq_payment_details',
        MagicMock(return_value=response.Response()))

    url = '/vendor/vfr/eq_bonus_payment'

    result = fixture_client.get(url)

    assert result.status_code == 404


def test_get_vendor_currency_success(
        monkeypatch, fixture_client, test_header):
    """Test get_vendor_currency."""
    mock_result = {
        'vendor_id': 1234,
        'currency_id': 1,
        'code': 'USD',
        'symbol': '$'}

    mock_ows_contract = {'items': [
        {'id': 7157428, 'period_id': 251, 'vendor_id': 1234, 'currency_id': 1},
        {'id': 7157421, 'period_id': 250, 'vendor_id': 1234, 'currency_id': 1}
    ]}

    mock_currency = {
        'id': 1,
        'code': 'USD',
        'symbol': '$'}

    monkeypatch.setattr(
        ows_contracts, 'get_booked_contracts',
        MagicMock(return_value=response.Response(mock_ows_contract)))

    monkeypatch.setattr(
        currency, 'get_currency_by_id',
        MagicMock(return_value=response.Response(mock_currency)))

    monkeypatch.setattr(
        vendor_currency, 'get_currency_by_vendor_id',
        MagicMock(return_value=response.Response(mock_result)))

    result = fixture_client.get('/vendor-currency', headers=test_header)
    response_message = json.loads(result.data.decode())

    assert result
    assert response_message == mock_result
    vendor_currency.get_currency_by_vendor_id.assert_called_with(
        GrassAccount('vendor', '1234'))

    assert vendor_currency.get_currency_by_vendor_id.call_count == 1


def test_get_accounting_period_details(
        monkeypatch, fixture_client):
    """Test get_accounting_period_details."""
    mock_result = {
        'year': '2020',
        'quarter': 1,
        'month': 2,
        'period_type': 'month',
        'first_period_id': 254,
        'last_period_id': 254
    }

    monkeypatch.setattr(
        accounting_intervals, 'get_period_by_id',
        MagicMock(return_value=response.Response(mock_result)))

    result = fixture_client.get('/accounting_period_details/254')

    response_message = json.loads(result.data.decode())

    assert result
    assert response_message == mock_result

    accounting_intervals.get_period_by_id.assert_called_with(254)
    assert accounting_intervals.get_period_by_id.call_count == 1


def test_get_accounting_intervals(
        test_header, monkeypatch, fixture_client):
    """Test get_accounting_period_details."""

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        MagicMock(return_value=True))

    mock_result = {
        'type': 'quarter',
        'number': 1,
        'year': '2020',
        'currency_id': 4,
        'periods': [
            253
        ]
    }

    monkeypatch.setattr(
        accounting_intervals, 'get_intervals_from_contracts',
        MagicMock(return_value=response.Response(mock_result)))

    result = fixture_client.get('/accounting-intervals/1', headers=test_header)

    response_message = json.loads(result.data.decode())

    assert result
    assert response_message == mock_result

    accounting_intervals \
        .get_intervals_from_contracts.assert_called_with('vendor', '1234', 1)
    assert accounting_intervals \
        .get_intervals_from_contracts.call_count == 1