"""Integration API tests for ows-product."""

import pytest
from typing import Any

import requests


def test_post_track_localization(workstation_api_client, track_ids):
    """Test POST to bulk track localization endpoint."""
    post_result = workstation_api_client.bulk_get_track_localization(track_ids)
    assert post_result.status_code == 200, \
        'Result of POST was {}, expected 200.'.format(post_result.status_code)
    for track in post_result.json()['items']:
        assert track['language_id'], \
            'Expected language_id to not be null for record {}'.format(track)


def test_get_track_localization(workstation_api_client, track_ids):
    """Test GET to track localization endpoint."""
    get_result = workstation_api_client.get_track_localization(track_ids)
    assert get_result.status_code == 200, \
        'Result of GET was {}, expected 200.'.format(get_result.status_code)
    for track in get_result.json()['items']:
        assert track['language_id'], \
            'Expected language_id to not be null for record {}'.format(track)


def test_get_product_document(qa_ows_product_url, product_document_id):
    """Test GET product document endpoint."""
    url = '{}/product/{}/document'.format(
        qa_ows_product_url, product_document_id)
    get_result = requests.get(url)
    data = get_result.json()
    assert get_result.status_code == 200
    assert data['display_status'] == 'submitted'
    assert data['preorder_date'] == '2019-04-20'


@pytest.mark.parametrize(
    'header_fixture_name,product_ids,expected_status_code,expected_response_body', [
        pytest.param(
            'ows_product_user_headers',
            [1, 132929501329295, 1329295],
            200,
            {'product_ids': [
                    {
                        'product_id': 1,
                        'tenant_type': 'account',
                        'tenant_id': 6888
                    },
                    None,
                    {
                        'product_id': 1329295,
                        'tenant_type': 'subaccount',
                        'tenant_id': 1
                    }
            ]},
            id='valid jwt is used and authorized to lookup product ownership'
        ),
        pytest.param(
            'unauthorized_headers',
            [1, 132929501329295, 1329295],
            401,
            {'code': 'authorization_error', 'message': 'Invalid Authorization'},
            id='non-legit headers are not sufficient for AuthZ, JWT is required'
        ),
        pytest.param(
            'content_profile_headers',
            [1, 132929501329295, 1329295],
            401,
            {'code': 'authorization_error', 'message': 'Invalid Authorization'},
            id='ContentProfile headers are not sufficient for AuthZ, JWT is required'
        ),
        pytest.param(
            'ows_product_user_headers',
            [],
            400,
            {'code': 'bad_request', 'message': 'No product ids in request body'},
            id='invalid request payload'
        ),
    ],
)
def test_lookup_product_ownership(
    header_fixture_name: str,
    product_ids: list[int],
    expected_status_code: int,
    expected_response_body: dict[str, Any],
    qa_ows_product_url: str,
    request: pytest.FixtureRequest,
) -> None:
    url = f'{qa_ows_product_url}/lookup/product/ownership/'
    headers = request.getfixturevalue(header_fixture_name)
    result = requests.post(url, json={'product_ids': product_ids}, headers=headers)

    assert result.status_code == expected_status_code, result.text
    assert result.json() == expected_response_body