"""TAX/VAT Refresh Processor for Payoneer Payments"""

from typing import List

from config import app_logger as logger
from src.constants import BATCH_SIZE_REFRESH, NO_WORKSHEET_ENTRIES_REFRESH_ERR
from src.models import Event, PayableBalanceAfterTaxEntry, PaymentGroup
from src.processors.base.payment_batch_refresh_processor import (
    PaymentBatchRefreshProcessor,
)
from src.processors.base.processor import Processor
from src.utils import get_all_payable_balance_after_tax_entries_by_event


class PayoneerRefreshProcessor(Processor):
    def __init__(
        self,
        payment_group: PaymentGroup,
        abacus_event: Event,
        is_check_payment: bool = False,
    ) -> None:
        """Init."""
        super().__init__(payment_group, abacus_event)
        self._limit = BATCH_SIZE_REFRESH
        # Check payments have no VAT, so VAT corrections are not refreshed for them.
        self._is_check_payment = is_check_payment
        self._all_worksheet_after_tax_entries: List[PayableBalanceAfterTaxEntry] = []

    def _set_total_count(self) -> None:
        """Set total number of worksheet payable after tax entries to be processed"""
        # One contract per abacus event, no duplicate here
        self._total_count = len(self._all_worksheet_after_tax_entries)

    def _set_all_worksheet_after_tax_entries(self) -> None:
        """Fetch and store all worksheet payable after tax entries for the event."""
        self._all_worksheet_after_tax_entries = (
            get_all_payable_balance_after_tax_entries_by_event(self._abacus_event)
        )

    def process(self) -> None:
        """Process to refresh tax/vat worksheets for Payoneer payments"""
        logger.info('Starting Payoneer Refresh Processor')

        self._set_all_worksheet_after_tax_entries()
        self._set_total_count()
        if self._total_count == 0:
            logger.info(
                NO_WORKSHEET_ENTRIES_REFRESH_ERR.format(
                    self._abacus_event.abacus_event_id
                )
            )
            return
        for offset in range(0, self._total_count, self._limit):
            self._process_batch(offset)

        logger.info('Completed Payoneer Refresh Processor')

    def _get_worksheet_after_tax_batch_data(
        self, offset: int = 0
    ) -> List[PayableBalanceAfterTaxEntry]:
        """Will contain logic for fetching eligible accounts."""
        return self._all_worksheet_after_tax_entries[offset : offset + self._limit]

    def _process_batch(self, offset: int = 0) -> None:
        """Refresh batch of worksheet payable after tax entries."""
        worksheet_after_tax_batch = self._get_worksheet_after_tax_batch_data(offset)
        PaymentBatchRefreshProcessor(
            self._abacus_event,
            worksheet_after_tax_batch,
            append_vat_corrections=not self._is_check_payment,
        ).process()