"""Integration API tests for OWS reporting."""

import json
from os import getenv

import pytest
from auth.auth import GrassAuth, UserType

from tests.utils.api_client import APIClient

REPORT_TYPES_WITH_EXPECTATIONS = [
    {
        'report_type_string': 'workstation-physical-product-view-US',
        'contains_coop_data': False,
        'contains_overstock_data': True,
    },
    {
        'report_type_string': 'workstation-physical-product-view-CA',
        'contains_coop_data': False,
        'contains_overstock_data': False,
    },
    {
        'report_type_string': 'workstation-physical-product-view-UK',
        'contains_coop_data': False,
        'contains_overstock_data': False,
    },
    {
        'report_type_string': 'workstation-physical-product-view-US-coop',
        'contains_coop_data': True,
        'contains_overstock_data': True,
    },
    {
        'report_type_string': 'workstation-physical-retail-view-US',
        'contains_coop_data': False,
        'contains_overstock_data': False,
    },
    {
        'report_type_string': 'workstation-physical-retail-view-CA',
        'contains_coop_data': False,
        'contains_overstock_data': False,
    },
    {
        'report_type_string': 'workstation-physical-retail-view-US-coop',
        'contains_coop_data': True,
        'contains_overstock_data': False,
    },
    {
        'report_type_string': 'workstation-physical-historical-product-view-US',  # noqa: E501
        'contains_coop_data': False,
        'contains_overstock_data': True,
        'historical': True,
    },
    {
        'report_type_string': 'workstation-physical-historical-product-view-CA',  # noqa: E501
        'contains_coop_data': False,
        'contains_overstock_data': False,
        'historical': True,
    },
    {
        'report_type_string': 'workstation-physical-historical-product-view-US-coop',  # noqa: E501
        'contains_coop_data': True,
        'contains_overstock_data': True,
        'historical': True,
    },
    {
        'report_type_string': 'workstation-physical-retail-aggregate-view-US',
        'contains_coop_data': False,
        'contains_overstock_data': False,
    },
    {
        'report_type_string': 'workstation-physical-retail-aggregate-view-CA',
        'contains_coop_data': False,
        'contains_overstock_data': False,
    },
    {
        'report_type_string': 'workstation-point-of-sale-by-product-country-view-EU',  # noqa: E501
        'contains_coop_data': False,
        'contains_overstock_data': False,
    },
    {
        'report_type_string': 'workstation-point-of-sale-by-product-view-EU',
        'contains_coop_data': False,
        'contains_overstock_data': False,
    },
    {
        'report_type_string': 'workstation-point-of-sale-by-country-view-EU',
        'contains_coop_data': False,
        'contains_overstock_data': False,
    },
]


def workstation_session_token():
    """Initialize Thirty Tigers grass auth token at start of test session."""
    return GrassAuth(UserType.WORKSTATION, 44807).grass_token


def api_client():
    """Create APIClient object with QA URL and Workstation session token."""
    return APIClient(getenv('BASE_QA_URL'), workstation_session_token())


@pytest.fixture
def coop_columns():
    """Return all non-historical co-op columns."""
    return ['Total RTD Co-Op $', 'Closed Co-Op $', 'Open Co-Op $']


@pytest.fixture
def overstock_columns():
    """Return all overstock columns."""
    return ['12M Overstock', '24M Overstock']


@pytest.fixture
def coop_historical():
    """Return historical co-op column."""
    return 'Total Co-Op $'


@pytest.fixture
def historical_params():
    """Historical reporting params."""
    return {
        'param_limit': 1,
        'param_start_year': 2017,
        'param_start_month': 3,
        'param_end_year': 2018,
        'param_end_month': 4,
    }


def report_run(report_type, params):
    """Report test run."""
    if 'historical' in report_type:
        return api_client().post(
            report_type['report_type_string'], json_params=params
        )
    else:
        return api_client().post(report_type['report_type_string'])


def check_historical_coop_reports(
    json_response_columns, coop_columns, coop_historical
):
    """Check historical co-op report output for co-op columns."""
    assert coop_historical in json_response_columns, (
        'Expected to find {} in {}'.format(
            coop_historical, json_response_columns
        )
    )
    assert not set(coop_columns).issubset(json_response_columns), (
        'Expected {} would not appear in {}'.format(
            coop_columns, json_response_columns
        )
    )


def check_non_historical_coop_reports(
    json_response_columns, coop_columns, coop_historical
):
    """Check non-historical co-op report output for co-op columns."""
    assert set(coop_columns).issubset(json_response_columns), (
        'Expected to find {} in {}'.format(coop_columns, json_response_columns)
    )
    assert coop_historical not in json_response_columns, (
        'Expected {} would not appear in {}'.format(
            coop_historical, json_response_columns
        )
    )


def check_non_coop_reports(
    json_response_columns, coop_columns, coop_historical
):
    """Check non-co-op report output for co-op columns."""
    assert not set(coop_columns).issubset(json_response_columns), (
        'Expected {} would not appear in {}'.format(
            coop_columns, json_response_columns
        )
    )
    assert coop_historical not in json_response_columns, (
        'Expected {} would not appear in {}'.format(
            coop_historical, json_response_columns
        )
    )


@pytest.mark.parametrize('report_type', REPORT_TYPES_WITH_EXPECTATIONS)
def test_coop_columns(
    report_type, coop_columns, coop_historical, historical_params
):
    """Test for the presence of co-op data."""
    response = report_run(report_type, historical_params)
    assert response.status_code == 200, (
        'Result of POST was {}, expected 200.'.format(response.status_code)
    )
    json_response = json.loads(response.content)
    if 'historical' in report_type and report_type['contains_coop_data']:
        check_historical_coop_reports(
            json_response['columns'], coop_columns, coop_historical
        )
    elif report_type['contains_coop_data']:
        check_non_historical_coop_reports(
            json_response['columns'], coop_columns, coop_historical
        )
    elif not report_type['contains_coop_data']:
        check_non_coop_reports(
            json_response['columns'], coop_columns, coop_historical
        )


@pytest.mark.parametrize('report_type', REPORT_TYPES_WITH_EXPECTATIONS)
def test_overstock_columns(report_type, overstock_columns, historical_params):
    """Test for the presence of overstock data."""
    response = report_run(report_type, historical_params)
    assert response.status_code == 200, (
        'Result of POST was {}, expected 200.'.format(response.status_code)
    )
    json_response = json.loads(response.content)
    if report_type['contains_overstock_data']:
        assert set(overstock_columns).issubset(json_response['columns']), (
            'Expected to see overstock columns for {}, got {}'.format(
                report_type['report_type_string'], json_response['columns']
            )
        )
    else:
        assert not set(overstock_columns).issubset(json_response['columns']), (
            'Expected not to see overstock columns for {}, got {}'.format(
                report_type['report_type_string'], json_response['columns']
            )
        )