"""Run controller contract functional tests."""

from unittest.mock import patch

from abacus_account.tests.utils.factories import AccountFactory
from abacus_contract.tests.utils.factories import (
    AccountContractFactory,
    ContractFactory,
    ContractLifecycleFactory,
)
from royalties.constants.constants import (
    CONTRACT_LIFECYCLE_STATUSES,
    CONTRACT_TYPES,
    STATEMENT_PERIOD_STATUSES,
)
from royalties.constants.error import ERROR_DIFFERENT_RUN_CONTROLLER
from royalties.tests.utils.factories import (
    RunControllerContractFactory,
    RunControllerFactory,
    StatementPeriodFactory,
)


def test_create_run_controller_contract(account_contract_fixtures, fixture_client):
    """Test POST /run-controller/contract."""
    account_id = contract_id = 1
    contract_type = CONTRACT_TYPES.DISTRIBUTION
    StatementPeriodFactory.create(
        statement_period_status=STATEMENT_PERIOD_STATUSES.CURRENT
    )
    run_controller = RunControllerFactory.create()

    post_body = {
        'account_id': account_id,
        'contract_id': contract_id,
        'contract_type': contract_type,
        'run_controller_id': run_controller.run_controller_id,
    }

    assert not run_controller.run_controller_contracts

    res = fixture_client.post('/run-controller/contract', json=post_body)

    assert res.status_code == 201
    assert res.json['contract_id'] == post_body['contract_id']
    assert res.json['run_controller_id'] == post_body['run_controller_id']
    assert res.json['run_controller_contract_id']
    assert len(run_controller.run_controller_contracts) == 1


def test_create_run_controller_contract_error(
    account_contract_fixtures, fixture_client
):
    """Test POST /run-controller/contract."""
    account_id = contract_id = 1
    contract_type = CONTRACT_TYPES.DISTRIBUTION
    StatementPeriodFactory.create(
        statement_period_status=STATEMENT_PERIOD_STATUSES.CURRENT
    )
    run_controller = RunControllerFactory.create()
    post_body = {
        'account_id': account_id,
        'contract_id': contract_id,
        'contract_type': contract_type,
        'run_controller_id': run_controller.run_controller_id,
    }

    assert not run_controller.run_controller_contracts

    fixture_client.post('/run-controller/contract', json=post_body)

    assert len(run_controller.run_controller_contracts) == 1

    run_controller_2 = RunControllerFactory.create()
    post_body_new_rc = {
        'account_id': account_id,
        'contract_id': 2,
        'contract_type': contract_type,
        'run_controller_id': run_controller_2.run_controller_id,
    }

    res = fixture_client.post('/run-controller/contract', json=post_body_new_rc)
    error_msg = {
        'run_controller_id': ERROR_DIFFERENT_RUN_CONTROLLER.format(
            contract_type=contract_type.capitalize(),
            run_controller_name=run_controller.run_controller_name,
        )
    }

    assert len(run_controller.run_controller_contracts) == 1
    assert res.json['message'] == error_msg


def test_get_run_controller_contracts_by_account(
    account_contract_fixtures, fixture_client
):
    """Test GET /run-controllers/contracts/account/<int:account_id>."""
    account_id = contract_id = 1
    RunControllerContractFactory.create(contract_id=contract_id)

    res = fixture_client.get(f'/run-controllers/contracts/account/{account_id}')

    assert res.status_code == 200
    assert res.json
    response_body = res.json
    items = response_body['items']
    assert all(rcc.get('run_controller_id') for rcc in items)
    assert all(rcc.get('contract_type') for rcc in items)
    assert all(rcc.get('contract_count') for rcc in items)


def test_get_run_controller_contracts_dataloaded(
    account_contract_fixtures, fixture_client
):
    """Test POST /run-controllers/contracts/dataloader."""
    run_controller_contracts = RunControllerContractFactory.create_batch(2)
    contract_ids = [rcc.contract_id for rcc in run_controller_contracts]
    contract_ids.append(9999)

    res = fixture_client.post(
        '/run-controllers/contracts/dataloader', json=contract_ids
    )

    assert res.status_code == 200
    assert res.json == [
        {
            'data': {
                'run_controller_contract_id': run_controller_contracts[
                    0
                ].run_controller_contract_id,
                'contract_id': run_controller_contracts[0].contract_id,
                'run_controller_id': run_controller_contracts[0].run_controller_id,
                'run_controller_name': run_controller_contracts[
                    0
                ].run_controller.run_controller_name,
            }
        },
        {
            'data': {
                'run_controller_contract_id': run_controller_contracts[
                    1
                ].run_controller_contract_id,
                'contract_id': run_controller_contracts[1].contract_id,
                'run_controller_id': run_controller_contracts[1].run_controller_id,
                'run_controller_name': run_controller_contracts[
                    1
                ].run_controller.run_controller_name,
            }
        },
        {'data': None},
    ]


@patch(
    'royalties.logic.run_controller_contract.is_abacus_contract_page_update_run_controller_ff_enabled'
)
def test_update_run_controller_contracts(mock_is_feature_enabled, fixture_client):
    """Test PUT /run-controller-contracts."""
    mock_is_feature_enabled.return_value = True
    account_id = 1
    contract_id = 101
    contract_type = CONTRACT_TYPES.DISTRIBUTION

    AccountFactory.create(account_id=account_id)
    contract = ContractFactory.create(
        contract_id=contract_id, contract_type=contract_type
    )
    ContractLifecycleFactory.create(
        contract=contract, lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.ACTIVE
    )
    contract.account_contract = AccountContractFactory.create(
        account_id=account_id, contract_id=contract.contract_id
    )
    run_controller_contract = RunControllerContractFactory.create(contract=contract)
    put_body = {
        'contract_id': run_controller_contract.contract_id,
        'run_controller_id': run_controller_contract.run_controller_id,
    }

    res = fixture_client.put('/run-controller-contracts', json=put_body)
    assert res.status_code == 200
    assert res.json == [
        {
            'run_controller_contract_id': run_controller_contract.run_controller_contract_id,
            'contract_id': run_controller_contract.contract_id,
            'run_controller_id': run_controller_contract.run_controller_id,
            'run_controller_name': run_controller_contract.run_controller.run_controller_name,
        }
    ]