"""Tests for hfa logic."""

import pytest
from unittest.mock import MagicMock
import pandas as pd

from product.logic import hfa
from product.models import hfa as hfa_model


@pytest.fixture
def mock_abacus_active_contract_df(mock_get_all_active_contract_mechanical_deductions_response):
    """Returns a mock abacus_active_contract_df DataFrame."""
    df = pd.DataFrame(mock_get_all_active_contract_mechanical_deductions_response)
    return df.astype({"account_id": "int64", "contract_id": "int64", "term_type": "string"})


@pytest.fixture
def mock_filtered_abacus_active_contract_df():
    """Returns a mock filtered_abacus_active_contract_df DataFrame."""
    return pd.DataFrame(
        [
            {
                "track_id": 103,
                "track_isrc": "USGHI7654321",
                "upc": "135789012346",
                "vendor_id": 1,
                "matched_term_type": "track",
                "mechanical_type": ["digital", "physical"],
                "contract_id": 3,
            },
        ]
    )


@pytest.fixture
def mock_empty_filtered_abacus_active_contract_df():
    """Returns a mock empty filtered_abacus_active_contract_df DataFrame."""
    return pd.DataFrame(
        [],
        columns=[
            "track_id",
            "track_isrc",
            "upc",
            "vendor_id",
            "matched_term_type",
            "mechanical_type",
            "contract_id",
        ],
    )


@pytest.fixture
def mock_hfa_filtered_eligible_digital_physical_releases_df():
    """Returns a Filtered HFA eligible digital/physical tracks DataFrame."""
    return pd.DataFrame(
        [
            {"track_id": 101, "hfa_configuration_code": "SP"},
            {"track_id": 102, "hfa_configuration_code": "CD"},
            {"track_id": 102, "hfa_configuration_code": "LP"},
            {"track_id": 102, "hfa_configuration_code": "CS"},
            {"track_id": 103, "hfa_configuration_code": "SP"},
        ]
    )


@pytest.fixture
def mock_hfa_filtered_eligible_ringtones_df():
    """Returns a Filtered HFA eligible ringtone tracks DataFrame."""
    return pd.DataFrame(
        [
            {"track_id": 501, "hfa_configuration_code": "RT"},
        ]
    )


@pytest.fixture
def mock_hfa_filtered_empty_df():
    """Returns a Filtered HFA empty Dataframe."""
    return pd.DataFrame(columns=["track_id", "hfa_configuration_code"])


def test_get_hfa_tracks_for_processing(monkeypatch, mock_hfa_eligible_tracks):
    """Test get_hfa_tracks_for_processing returns expected result."""

    monkeypatch.setattr(
        hfa_model,
        "get_hfa_eligible_tracks",
        MagicMock(return_value=mock_hfa_eligible_tracks),
    )

    result = hfa.get_hfa_tracks_for_processing()

    expected = [
            {
                "track_id": 101,
                "track_isrc": "USABC1234567",
                "upc": "123456789012",
                "release_id": 201,
                "vendor_id": 3,
                "hfa_configuration_code": "CD",
                "trans_type": "digital",
            },
            {
                "track_id": 102,
                "track_isrc": "USDEF7654321",
                "upc": "987654321098",
                "release_id": 202,
                "vendor_id": 3,
                "hfa_configuration_code": "LP",
                "trans_type": "physical",
            },
            {
                "track_id": 501,
                "track_isrc": "USXYZ1234567",
                "upc": "112233445566",
                "release_id": None,
                "vendor_id": 3,
                "hfa_configuration_code": "RT",
                "trans_type": "digital",
            }
        ]

    assert result.status == 200
    assert result.message == expected

    hfa_model.get_hfa_eligible_tracks.assert_called_once()


def test_get_hfa_tracks_for_processing_handles_exception(monkeypatch, context):
    """Test get_hfa_tracks_for_processing returns fatal response when exception occurs."""

    monkeypatch.setattr(
        hfa_model,
        "get_hfa_eligible_tracks",
        MagicMock(side_effect=Exception("Simulated failure")),
    )

    result = hfa.get_hfa_tracks_for_processing()

    assert result.status == 500
    assert result.errors["message"] == "Failed to fetch HFA pending tracks."
    context.g.log.exception.assert_called_once()