"""Test for Sony SME."""

from unittest.mock import MagicMock

import pytest
from owsresponse import response

from account.logic import sme
from account.models import (
    owner as owner_model,
    subaccount as subaccount_model,
    vendor as vendor_model,
)


@pytest.fixture
def fixture_found_response():
    """Fixture response for data of status OK."""
    return response.Response()


@pytest.fixture
def fixture_not_found_response():
    """Fixture response for data that is not found."""
    return response.create_not_found_response()


@pytest.fixture
def fixture_owner_from_vendor():
    """Fixture response for an owner from vendor."""
    return response.Response({'owner': 'TEST1'})


@pytest.fixture
def fixture_vendor_from_subaccount():
    """Fixture response for a vendor from a subaccount."""
    return response.Response({'vendor_id': 1})


@pytest.fixture
def fixture_sme_owner_from_owner():
    """Fixture response for an SME owner."""
    return response.Response(
        {
            'owner_id': '12345',
            'owner_abbrivation': 'TEST1',
            'gras_sender_name': 'present',
        }
    )


@pytest.fixture
def fixture_non_sme_owner_from_owner():
    """Fixture response for non SME owner from an owner."""
    return response.Response(
        {'owner_id': '12345', 'owner_abbrivation': 'TEST1', 'gras_sender_name': ''}
    )


def test_vendor_is_sme(monkeypatch, fixture_owner_from_vendor, fixture_sme_owner_from_owner):
    """Test correct return status for SME vendors."""
    monkeypatch.setattr(
        vendor_model, 'get_owner', MagicMock(return_value=fixture_owner_from_vendor)
    )
    monkeypatch.setattr(
        owner_model, 'get_owner', MagicMock(return_value=fixture_sme_owner_from_owner)
    )

    result = sme.is_sme_vendor(1)
    owner_model.get_owner.assert_called_with(vendor_model.get_owner(1).message.get('owner'))

    assert result


def test_vendor_not_sme(monkeypatch, fixture_owner_from_vendor, fixture_non_sme_owner_from_owner):
    """Test correct status return for non-SME vendors."""
    monkeypatch.setattr(
        vendor_model, 'get_owner', MagicMock(return_value=fixture_owner_from_vendor)
    )
    monkeypatch.setattr(
        owner_model,
        'get_owner',
        MagicMock(return_value=fixture_non_sme_owner_from_owner),
    )

    result_non_sme = sme.is_sme_vendor(1)
    owner_model.get_owner.assert_called_with(vendor_model.get_owner(1).message.get('owner'))

    assert not result_non_sme
    assert result_non_sme.status == 404


def test_vendor_is_sme_vendor_not_found(monkeypatch, fixture_not_found_response):
    """Test correct status return for non-existent vendor."""
    monkeypatch.setattr(
        vendor_model, 'get_owner', MagicMock(return_value=fixture_not_found_response)
    )

    result_vendor_not_found = sme.is_sme_vendor(1)

    assert not result_vendor_not_found
    assert result_vendor_not_found.status == 404


def test_vendor_is_sme_owner_not_found(
    monkeypatch, fixture_not_found_response, fixture_owner_from_vendor
):
    """Test correct status return for non-existent owner."""
    monkeypatch.setattr(
        vendor_model, 'get_owner', MagicMock(return_value=fixture_owner_from_vendor)
    )
    monkeypatch.setattr(
        owner_model, 'get_owner', MagicMock(return_value=fixture_not_found_response)
    )

    result_owner_not_found = sme.is_sme_vendor(1)

    assert not result_owner_not_found
    assert result_owner_not_found.status == 404


def test_subaccount_is_sme(monkeypatch, fixture_found_response, fixture_vendor_from_subaccount):
    """Test correct return status for SME vendors given a subaccount_id."""
    monkeypatch.setattr(
        subaccount_model,
        'get_subaccount',
        MagicMock(return_value=fixture_vendor_from_subaccount),
    )

    monkeypatch.setattr(sme, 'is_sme_vendor', MagicMock(return_value=fixture_found_response))

    result = sme.is_sme_subaccount(1)
    sme.is_sme_vendor.assert_called_with(
        subaccount_model.get_subaccount(1).message.get('vendor_id')
    )

    assert result


def test_subaccount_is_not_sme(
    monkeypatch, fixture_not_found_response, fixture_vendor_from_subaccount
):
    """Test correct return status for SME vendors given a subaccount_id."""
    monkeypatch.setattr(
        subaccount_model,
        'get_subaccount',
        MagicMock(return_value=fixture_vendor_from_subaccount),
    )

    monkeypatch.setattr(sme, 'is_sme_vendor', MagicMock(return_value=fixture_not_found_response))

    result_vendor_not_sme = sme.is_sme_subaccount(1)
    sme.is_sme_vendor.assert_called_with(
        subaccount_model.get_subaccount(1).message.get('vendor_id')
    )

    assert not result_vendor_not_sme
    assert result_vendor_not_sme.status == 404


def test_subaccount_is_sme_vendor_not_found(monkeypatch, fixture_not_found_response):
    """Test return status for invalid vendor given subaccount_id."""
    monkeypatch.setattr(
        subaccount_model,
        'get_subaccount',
        MagicMock(return_value=fixture_not_found_response),
    )

    result_vendor_not_found = sme.is_sme_subaccount(1)

    assert not result_vendor_not_found
    assert result_vendor_not_found.status == 404