"""Unit tests for the feature logic."""

from typing import Any
from unittest.mock import MagicMock, patch

from owsresponse import response

from account.logic import feature, vendor
from account.models import feature as feature_model

VENDOR_1_UUID = '87682992-bff2-40ff-aa75-18eb6214679e'
VENDOR_2_UUID = '6097ad5a-2186-4dbe-8286-82ce933d3538'
SUBACCOUNT_1_UUID = '11387154-0267-11ef-82c8-4a2888760684'
SUBACCOUNT_2_UUID = 'b1e2f3a4-0000-4000-8000-000000000002'
UNKNOWN_UUID = '00000000-0000-0000-0000-000000000000'


def test_get_enabled_features_for_vendor(monkeypatch):
    """Test getting the enabled features for a vendor."""
    vendor_id = 1

    features_response = response.Response(
        {
            'items': [
                {'feature_id': 1, 'feature_name': 'One'},
                {'feature_id': 2, 'feature_name': 'Two'},
            ]
        }
    )

    monkeypatch.setattr(vendor, 'is_vendor', MagicMock(return_value=response.Response()))

    monkeypatch.setattr(
        feature_model,
        'get_enabled_features_for_vendor',
        MagicMock(return_value=features_response),
    )

    result = feature.get_enabled_features_for_vendor(vendor_id)

    vendor.is_vendor.assert_called_once_with(vendor_id)
    feature_model.get_enabled_features_for_vendor.assert_called_once_with(vendor_id)
    assert result.message == features_response.message


def test_get_enabled_features_for_vendor_not_found(monkeypatch):
    """Test getting the enabled features for a vendor that's not found."""
    vendor_id = 1

    monkeypatch.setattr(
        vendor,
        'is_vendor',
        MagicMock(return_value=response.create_not_found_response()),
    )

    result = feature.get_enabled_features_for_vendor(vendor_id)

    vendor.is_vendor.assert_called_once_with(vendor_id)
    assert result.status == 404


def test_bulk_add_restricted_features_for_vendor(monkeypatch):
    """Test bulk adding restricted features for vendor."""
    vendor_id = 1
    feature_ids = [2, 3]
    bulk_add_restricted_features_response = response.Response(
        [
            {'vendor_id': vendor_id, 'feature_id': 2},
            {'vendor_id': vendor_id, 'feature_id': 3},
        ]
    )

    monkeypatch.setattr(vendor, 'is_vendor', MagicMock(return_value=response.Response(True)))
    monkeypatch.setattr(
        feature_model,
        'is_valid_features',
        MagicMock(return_value=response.Response(True)),
    )
    monkeypatch.setattr(
        feature_model,
        'bulk_add_restricted_features_for_vendor',
        MagicMock(return_value=bulk_add_restricted_features_response),
    )

    result = feature.bulk_add_restricted_features_for_vendor(vendor_id, feature_ids)

    vendor.is_vendor.assert_called_once_with(vendor_id)
    feature_model.is_valid_features.assert_called_once_with(feature_ids)
    feature_model.bulk_add_restricted_features_for_vendor.assert_called_once_with(
        vendor_id, feature_ids
    )
    assert result.message == bulk_add_restricted_features_response.message


def test_bulk_add_restricted_features_for_vendor_not_found_vendor(monkeypatch):
    """Test bulk adding restricted features for invalid vendor."""
    vendor_id = -23
    feature_ids = [2, 3]

    monkeypatch.setattr(
        vendor,
        'is_vendor',
        MagicMock(return_value=response.create_not_found_response()),
    )
    monkeypatch.setattr(feature_model, 'is_valid_features', MagicMock(return_value=None))
    monkeypatch.setattr(
        feature_model,
        'bulk_add_restricted_features_for_vendor',
        MagicMock(return_value=None),
    )

    result = feature.bulk_add_restricted_features_for_vendor(vendor_id, feature_ids)

    vendor.is_vendor.assert_called_once_with(vendor_id)
    feature_model.is_valid_features.assert_not_called()
    feature_model.bulk_add_restricted_features_for_vendor.assert_not_called()
    assert result.status == 404


def test_bulk_add_restricted_features_for_vendor_not_found_feature(monkeypatch):
    """Test bulk adding invalid features for vendor."""
    vendor_id = 1
    feature_ids = [-23]

    monkeypatch.setattr(vendor, 'is_vendor', MagicMock(return_value=response.Response()))
    monkeypatch.setattr(
        feature_model,
        'is_valid_features',
        MagicMock(return_value=response.create_not_found_response()),
    )
    monkeypatch.setattr(
        feature_model,
        'bulk_add_restricted_features_for_vendor',
        MagicMock(return_value=None),
    )

    result = feature.bulk_add_restricted_features_for_vendor(vendor_id, feature_ids)

    vendor.is_vendor.assert_called_once_with(vendor_id)
    feature_model.is_valid_features.assert_called_once_with(feature_ids)
    feature_model.bulk_add_restricted_features_for_vendor.assert_not_called()
    assert result.status == 404


@patch('account.logic.feature.format_for_dataloader')
@patch('account.logic.feature.feature_model')
@patch('account.logic.feature.mysql')
def test_lookup_features_by_vendor_uuids(
    mock_mysql: MagicMock,
    mock_feature_model: MagicMock,
    mock_format_for_dataloader: MagicMock,
) -> None:
    """Test looking up enabled feature IDs for vendors by UUID."""
    uuids = [VENDOR_1_UUID, VENDOR_2_UUID, UNKNOWN_UUID]

    mock_feature_model.get_enabled_feature_ids_for_vendor_uuids.return_value = {
        VENDOR_2_UUID: [1, 2, 3],
        VENDOR_1_UUID: [1, 2],
    }

    expected_vendors: list[Any] = [
        {'vendor_uuid': VENDOR_1_UUID, 'feature_ids': [1, 2]},
        {'vendor_uuid': VENDOR_2_UUID, 'feature_ids': [1, 2, 3]},
        None,
    ]
    mock_format_for_dataloader.return_value = expected_vendors

    result = feature.lookup_features_by_vendor_uuids(uuids)

    mock_session = mock_mysql.session_scope.return_value.__enter__.return_value
    mock_mysql.session_scope.assert_called_once_with(read_only=True)
    mock_feature_model.get_enabled_feature_ids_for_vendor_uuids.assert_called_once_with(
        uuids, mock_session
    )
    assert result.status == 200
    assert result.message == {'vendors': expected_vendors}
    mock_format_for_dataloader.assert_called_once_with(
        [
            {'vendor_uuid': VENDOR_2_UUID, 'feature_ids': [1, 2, 3]},
            {'vendor_uuid': VENDOR_1_UUID, 'feature_ids': [1, 2]},
        ],
        uuids,
        'vendor_uuid',
    )


@patch('account.logic.feature.format_for_dataloader')
@patch('account.logic.feature.feature_model')
@patch('account.logic.feature.mysql')
def test_lookup_features_by_subaccount_uuids(
    mock_mysql: MagicMock,
    mock_feature_model: MagicMock,
    mock_format_for_dataloader: MagicMock,
) -> None:
    """Test looking up enabled feature IDs for subaccounts by UUID."""
    uuids = [SUBACCOUNT_1_UUID, SUBACCOUNT_2_UUID, UNKNOWN_UUID]

    mock_feature_model.get_enabled_feature_ids_for_subaccount_uuids.return_value = {
        SUBACCOUNT_2_UUID: [1, 2, 3],
        SUBACCOUNT_1_UUID: [1, 2],
    }

    expected_subaccounts: list[Any] = [
        {'subaccount_uuid': SUBACCOUNT_1_UUID, 'feature_ids': [1, 2]},
        {'subaccount_uuid': SUBACCOUNT_2_UUID, 'feature_ids': [1, 2, 3]},
        None,
    ]
    mock_format_for_dataloader.return_value = expected_subaccounts

    result = feature.lookup_features_by_subaccount_uuids(uuids)

    mock_session = mock_mysql.session_scope.return_value.__enter__.return_value
    mock_mysql.session_scope.assert_called_once_with(read_only=True)
    mock_feature_model.get_enabled_feature_ids_for_subaccount_uuids.assert_called_once_with(
        uuids, mock_session
    )
    assert result.status == 200
    assert result.message == {'subaccounts': expected_subaccounts}
    mock_format_for_dataloader.assert_called_once_with(
        [
            {'subaccount_uuid': SUBACCOUNT_2_UUID, 'feature_ids': [1, 2, 3]},
            {'subaccount_uuid': SUBACCOUNT_1_UUID, 'feature_ids': [1, 2]},
        ],
        uuids,
        'subaccount_uuid',
    )


def test_bulk_remove_restricted_features_for_vendor(monkeypatch):
    """Test bulk removing restricted features for vendor."""
    vendor_id = 1
    feature_ids = [2, 3]
    bulk_remove_restricted_features_response = response.Response(feature_ids)

    monkeypatch.setattr(
        feature_model,
        'bulk_remove_restricted_features_for_vendor',
        MagicMock(return_value=bulk_remove_restricted_features_response),
    )

    result = feature.bulk_remove_restricted_features_for_vendor(vendor_id, feature_ids)

    feature_model.bulk_remove_restricted_features_for_vendor.assert_called_once_with(
        vendor_id, feature_ids
    )
    assert result.message == bulk_remove_restricted_features_response.message