"""Tests for ows_abacus_account."""
from unittest.mock import MagicMock
from unittest.mock import patch

from json_contract_file_import.account_import import _account_already_exists
from json_contract_file_import.account_import import _import_new_account
from json_contract_file_import.account_import import _update_existing_account
from json_contract_file_import.account_import import import_account
from json_contract_file_import.entity_import_result import EntityImportResult
from tests.unit.utils import assert_import_result


@patch('json_contract_file_import.account_import._account_already_exists')
@patch('json_contract_file_import.account_import._import_new_account')
def test_import_account_new_account(
        mock_import_new_account,
        mock_account_already_exists,
        mock_json_contract_file_parsed
):
    """Test importing new account."""
    mock_account_already_exists.return_value = False
    mock_import_new_account.return_value = []

    import_results = import_account(mock_json_contract_file_parsed, True)

    assert import_results == []

    mock_account_already_exists.assert_called_once_with(2486)
    mock_import_new_account.assert_called_once_with(mock_json_contract_file_parsed)


@patch('json_contract_file_import.account_import._account_already_exists')
@patch('json_contract_file_import.account_import._update_existing_account')
def test_import_account_existing_account(
        mock_update_existing_account,
        mock_account_already_exists,
        mock_json_contract_file_parsed
):
    """Test importing existing account."""
    mock_account_already_exists.return_value = True
    mock_update_existing_account.return_value = []

    import_results = import_account(mock_json_contract_file_parsed, True)

    assert import_results == []

    mock_account_already_exists.assert_called_once_with(2486)
    mock_update_existing_account.assert_called_once_with(
        mock_json_contract_file_parsed
    )


@patch('json_contract_file_import.account_import.update_account')
@patch('json_contract_file_import.account_import.update_payment_term')
@patch('json_contract_file_import.account_import.abacus_state_import')
def test__update_existing_account_success(
        mock_abacus_state_import,
        mock_update_payment_term,
        mock_update_account,
        mock_json_contract_file_parsed
):
    """Test successful import of existing account."""
    mock_response = MagicMock()
    mock_response.status_code = 201
    mock_response.text = """{
        'account_id': 2486,
        'account_name': 'An Account, not a Vendor',
        'created_by': '',
        'sap_created_at': None,
        'account_payee_id': 3,
        'account_payment_term_id': 3
    }"""
    mock_response.json.return_value = {
        'account_payment_term_id': 3,
        'account_payee_id': 3,
    }
    mock_update_account.return_value = mock_response

    payment_term_import_result = EntityImportResult(
        EntityImportResult.ACCOUNT_PAYMENT_TERM,
        3,
        True,
        additional_info='Some additional info.'
    )
    mock_update_payment_term.return_value = payment_term_import_result

    abacus_state_import_result = EntityImportResult(
        EntityImportResult.ABACUS_STATE,
        3,
        True,
        additional_info='Some additional info.'
    )
    mock_abacus_state_import.import_abacus_states.return_value = [
        abacus_state_import_result
    ]

    response = _update_existing_account(mock_json_contract_file_parsed)

    mock_update_account.assert_called_once_with(2486, {
        'account_name': 'MANITOMAL S.L.',
    })

    mock_update_payment_term.assert_called_once_with(
        3,
        mock_json_contract_file_parsed
    )
    mock_abacus_state_import.import_abacus_states.assert_called_once_with(3)

    expected_account_import_result = EntityImportResult(
        EntityImportResult.ACCOUNT,
        2486, True,
        additional_info=mock_response.text
    )

    assert len(response) == 3
    assert_import_result(response[0], expected_account_import_result)
    assert_import_result(response[1], payment_term_import_result)
    assert_import_result(response[2], abacus_state_import_result)


@patch('json_contract_file_import.account_import.create_account')
@patch('json_contract_file_import.account_import.update_payment_term')
@patch('json_contract_file_import.account_import.abacus_state_import')
def test__import_new_account_success(
        mock_abacus_state_import,
        mock_update_payment_term,
        mock_create_account,
        mock_json_contract_file_parsed
):
    """Test successful import of new account."""
    mock_response = MagicMock()
    mock_response.status_code = 201
    mock_response.text = """{
        'account_id': 2486,
        'account_name': 'An Account, not a Vendor',
        'created_by': '',
        'sap_created_at': None,
        'account_payee_id': 3,
        'account_payment_term_id': 3
    }"""
    mock_response.json.return_value = {
        'account_payment_term_id': 3,
        'account_payee_id': 3,
    }
    mock_create_account.return_value = mock_response

    payment_term_import_result = EntityImportResult(
        EntityImportResult.ACCOUNT_PAYMENT_TERM,
        3,
        True,
        additional_info='Some additional info.'
    )
    mock_update_payment_term.return_value = payment_term_import_result

    mock_abacus_state_import.import_abacus_states.return_value = []

    response = _import_new_account(mock_json_contract_file_parsed)

    mock_create_account.assert_called_once_with({
        'account_id': 2486,
        'account_name': 'MANITOMAL S.L.',
        'currency_code': 'EUR',
        'created_by': 'json-contract-file-import',
        'creation_source': 'json-contract-file-import'
    })

    mock_update_payment_term.assert_called_once_with(
        3,
        mock_json_contract_file_parsed
    )

    mock_abacus_state_import.import_abacus_states.assert_called_once_with(3)

    expected_account_import_result = EntityImportResult(
        EntityImportResult.ACCOUNT,
        2486, True,
        additional_info=mock_response.text
    )

    assert len(response) == 2
    assert_import_result(response[0], expected_account_import_result)
    assert_import_result(response[1], payment_term_import_result)


@patch('json_contract_file_import.account_import.create_account')
@patch('json_contract_file_import.account_import.logger')
def test__import_new_account_error(
        mock_logger,
        mock_create_account,
        mock_json_contract_file_parsed
):
    """Test failed import of new account."""
    mock_response = MagicMock()
    mock_response.status_code = 400
    mock_response.text = """{
      "code": "error",
      "message": "ABACUS account already exists: 2486"
    }"""
    mock_create_account.return_value = mock_response

    response = _import_new_account(mock_json_contract_file_parsed)

    mock_logger.error.assert_called_once_with(
        'Failed response from creating account. '
        'Skipping creating further entities. Account: 2486'
    )

    expected_import_result = EntityImportResult(EntityImportResult.ACCOUNT,
                                                2486, False,
                                                '400 ' + mock_response.text)
    assert len(response) == 1
    assert_import_result(response[0], expected_import_result)


@patch('json_contract_file_import.account_import.get_account')
@patch('json_contract_file_import.account_import.failed_response')
def test__account_already_exists_with_existing_account(
        mock_failed_response,
        mock_get_account
):
    """Test account exists when account is returned."""
    get_account_response = MagicMock()
    mock_get_account.return_value = get_account_response

    mock_failed_response.return_value = False

    exists = _account_already_exists(100)

    assert exists
    mock_failed_response.assert_called_once_with(get_account_response)


@patch('json_contract_file_import.account_import.get_account')
@patch('json_contract_file_import.account_import.failed_response')
def test__account_already_exists_with_no_existing_account(
        mock_failed_response,
        mock_get_account
):
    """Test account exists when account is not returned."""
    get_account_response = MagicMock()
    mock_get_account.return_value = get_account_response

    mock_failed_response.return_value = True

    exists = _account_already_exists(100)

    assert not exists
    mock_failed_response.assert_called_once_with(get_account_response)