"""Unit tests for streams breakdown model layer."""

import datetime
from unittest.mock import patch

import pytest

from sound_recordings.models import streams_breakdown
from tests.unit.models.conftest import snowflake_fetch_assert

MOCK_SQL = "{filter_clause}"


@pytest.fixture
def mock_db_result():
    """Mock database result."""
    return "TEST", 0, 1, 2, 2, 1, 0, 3, datetime.date(2018, 7, 6)


@pytest.fixture
def mock_snowflake_fetchone(mock_db_result):
    """Mock Snowflake fetchone."""
    with patch(
        "sound_recordings.models.streams_breakdown.snowflake.fetchone"
    ) as fetchone:
        fetchone.return_value = mock_db_result
        yield fetchone


@pytest.fixture(autouse=True)
def no_cache():
    """Mock out caching of response."""
    with patch("sound_recordings.connectors.redis.client.get") as get:
        get.return_value = None
        yield get


@pytest.fixture
def mock_snowflake_fetchone_empty():
    """Mock Snowflake fetchone empty response."""
    with patch(
        "sound_recordings.models.streams_breakdown.snowflake.fetchone"
    ) as fetchone:
        fetchone.return_value = ()
        yield fetchone


@pytest.fixture
def mock_load_query():
    """Mock load query."""
    with patch("sound_recordings.models.streams_breakdown.SQLLoader") as sql_loader:
        load_query = sql_loader.load_query
        load_query.return_value = MOCK_SQL
        yield load_query


@pytest.fixture
def mock_store_availability():
    """Mock store_availability."""
    with patch(
        "sound_recordings.models.streams_breakdown.store_availability"
    ) as store_availability:
        store_availability.get_store_ids.return_value = [1, 286]
        yield store_availability


def test_get_streams_breakdown(
    mock_load_query, mock_snowflake_fetchone, mock_store_availability
):
    """Test successful response."""
    expected_response = {
        "isrc": "TEST",
        "streams_passive": 0,
        "streams_active": 1,
        "streams_collection": 2,
        "subscription": 2,
        "ad_supported": 1,
        "mid_tier": 0,
        "streams": 3,
    }

    permissions_filter = {
        "label_ids": [7123],
        "artist_ids": None,
        "subaccount_ids": None,
    }

    response = streams_breakdown.get_streams_breakdown(
        permissions_filter, "test", ["theorchard"]
    )
    assert response == expected_response
    mock_load_query.assert_called_with("streams_breakdown")


def test_get_streams_breakdown_fail(
    mock_snowflake_fetchone_empty, mock_store_availability
):
    """Test empty response."""
    permissions_filter = {
        "label_ids": [7123],
        "artist_ids": None,
        "subaccount_ids": None,
    }
    response = streams_breakdown.get_streams_breakdown(
        permissions_filter, "test", ["theorchard"]
    )
    assert response is None


def test_get_streams_breakdown_with_subaccount(
    mock_load_query, mock_snowflake_fetchone, mock_store_availability
):
    """Test get_sos_with_breakdown with subaccount."""
    permissions_filter = {
        "label_ids": None,
        "artist_ids": None,
        "subaccount_ids": [345],
        "feed_ids": [1, 2],
    }

    expected_args = {
        "label_ids": None,
        "artist_ids": None,
        "subaccount_ids": [345],
        "isrc": "isrc",
        "store_ids": [286],
        "feed_ids": [1, 2],
        "start_date": "2019-11-01",
        "end_date": "2019-12-01",
        "country_codes": ["DE", "NO"],
        "distributors": ["theorchard"],
    }

    streams_breakdown.get_streams_breakdown(
        permissions_filter,
        "isrc",
        ["theorchard"],
        ["DE", "NO"],
        [286, 712],
        "2019-11-01",
        "2019-12-01",
    )

    expected_sql = (
        "product_id IN (SELECT product_id FROM dim_release "
        "WHERE subaccountid IN (:subaccount_ids)) AND "
        "(download_activity_date BETWEEN :start_date AND :end_date)  "
        "AND feed_id IN (:feed_ids) "
    )
    snowflake_fetch_assert(mock_snowflake_fetchone, expected_sql, expected_args)
    mock_load_query.assert_called_with("streams_breakdown_by_country")


def test_get_streams_breakdown_with_empty_subaccount(
    mock_load_query, mock_snowflake_fetchone, mock_store_availability
):
    """Test get_sos_with_breakdown with empty subaccount."""
    permissions_filter = {
        "label_ids": [7123],
        "artist_ids": None,
        "subaccount_ids": None,
        "feed_ids": [1, 2],
    }

    expected_args = {
        "label_ids": [7123],
        "artist_ids": None,
        "subaccount_ids": None,
        "isrc": "isrc",
        "store_ids": [1],
        "feed_ids": [1, 2],
        "start_date": None,
        "end_date": None,
        "country_codes": ["DE", "NO"],
        "distributors": ["theorchard"],
    }

    streams_breakdown.get_streams_breakdown(
        permissions_filter, "isrc", ["theorchard"], ["DE", "NO"], [1], None, None
    )
    assert mock_snowflake_fetchone.call_count == 1
    call, *_ = mock_snowflake_fetchone.call_args_list
    (_, args), *_ = call
    assert args == expected_args
    mock_load_query.assert_called_with("streams_breakdown_by_country")


def test_get_streams_breakdown_with_artist_profile(
    mock_load_query, mock_snowflake_fetchone, mock_store_availability
):
    """Test get_sos_with_breakdown with empty subaccount."""
    permissions_filter = {
        "label_ids": None,
        "subaccount_ids": None,
        "artist_ids": [917636, 1552280],
        "feed_ids": [1, 2],
    }

    expected_args = {
        "label_ids": None,
        "subaccount_ids": None,
        "artist_ids": [917636, 1552280],
        "isrc": "isrc",
        "store_ids": [1, 286],
        "start_date": "2019-11-01",
        "end_date": "2019-12-01",
        "feed_ids": [1, 2],
        "distributors": ["theorchard"],
    }

    streams_breakdown.get_streams_breakdown(
        permissions_filter, "isrc", ["theorchard"], [], [], "2019-11-01", "2019-12-01"
    )
    assert mock_snowflake_fetchone.call_count == 1
    call, *_ = mock_snowflake_fetchone.call_args_list
    (_, args), *_ = call
    assert args == expected_args
    mock_load_query.assert_called_with("streams_breakdown")