"""Unit tests for QQSL."""
from unittest import mock
from unittest.mock import MagicMock
from unittest.mock import patch

import pytest
from snowflake_connector.etl_connector import SQLLoader

from feed_ingestion.flows.qq import stage_loader as qq_stage_loader
from feed_ingestion.flows.qq.stage_loader import QQSL


class TestStageLoader(object):
    """Unit tests for QQSL."""

    @pytest.fixture
    def mock_sql_loader(self):
        """Return sql_loader mock."""
        sql_loader_path = (
            'feed_ingestion.flows.spotify.snowflake_executor.sql_loader')
        with patch(sql_loader_path) as sql_loader:
            yield sql_loader

    @pytest.fixture
    def mock_stage_loader(self, mock_sql_loader):
        """Yield executor context."""
        stage_loader = QQSL(MagicMock(), mock_sql_loader)
        stage_loader.resolve_sql_loader_and_execute = MagicMock()
        yield stage_loader

    def test_load_staging_raw_table(self, mock_stage_loader):
        """Test load_staging_raw_table."""
        stage_name = 'test_stage'
        skip_corrupted_rows = 'True'
        staging_raw = 'test_staging_raw'
        date = '2018-01-01'
        source_files_dict = {
            'files': [
                {'file_name': 'test1', 'file_size': 42}]}

        mock_stage_loader.load_staging_raw_table(
            staging_raw_table=staging_raw,
            source_files_dict=source_files_dict,
            date=date,
            stage_name=stage_name,
            skip_corrupted_rows=skip_corrupted_rows,
            licensor='theorchard')

        assert mock_stage_loader.resolve_sql_loader_and_execute.call_count == 1

        for file in source_files_dict['files']:
            mock_stage_loader.resolve_sql_loader_and_execute.assert_any_call(
                'load_staging_raw',
                params=dict(
                    db=mock.ANY,
                    schema=mock.ANY,
                    stage=stage_name,
                    on_error='CONTINUE',
                    staging_raw_table=staging_raw,
                    file_name=file['file_name'],
                    file_size=file['file_size'],
                    download_date=date,
                    licensor='theorchard',
                    ingestion_time=mock.ANY))


class TestQueryVersioning(object):
    """SQLLoader resolves the date-versioned queries sub folder."""

    @pytest.mark.parametrize('date, expected_folder', [
        ('2026-07-07', '2026-07-01'),
        ('2026-07-01', '2026-07-01'),
        ('2026-06-30', '2022-10-01'),
        ('2022-10-01', '2022-10-01'),
        ('2022-09-30', None),
    ])
    def test_sub_folder_resolution(self, date, expected_folder):
        """Resolve the queries sub folder for a reporting date.

        P0CY dates resolve to the 2026-07-01 folder, legacy dates to the
        2022-10-01 folder; dates before the baseline resolve to nothing.
        """
        loader = SQLLoader(qq_stage_loader.__file__)

        assert loader._get_sub_folder(date) == expected_folder