"""Test Single Product Overview handlers."""

from unittest.mock import MagicMock

import pytest
from oto.response import Response, create_error_response
from owsrequest import access

from reporting.constants import error, header
from reporting.logic import single_product_overview as spo

error_response = create_error_response(
    error.ERROR_CODE_UNAUTHORIZED,
    error.ERROR_MESSAGE_FORBIDDEN_USER,
    status=403,
)

GRASS_HEADERS = {
    header.GRASS_ACCOUNT_TYPE: header.GRASS_ACCOUNT_TYPE_VENDOR,
    header.GRASS_ACCOUNT_ID: '7123',
}

PROFILE_HEADERS = {
    header.ORCHARD_PROFILE_TYPE: 'Label',
    header.ORCHARD_PROFILE_ID: '456',
}


@pytest.mark.parametrize(
    (
        'expected_response_code',
        'territory',
        'belongs_to_product_response',
        'overview_response_code',
    ),
    [
        (200, 'CA', Response(status=200), 200),
        (404, 'AUS', Response(status=200), 404),
        (500, 'CA', Response(status=200), 500),
        (403, 'CA', error_response, 200),
    ],
)
def test_get_single_product_overview(
    client,
    monkeypatch,
    local_product_cd,
    expected_response_code,
    overview_response_code,
    territory,
    belongs_to_product_response,
):
    """Test get_sales_rtd handler with legacy Grass headers."""
    monkeypatch.setattr(
        access,
        'verify_grass_headers',
        value=MagicMock(return_value=Response()),
    )

    monkeypatch.setattr(
        spo,
        'product_belongs_to_account',
        value=MagicMock(return_value=belongs_to_product_response),
    )

    monkeypatch.setattr(
        spo,
        'get_overview',
        value=MagicMock(
            return_value=Response(
                status=overview_response_code, message='test'
            )
        ),
    )

    result = client.get(
        '/product/{}/overview/{}'.format(local_product_cd, territory),
        content_type='application/json',
        headers=GRASS_HEADERS,
    )

    assert result.status_code == expected_response_code


@pytest.mark.parametrize(
    ('expected_response_code', 'belongs_to_product_response'),
    [
        (200, Response(status=200)),
        (403, error_response),
    ],
)
def test_get_single_product_overview_with_profile_headers(
    client,
    monkeypatch,
    local_product_cd,
    expected_response_code,
    belongs_to_product_response,
):
    """Test handler falls back to profile headers when Grass headers absent."""
    monkeypatch.setattr(
        spo,
        'product_belongs_to_profile',
        value=MagicMock(return_value=belongs_to_product_response),
    )

    monkeypatch.setattr(
        spo,
        'get_overview',
        value=MagicMock(return_value=Response(status=200, message='test')),
    )

    result = client.get(
        '/product/{}/overview/CA'.format(local_product_cd),
        content_type='application/json',
        headers=PROFILE_HEADERS,
    )

    assert result.status_code == expected_response_code
    if expected_response_code == 200:
        spo.product_belongs_to_profile.assert_called_once_with(
            local_product_cd, 'CA', 'Label', '456'
        )


def test_get_single_product_overview_missing_all_headers(
    client, local_product_cd
):
    """Test handler errors when neither Grass nor profile headers exist."""
    result = client.get(
        '/product/{}/overview/CA'.format(local_product_cd),
        content_type='application/json',
    )

    assert result.status_code == 400
    assert (
        result.json.get('code') == error.ERROR_CODE_MISSING_HEADERS
    )