"""ManufacturedUpcsProcessor tests."""

from string import Template
from unittest.mock import MagicMock, patch

from faker import Faker
import pytest

from src.processors.exceptions import ProcessingError
from src.processors.manufactured_upcs import ManufacturedUpcsProcessor
from src.processors.manufactured_upcs.queries import (
    CLEANUP_MANUFACTURED_UPCS,
    INSERT_MANUFACTURED_UPCS,
)
from tests.unit.factories import StatementPeriodFactory
from tests.utils import create_sample_csv_buffer


class TestManufacturedUpcsProcessor:
    """ManufacturedUpcsProcessor test suite."""

    def test_load_csv_data_success(self, faker: Faker) -> None:
        """Test loading data from CSV file success."""
        processor = ManufacturedUpcsProcessor(faker.pystr(), faker.pystr())
        processor._input_file_buffer = create_sample_csv_buffer(
            [('UPC',), ('5053383333',), ('5053383334',)]
        )
        processor._load_csv_data()
        assert processor._data == ['5053383333', '5053383334']

    def test_load_csv_data_no_data(self, faker: Faker) -> None:
        """Test loading data from CSV file no data failure."""
        processor = ManufacturedUpcsProcessor(faker.pystr(), faker.pystr())
        processor._input_file_buffer = create_sample_csv_buffer([('UPC',)])
        with pytest.raises(ProcessingError, match='No items in file to post'):
            processor._load_csv_data()

    def test_load_csv_data_invalid(self, faker: Faker) -> None:
        """Test loading data from CSV file invalid data failure."""
        processor = ManufacturedUpcsProcessor(faker.pystr(), faker.pystr())
        processor._input_file_buffer = create_sample_csv_buffer(
            (('product_id'), ('5053383333'), ('5053383334'))
        )
        with pytest.raises(ProcessingError, match='Invalid file content'):
            processor._load_csv_data()

    @patch(
        'src.processors.manufactured_upcs.'
        'manufactured_upcs.get_current_statement_period'
    )
    def test_load_ows_data_success(self, mock_royalties: MagicMock) -> None:
        """Test load ows data."""
        mock_period = StatementPeriodFactory.build()
        mock_royalties.return_value = mock_period

        processor = ManufacturedUpcsProcessor('', '')
        processor._load_ows_data()
        assert processor._statement_period == mock_period
        mock_royalties.assert_called_once()

    @patch(
        'src.processors.manufactured_upcs.'
        'manufactured_upcs.get_current_statement_period'
    )
    def test_load_ows_data_no_data(self, mock_ows_royalties: MagicMock) -> None:
        """Test load ows data."""
        mock_ows_royalties.return_value = None

        processor = ManufacturedUpcsProcessor('', '')
        with pytest.raises(ProcessingError, match='No current statement period'):
            processor._load_ows_data()
        mock_ows_royalties.assert_called_once()

    @patch('src.processors.manufactured_upcs.manufactured_upcs' '.SnowflakeSQLExecutor')
    def test_cleanup_data(self, mock_snowflake: MagicMock) -> None:
        """Test cleanup snowflake data."""
        executor_instance = MagicMock()
        executor_instance.execute.return_value = None
        mock_snowflake.return_value.__enter__.return_value = executor_instance

        processor = ManufacturedUpcsProcessor('', '')
        mock_period = StatementPeriodFactory.build()
        processor._statement_period = mock_period
        processor._cleanup_data()
        sql_query = Template(CLEANUP_MANUFACTURED_UPCS).substitute(
            **{
                'db': 'TEST',
                'schema': 'TEST',
                'statement_period_id': mock_period.statement_period_id,
            }
        )
        executor_instance.execute.assert_called_once_with(sql_query)

    @patch('src.processors.manufactured_upcs.manufactured_upcs' '.SnowflakeSQLExecutor')
    def test_insert_data(self, mock_snowflake: MagicMock) -> None:
        """Test cleanup snowflake data."""
        executor_instance = MagicMock()
        executor_instance.execute.return_value = None
        mock_snowflake.return_value.__enter__.return_value = executor_instance

        processor = ManufacturedUpcsProcessor('', '')
        processor._statement_period = StatementPeriodFactory.build(
            statement_period_id=1
        )
        processor._data = ['123']
        processor._insert_data()
        sql_query = Template(INSERT_MANUFACTURED_UPCS).substitute(
            **{
                'db': 'TEST',
                'schema': 'TEST',
                'values': (
                    '(1, 123, CURRENT_DATE(),' " 'lambda-documents-load-from-s3')"
                ),
            }
        )
        executor_instance.execute.assert_called_once_with(sql_query)