"""Functional tests for run controllers."""

from abacus_common_logic.test_utils.helpers import get_json_body

from royalties.constants import constants, error
from royalties.models.run_controller import RunController
from royalties.tests.utils.factories import (
    RunControllerContractFactory,
    RunControllerFactory,
)


def test_create_run_controller(fixture_client):
    """Create a run controller."""
    response = fixture_client.post(
        '/run-controller',
        json={
            'run_controller_name': 'High Priority 1',
            'contract_type': constants.CONTRACT_TYPES.DISTRIBUTION,
        },
    )
    assert response.status_code == 201
    response_body = get_json_body(response)
    controllers = RunController.query.all()
    assert len(controllers) == 1
    assert response_body == {
        'run_controller_id': controllers[0].run_controller_id,
        'run_controller_name': 'High Priority 1',
        'contract_type': constants.CONTRACT_TYPES.DISTRIBUTION,
    }


def test_list_run_controllers(fixture_client, run_controller_fixtures, remove_fks):
    """List run controllers."""
    high_priority_1 = run_controller_fixtures[0]
    RunControllerContractFactory.create(run_controller=high_priority_1, contract_id=1)
    RunControllerContractFactory.create(run_controller=high_priority_1, contract_id=2)
    response = fixture_client.get('/run-controllers')
    assert response.status_code == 200
    response_body = get_json_body(response)
    assert [row['run_controller_name'] for row in response_body['items']] == [
        controller.run_controller_name for controller in run_controller_fixtures
    ]
    assert [row['contract_count'] for row in response_body['items']] == [2, 0, 0]
    assert all(
        [
            row['contract_type'] == constants.CONTRACT_TYPES.DISTRIBUTION
            for row in response_body['items']
        ]
    )


def test_list_run_controllers_by_contract_type(fixture_client):
    """List run controllers, filtered by contract type."""
    total_count = 3
    for ind in range(total_count):
        RunControllerFactory.create(
            run_controller_name=f'Distribution {ind + 1}',
            contract_type=constants.CONTRACT_TYPES.DISTRIBUTION,
        )
        RunControllerFactory.create(
            run_controller_name=f'Legacy Distribution {ind + 1}',
            contract_type=constants.CONTRACT_TYPES.LEGACY_DISTRIBUTION,
        )
    response = fixture_client.get('/run-controllers')
    assert response.status_code == 200
    assert len(response.json['items']) == total_count * 2  # 6
    assert response.json['total_count'] == total_count * 2  # 6

    response = fixture_client.get('/run-controllers?contract_type=distribution')
    assert response.status_code == 200
    assert len(response.json['items']) == total_count
    assert all(
        [item['contract_type'] == constants.CONTRACT_TYPES.DISTRIBUTION]
        for item in response.json['items']
    )
    assert response.json['total_count'] == total_count

    legacy_limit = 2
    response = fixture_client.get(
        f'/run-controllers?contract_type=legacy_distribution&limit={legacy_limit}'
    )
    assert response.status_code == 200
    assert len(response.json['items']) == legacy_limit
    assert all(
        [item['contract_type'] == constants.CONTRACT_TYPES.LEGACY_DISTRIBUTION]
        for item in response.json['items']
    )
    assert response.json['total_count'] == total_count


def test_list_run_controllers_active_only(fixture_client):
    """Get list of only active run controllers."""
    run_controllers = RunControllerFactory.create_batch(3)
    run_controllers[0].deleted_at = '2023-09-18'
    run_controllers[0].deleted_by = 'someone'

    response = fixture_client.get('/run-controllers?active_only=true')

    assert response.status_code == 200
    assert response.json.get('total_count') == 2
    assert len(response.json.get('items')) < len(run_controllers)


def test_get_run_controller_by_contract(fixture_client, run_controller_fixtures):
    """GET /run-controller-by-contract/<int:contract_id>."""
    run_controller = run_controller_fixtures[0]
    RunControllerContractFactory.create(run_controller=run_controller, contract_id=1)
    res = fixture_client.get('/run-controller-by-contract/1')
    assert res.status_code == 200
    assert res.json == {
        'run_controller_id': run_controller.run_controller_id,
        'run_controller_name': run_controller.run_controller_name,
        'contract_type': run_controller.contract_type,
    }


def test_get_run_controller_by_contract_not_found(fixture_client):
    """/run-controller-by-contract/<int:contract_id>."""
    res = fixture_client.get('/run-controller-by-contract/1')
    assert res.status_code == 404
    assert res.json['message'] == error.ERROR_RUN_CONTROLLER_NOT_ASSOCIATED