"""Test initiate_report_run handler."""

import json
from unittest.mock import MagicMock

import pytest
import requests
from oto import response
from owsrequest import access

import application
from reporting.constants import mode as mc
from reporting.models import ows_account


def test_initiate_report_run_success(client, valid_post_headers, mocker):
    """Test successful initiation of a report run."""
    report_token = 'report_01'
    run_token = 'run_token_number_9'
    params = {
        'param_limit': None,
        'param_vendor_id': 7123,
        'param_subaccount_id': None,
    }

    mocker.patch.object(
        access,
        'verify_grass_access',
        return_value=response.Response(status=200),
    )

    location_header = '{base_uri}/{report_token}/runs/{run_token}'.format(
        base_uri=mc.MODE_REPORTS_URL,
        report_token=report_token,
        run_token=run_token,
    )

    mock_response = MagicMock(
        status_code=302, headers={'Location': location_header}
    )

    mocker.patch.object(requests, 'get', return_value=mock_response)

    with application.app.test_request_context():
        result = client.post(
            '/report/{}/run'.format(report_token),
            headers=valid_post_headers,
            data=json.dumps(params),
        )
        result_data = json.loads(result.data.decode('utf-8'))

        assert result.status_code == 200
        assert result_data.get('run_token') == run_token


def test_initiate_report_run_no_report_found(
    client, valid_post_headers, mocker
):
    """Test no report found response when initiating a report run."""
    report_token = 'report_01'
    params = {
        'param_limit': None,
        'param_vendor_id': 7123,
        'param_subaccount_id': None,
    }
    mock_response = MagicMock(status_code=404)

    mocker.patch.object(
        access,
        'verify_grass_access',
        return_value=response.Response(status=200),
    )

    mocker.patch.object(requests, 'get', return_value=mock_response)

    with application.app.test_request_context():
        result = client.post(
            '/report/{}/run'.format(report_token),
            headers=valid_post_headers,
            data=json.dumps(params),
        )
        result_data = json.loads(result.data.decode('utf-8'))

        assert result.status_code == 404
        assert result_data.get('message') == 'No report found'


def test_initiate_report_run_mode_fatal_failure(
    client, valid_post_headers, mocker
):
    """Test fatal response when initiating a report run."""
    report_token = 'report_01'
    params = {
        'param_limit': None,
        'param_vendor_id': 7123,
        'param_subaccount_id': None,
    }
    mock_response = MagicMock(status_code=500)

    mocker.patch.object(
        access,
        'verify_grass_access',
        return_value=response.Response(status=200),
    )

    mocker.patch.object(requests, 'get', return_value=mock_response)

    with application.app.test_request_context():
        result = client.post(
            '/report/{}/run'.format(report_token),
            headers=valid_post_headers,
            data=json.dumps(params),
        )
        result_data = json.loads(result.data.decode('utf-8')).get('message')

        assert result.status_code == 500
        assert result_data == 'There was a problem completing your request'


def test_initiate_report_run_on_vendor_response_failure(
    client, valid_post_headers, mocker
):
    """Test fatal response when initiating a report run."""
    report_token = 'report_01'
    params = {}

    mock_response = MagicMock(status_code=500)
    mocker.patch.object(
        access,
        'verify_grass_access',
        return_value=response.Response(status=200),
    )
    mocker.patch.object(requests, 'get', return_value=mock_response)
    mocker.patch.object(
        ows_account,
        'get_vendor_id_from_grass_headers',
        return_value=mock_response,
    )

    with application.app.test_request_context():
        result = client.post(
            '/report/{}/run'.format(report_token),
            headers=valid_post_headers,
            data=json.dumps(params),
        )
        result_data = json.loads(result.data.decode('utf-8')).get('message')

        assert result.status_code == 500
        assert result_data == 'There was a problem completing your request'


@pytest.mark.parametrize(
    'access_response_code, expected_response_code', [(403, 403), (400, 400)]
)
def test_initiate_report_run_access_failure(
    client,
    valid_post_headers,
    mocker,
    access_response_code,
    expected_response_code,
):
    """Test fatal response when grass access is not granted."""
    report_token = 'report_01'

    params = {
        'param_limit': None,
        'param_vendor_id': 7123,
        'param_subaccount_id': None,
    }

    mocker.patch.object(
        access,
        'verify_grass_access',
        return_value=response.Response(status=access_response_code),
    )

    with application.app.test_request_context():
        result = client.post(
            '/report/{}/run'.format(report_token),
            headers=valid_post_headers,
            data=json.dumps(params),
        )
        assert result.status_code == expected_response_code