"""Test for the validation access module."""

import pytest

from owsrequest import access
from owsrequest.constants import errors
from owsrequest.constants import headers


def fixture_empty_grass_headers():
    """Fixture for empty grass headers."""
    return (None, None)


def fixture_blank_grass_headers():
    """Fixture for blank grass headers."""
    return ('', '')


def fixture_missing_grass_account_type():
    """Fixture for missing account type."""
    return (None, 'anything')


def fixture_missing_grass_account_id():
    """Fixture for missing grass account id."""
    return (headers.GRASS_ACCOUNT_TYPE_VENDOR, None)


@pytest.fixture(params=[123, '123'])
def fixture_grass_headers_vendor(request):
    """Fixture with a valid vendor grass header."""
    vendor_id = request.param
    return (headers.GRASS_ACCOUNT_TYPE_VENDOR, vendor_id)


@pytest.fixture(params=[456, '456'])
def fixture_grass_headers_subaccount(request):
    """Fixture with a valid subaccount grass header."""
    subaccount_id = request.param
    return (headers.GRASS_ACCOUNT_TYPE_SUBACCOUNT, subaccount_id)


@pytest.mark.parametrize('headers', [
    (fixture_empty_grass_headers()),
    (fixture_blank_grass_headers()),
    (fixture_missing_grass_account_type()),
    (fixture_missing_grass_account_id())])
def test_verify_grass_access_requires_headers(monkeypatch, headers):
    """Test headers are required."""
    result = access.verify_grass_access(
        header_account_type=headers[0],
        header_account_id=headers[1],
        required=True)
    assert not result


def test_verify_grass_access_does_not_require_headers(monkeypatch):
    """Test headers are not required."""
    result = access.verify_grass_access(
        header_account_type=None,
        header_account_id=None,
        required=False)
    assert result


@pytest.mark.parametrize('headers', [
    (fixture_missing_grass_account_type()),
    (fixture_missing_grass_account_id())])
def test_verify_grass_access_fails_incomplete_headers(monkeypatch, headers):
    """Test incomplete headers are invalid."""
    result = access.verify_grass_access(
        header_account_type=headers[0],
        header_account_id=headers[1],
        required=False)
    assert not result


def test_verify_grass_access_consistency_vendor(
        monkeypatch, fixture_grass_headers_vendor):
    """Test consistency upheld between Grass headers and validation kwargs."""
    vendor_id = fixture_grass_headers_vendor[1]
    result = access.verify_grass_access(
        header_account_type=fixture_grass_headers_vendor[0],
        header_account_id=vendor_id,
        vendor=vendor_id)
    assert result

    result = access.verify_grass_access(
        header_account_type=fixture_grass_headers_vendor[0],
        header_account_id=vendor_id,
        vendor=vendor_id,
        subaccount='anything')
    assert result

    result = access.verify_grass_access(
        header_account_type=fixture_grass_headers_vendor[0],
        header_account_id=vendor_id,
        vendor=int(vendor_id),
        subaccount='anything')
    assert result

    result = access.verify_grass_access(
        header_account_type=fixture_grass_headers_vendor[0],
        header_account_id=vendor_id,
        vendor='not valid')
    assert not result
    assert result.status == 403

    result = access.verify_grass_access(
        header_account_type=fixture_grass_headers_vendor[0],
        header_account_id=vendor_id,
        subaccount=vendor_id)
    assert not result
    assert result.status == 403


def test_verify_grass_access_consistency_subaccount(
        monkeypatch, fixture_grass_headers_subaccount):
    """Test consistency upheld between Grass headers and validation kwargs."""
    subaccount_id = fixture_grass_headers_subaccount[1]

    result = access.verify_grass_access(
        header_account_type=fixture_grass_headers_subaccount[0],
        header_account_id=subaccount_id,
        subaccount=subaccount_id)
    assert result

    result = access.verify_grass_access(
        header_account_type=fixture_grass_headers_subaccount[0],
        header_account_id=subaccount_id,
        vendor='anything',
        subaccount=subaccount_id)
    assert result

    result = access.verify_grass_access(
        header_account_type=fixture_grass_headers_subaccount[0],
        header_account_id=subaccount_id,
        vendor='anything',
        subaccount=int(subaccount_id))
    assert result

    result = access.verify_grass_access(
        header_account_type=fixture_grass_headers_subaccount[0],
        header_account_id=subaccount_id,
        subaccount='not_valid')
    assert not result
    assert result.status == 403

    result = access.verify_grass_access(
        header_account_type=fixture_grass_headers_subaccount[0],
        header_account_id=subaccount_id,
        vendor=subaccount_id)
    assert not result
    assert result.status == 403


@pytest.mark.parametrize('headers', [
    (fixture_empty_grass_headers()),
    (fixture_blank_grass_headers())])
def test_verify_grass_headers_optional(headers):
    """Test that validation succeeds when headers are optional and empty."""
    result = access.verify_grass_access(
        header_account_type=headers[0],
        header_account_id=headers[1],
        required=False)
    assert errors.LOG_NON_GRASS_HEADERS_ACCESS
    assert result


@pytest.mark.parametrize('headers', [
    (fixture_empty_grass_headers()),
    (fixture_blank_grass_headers())])
def test_verify_grass_headers_optional_by_default(headers):
    """Test that headers are optional by default."""
    result = access.verify_grass_access(
        header_account_type=headers[0], header_account_id=headers[1])
    assert errors.LOG_NON_GRASS_HEADERS_ACCESS
    assert result


@pytest.mark.parametrize(('headers', 'log_non_grass_headers_access'), [
    (fixture_empty_grass_headers(), False),
    (fixture_blank_grass_headers(), False),
    (fixture_missing_grass_account_type(), False),
    (fixture_missing_grass_account_id(), False)])
def test_verify_grass_headers_required_missing(
        headers, log_non_grass_headers_access):
    """Test that validation fails if headers are required and not complete."""
    result = access.verify_grass_access(
        header_account_type=headers[0],
        header_account_id=headers[1],
        required=True)
    assert errors.LOG_NON_GRASS_HEADERS_ACCESS == log_non_grass_headers_access
    assert result.status == 400


@pytest.mark.parametrize(('profile_type', 'profile_id', 'expected'), [
    ('dummy', 'id', 200),
    ('ArtistProfile', 1234, 200),
    ('', 'id', 400),
    ('', '', 200),
    ('dummy', '', 400),
    (None, None, 200),
])
def test_verify_profile_headers_are_complete(
        profile_type, profile_id, expected):
    """Test verify_profile_headers_are_complete."""
    result = access.verify_profile_headers_are_complete(
        profile_type, profile_id)
    assert result.status == expected


@pytest.mark.parametrize((
    'head_profile_type', 'head_profile_id', 'profile_type', 'profile_id',
    'expected'
), [
    # direct calls.
    (None, None, 'dummy', '123', 200),
    ('', '', 'dummy', '123', 200),
    # via grass
    ('dummy', '456', 'dummy', '123', 403),
    ('random', '123', 'dummy', '123', 403),
    ('dummy', 123, 'dummy', '123', 200),
    ('dummy', '123', 'dummy', '123', 200),
    # fake calls
    (None, '123', 'dummy', '123', 400),
    ('dummy', None, 'dummy', '123', 400),
])
def test_verify_profile_headers_match_route(
        head_profile_type, head_profile_id, profile_type, profile_id,
        expected):
    """Test verify_profile_headers_match_route."""
    result = access.verify_profile_headers_match_route(
        head_profile_type, head_profile_id, profile_type, profile_id)
    assert result.status == expected