"""PostSpanishTaxDetailsProcessor tests"""

import logging
from unittest.mock import call, Mock, patch

from faker import Faker
import pytest

from src.connectors.exceptions import OwsPayeeException
from src.constants import DEFAULT_BATCH_SIZE
from src.processors.banking_details import RegisterBankingDetailsProcessor
from src.processors.base import LogEntry
from src.processors.exceptions import ProcessingError
from tests.utils import create_sample_csv_buffer


class TestRegisterBankingDetailsProcessor:
    """RegisterBankingDetailsProcessor test suite."""

    @patch.object(RegisterBankingDetailsProcessor, '_register_banking_details')
    @patch.object(RegisterBankingDetailsProcessor, '_load_account_payee_ids')
    @patch.object(RegisterBankingDetailsProcessor, '_load_data')
    def test_process(
        self,
        mock_load_data: Mock,
        mock_load_account_payee_ids: Mock,
        mock_register_banking_details: Mock,
        faker: Faker,
    ) -> None:
        """Test process method."""
        processor = RegisterBankingDetailsProcessor(faker.pystr(), faker.pystr())

        processor.process()

        mock_load_data.assert_called_once_with()
        mock_load_account_payee_ids.assert_called_once_with()
        mock_register_banking_details.assert_called_once_with()

    def test_load_data_success(self, faker: Faker) -> None:
        """Test loading data from CSV file success."""
        buffer = create_sample_csv_buffer((('vendor_id',), ('15',), ('26',), ('32',)))
        processor = RegisterBankingDetailsProcessor(faker.pystr(), faker.pystr())
        processor._input_file_buffer = buffer
        processor._load_data()
        assert processor._account_ids == [15, 26, 32]

    def test_load_data_failure_no_file(self, faker: Faker) -> None:
        """Test loading data from CSV file failure."""
        processor = RegisterBankingDetailsProcessor(faker.pystr(), faker.pystr())
        with pytest.raises(ProcessingError, match='Unable to read the file'):
            processor._load_data()

    def test_load_data_failure_no_content(self) -> None:
        """Test loading data from CSV file failure, no content."""
        buffer = create_sample_csv_buffer(('vendor_id',))
        processor = RegisterBankingDetailsProcessor('', '')
        processor._input_file_buffer = buffer
        with pytest.raises(ProcessingError, match='No items in file to register'):
            processor._load_data()

    def test_load_data_failure_bad_content(self) -> None:
        """Test loading data from CSV file failure, bad content."""
        buffer = create_sample_csv_buffer((('vendor_id',), ('15',), ('abc',)))
        processor = RegisterBankingDetailsProcessor('', '')
        processor._input_file_buffer = buffer
        with pytest.raises(ProcessingError):
            processor._load_data()

    @patch('src.processors.banking_details.register_banking_details.ows_abacus_account')
    def test_load_account_payee_ids(
        self, mock_ows_abacus_account: Mock, faker: Faker
    ) -> None:
        """Test _load_account_payee_ids method."""
        items_count = round(DEFAULT_BATCH_SIZE * 2.1)
        mock_ows_abacus_account.get_payees_by_accounts.side_effect = (
            self.generate_ids_map(3, DEFAULT_BATCH_SIZE),
            self.generate_ids_map(DEFAULT_BATCH_SIZE, DEFAULT_BATCH_SIZE * 2),
            self.generate_ids_map(DEFAULT_BATCH_SIZE * 2, items_count - 2),
        )

        processor = RegisterBankingDetailsProcessor(faker.pystr(), faker.pystr())
        processor._account_ids = list(self.generate_ids_map(0, items_count).keys())

        processor._load_account_payee_ids()

        assert mock_ows_abacus_account.get_payees_by_accounts.call_args_list == [
            call(list(self.generate_ids_map(0, DEFAULT_BATCH_SIZE).keys())),
            call(
                list(
                    self.generate_ids_map(
                        DEFAULT_BATCH_SIZE, DEFAULT_BATCH_SIZE * 2
                    ).keys()
                )
            ),
            call(
                list(self.generate_ids_map(DEFAULT_BATCH_SIZE * 2, items_count).keys())
            ),
        ]
        assert processor._account_id_account_payee_id == self.generate_ids_map(
            3, items_count - 2
        )
        assert processor._logs == {
            logging.ERROR: [LogEntry('Missing accounts {648, 649, 20, 21, 22}')]
        }

    @patch('src.processors.banking_details.register_banking_details.ows_payee')
    def test_register_banking_details(self, mock_ows_payee: Mock) -> None:
        """Test _register_banking_details"""
        mock_ows_payee.register_banking_details.side_effect = [
            None,
            None,
            OwsPayeeException('Er1'),
            OwsPayeeException('Er2'),
            None,
        ]

        processor = RegisterBankingDetailsProcessor('', '')
        processor._account_id_account_payee_id = self.generate_ids_map(0, 5)

        processor._register_banking_details()

        assert mock_ows_payee.register_banking_details.call_args_list == [
            call(item) for item in self.generate_ids_map(0, 5).values()
        ]
        assert processor._logs == {
            logging.ERROR: [
                LogEntry('ows-payee failure: Er1'),
                LogEntry('ows-payee failure: Er2'),
            ]
        }

    @staticmethod
    def generate_ids_map(start: int, end: int) -> dict[int, int]:
        """Generate fake IDs map."""
        return {20 + i: 100 + i for i in range(start, end)}