"""Integration tests for get abacus state action list.

GET /abacus-state/<string:parent_table_name>/<int:parent_table_id>.
"""

from typing import Any

import pytest
from abacus_common_logic.connectors.database import db

from tests.integration.conftest import ows_abacus_state_api_client


@pytest.fixture
def seed_accounting_period_abacus_state(basic_headers: dict[str, Any]) -> None:
    """Use API to seed accounting period."""
    abacus_state_client = ows_abacus_state_api_client(basic_headers)
    post_data = [
        {
            'parent_table_id': 1,
            'action_name': 'deliver_sales_files',
            'parent_table_name': 'accounting_period',
        }
    ]
    abacus_state_client.post_states(post_data)


@pytest.mark.parametrize(
    'header_fixture_name, expected_status_code',
    [
        pytest.param(
            'no_authorization_headers',
            403,
            id='orchard-requestor-service forces profile checks',
        ),
        pytest.param(
            'some_other_app_profile_headers',
            403,
            id='other apps are not authorized',
        ),
        pytest.param('abacus_headers', 200, id='abacus is authorized'),
        pytest.param(
            'a360_headers',
            403,
            id='Account360Profile is not authorized, should be based on PP',
        ),
    ],
)
def test_authorization_accounting_period_abacus_state(
    seed_accounting_period_abacus_state: Any,
    header_fixture_name: str,
    expected_status_code: int,
    request: pytest.FixtureRequest,
) -> None:
    """Test authorization based on headers."""
    headers = request.getfixturevalue(header_fixture_name)

    abacus_state_client = ows_abacus_state_api_client(headers)
    result = abacus_state_client.get_state('accounting-period', 1)
    assert result.status_code == expected_status_code

    if expected_status_code == 200:
        item = result.json()[0]
        assert item['action_name'] == 'deliver_sales_files'
        assert item['action_status'] == 'init'
        assert 'abacus_state_id' in item
    else:
        assert result.json() == {
            'code': 'authorization_error',
            'message': 'Unauthorized',
        }


@pytest.fixture
def seed_account_payee_abacus_state(
    drop_fks: Any,
    basic_headers: dict[str, Any],
) -> None:
    """Use db engine and API to fixture account_payee state."""
    account_query = """
    INSERT INTO royalty_accounting.account (
        account_id,
        account_name,
        created_by,
        created_at,
        last_modified_by,
        last_modified
    ) VALUES (
        25153,
        'TEST ACCOUNT',
        1472,
        '2021-04-12 02:38:45.000000',
        1472,
        '2021-04-12 02:38:45.000000'
    )
    """
    db.engine.execute(account_query)

    account_payee_query = """
    INSERT INTO royalty_accounting.account_payee
    (account_id,
    payoneer_payee_id,
    payoneer_payee_name,
    payoneer_iframe_url,
    payoneer_iframe_url_date,
    payoneer_session_id,
    created_by,
    created_at,
    last_modified_by,
    last_modified)
    VALUES
    (25153,
    1,
    'test',
    'test',
    '2022-03-24',
    'test',
    'vz',
    '2022-03-24 07:27:26',
    'vz',
    '2022-03-24 07:27:30')"""
    db.engine.execute(account_payee_query)

    abacus_state_client = ows_abacus_state_api_client(basic_headers)
    post_data = [
        {
            'parent_table_id': 1,
            'action_name': 'tax_eligibility',
            'parent_table_name': 'account_payee',
        },
        {
            'parent_table_id': 1,
            'action_name': 'payment_eligibility',
            'parent_table_name': 'account_payee',
        },
    ]
    abacus_state_client.post_states(post_data)


@pytest.mark.parametrize(
    'header_fixture_name, expected_status_code',
    [
        pytest.param(
            'no_authorization_headers',
            403,
            id='orchard-requestor-service forces profile checks',
        ),
        pytest.param(
            'some_other_app_profile_headers',
            403,
            id='other apps are not authorized',
        ),
        pytest.param('abacus_headers', 200, id='abacus is authorized'),
        pytest.param(
            'a360_headers',
            403,
            id='Account360Profile is not authorized, should be based on PP',
        ),
    ],
)
def test_authorization_account_payee_abacus_state(
    seed_account_payee_abacus_state: Any,
    header_fixture_name: str,
    expected_status_code: int,
    request: pytest.FixtureRequest,
) -> None:
    """Test authorization based on headers."""
    headers = request.getfixturevalue(header_fixture_name)
    abacus_state_client = ows_abacus_state_api_client(headers)
    result = abacus_state_client.get_state('account-payee', 1)
    assert result.status_code == expected_status_code

    if expected_status_code == 200:
        json_result = result.json()
        assert len(json_result) == 2
        assert json_result[0]['action_name'] == 'tax_eligibility'
        assert json_result[1]['action_name'] == 'payment_eligibility'
    else:
        assert result.json() == {
            'code': 'authorization_error',
            'message': 'Unauthorized',
        }


@pytest.mark.parametrize(
    'parent_table_name, expected_status_code',
    [
        pytest.param(
            'accounting-period',
            403,
            id='Not yet authorized for accounting_period',
        ),
        pytest.param(
            'account-payee',
            200,
            id='account payee is authorized',
        ),
    ],
)
def test_authorization_read_only_user(
    seed_accounting_period_abacus_state: Any,
    seed_account_payee_abacus_state: Any,
    parent_table_name: str,
    bearer_token_read_only_user: dict[str, Any],
    expected_status_code: int,
) -> None:
    """Test authorization based on headers."""
    headers = {
        'Content-Type': 'application/json',
        'orchard-requestor-service': 'graphql-abacus',
        'Authorization': f'Bearer {bearer_token_read_only_user}',
    }
    abacus_state_client = ows_abacus_state_api_client(headers)
    result = abacus_state_client.get_state(parent_table_name, 1)
    assert result.status_code == expected_status_code