"""Test Product Configuration Logic."""
from oto import response

from product_configuration.logic import product_configuration
from product_configuration.models import distribution_format
from product_configuration.models import distribution_format_media
from product_configuration.models import distribution_format_media_format
from product_configuration.models import supply_chain
from product_configuration.models import supply_chain_defaults
from product_configuration.supply_chain import supply_chain_configuration_schemas # noqa


def test_get_distribution_format_media_types_success(
        mocker, distribution_format_media_types):
    """Test successful retrieval of distribution_format_media types."""
    mocker.patch.object(
        distribution_format_media, 'get_all_media_types',
        return_value=response.Response(
            status=200, message=distribution_format_media_types))

    result = product_configuration.get_distribution_format_media_types()

    assert result.status == 200
    assert result.message == {
        'items': distribution_format_media_types,
        'pagination': {
            'type': 'standard',
            'offset': 0,
            'limit': len(distribution_format_media_types),
            'total_records': len(distribution_format_media_types)
        }
    }


def test_get_distribution_format_media_types_failure(mocker):
    """Test unsuccessful retrieval of distribution_format_media types."""
    mocker.patch.object(
        distribution_format_media, 'get_all_media_types',
        return_value=response.create_fatal_response())

    result = product_configuration.get_distribution_format_media_types()

    assert result.status == 500


def test_get_distribution_format_media_formats_success(
        mocker, distribution_format_media_formats):
    """Test successful retrieval of distribution_format_media formats."""
    mocker.patch.object(
        distribution_format_media_format, 'get_all_media_formats',
        return_value=response.Response(
            status=200, message=distribution_format_media_formats))

    result = product_configuration.get_distribution_format_media_formats()

    assert result.status == 200
    assert result.message == {
        'items': distribution_format_media_formats,
        'pagination': {
            'type': 'standard',
            'offset': 0,
            'limit': len(distribution_format_media_formats),
            'total_records': len(distribution_format_media_formats)
        }
    }


def test_get_distribution_format_media_formats_failure(mocker):
    """Test unsuccessful retrieval of distribution_format_media types."""
    mocker.patch.object(
        distribution_format_media_format, 'get_all_media_formats',
        return_value=response.create_fatal_response())

    result = product_configuration.get_distribution_format_media_formats()

    assert result.status == 500


def test_get_distribution_formats_success(mocker, distribution_formats):
    """Test sucessful retrieval of distribution_formats."""
    mocker.patch.object(
        distribution_format, 'get_all_formats',
        return_value=response.Response(message=distribution_formats))

    result = product_configuration.get_distribution_formats()

    assert result.status == 200
    assert result.message == {
        'items': distribution_formats,
        'pagination': {
            'type': 'standard',
            'offset': 0,
            'limit': len(distribution_formats),
            'total_records': len(distribution_formats)
        }
    }


def test_get_distribution_formats_failure(mocker):
    """Test unsuccessful retrieval of distribution_formats."""
    mocker.patch.object(
        distribution_format, 'get_all_formats',
        return_value=response.create_fatal_response())

    result = product_configuration.get_distribution_formats()

    assert result.status == 500


def test_get_supply_chain_configuration_schemas(
        mocker, supply_chain_configuration_schema):
    """Test retrieval of supply chain configuration schemas."""
    mocker.patch.object(
        supply_chain, 'get_configuration_schemas',
        return_value=response.Response(
            message=supply_chain_configuration_schema))

    result = product_configuration.get_supply_chain_configuration_schemas()

    assert result.status == 200
    assert result.message == supply_chain_configuration_schema


def test_get_supply_chain_configurations_success(
        mocker, proper_supply_chain_configurations):
    """Test retrieving configurations for a given supply chain."""
    supply_chain_id = 1

    mocker.patch.object(
        supply_chain, 'is_supply_chain_id_valid', return_value=True)
    mocker.patch.object(
        supply_chain, 'get_configurations',
        return_value=response.Response(
            message=proper_supply_chain_configurations))

    result = product_configuration.get_supply_chain_configurations(supply_chain_id) # noqa

    assert result.status == 200
    assert result.message == proper_supply_chain_configurations


def test_get_supply_chain_configurations_failure(
        mocker, proper_supply_chain_configurations):
    """Test retrieving configurations for an invalid supply chain."""
    invalid_supply_chain_id = 2
    mocker.patch.object(
        supply_chain, 'is_supply_chain_id_valid', return_value=False)

    result = product_configuration.get_supply_chain_configurations(invalid_supply_chain_id) # noqa

    assert result.status == 404


def test_get_supply_chain_configuration_success(
        mocker, proper_supply_chain_configurations):
    """Test retrieving a single supply chain configuration."""
    supply_chain_id = 1
    distribution_format_id = 1
    expected_configuration = proper_supply_chain_configurations[0]

    mocker.patch.object(
        supply_chain, 'is_supply_chain_id_valid', return_value=True)

    mocker.patch.object(
        supply_chain, 'get_configuration_by_distribution_format',
        return_value=response.Response(message=expected_configuration))

    result = product_configuration.get_supply_chain_configuration(
        supply_chain_id, distribution_format_id)

    assert result.status == 200
    assert result.message == expected_configuration


def test_get_supply_chain_configuration_failure(
        mocker, proper_supply_chain_configurations):
    """Test retrieving a single supply chain configuration.

    Invalid distribution format id.
    """
    supply_chain_id = 1
    distribution_format_id = 100

    mocker.patch.object(
        supply_chain, 'is_supply_chain_id_valid', return_value=True)

    mocker.patch.object(
        supply_chain, 'get_configuration_by_distribution_format',
        return_value=response.create_not_found_response())

    result = product_configuration.get_supply_chain_configuration(
        supply_chain_id, distribution_format_id)

    assert result.status == 404


def test_get_supply_chain_configuration_failure_supply_chain_id(
        mocker, proper_supply_chain_configurations):
    """Test retrieving a single supply chain configuration.

    Invalid supply_chain_id.
    """
    supply_chain_id = 100
    distribution_format_id = 1

    mocker.patch.object(
        supply_chain, 'is_supply_chain_id_valid', return_value=False)

    result = product_configuration.get_supply_chain_configuration(
        supply_chain_id, distribution_format_id)

    assert result.status == 404


def test_get_supply_chain_dafault_success(
        mocker, supply_chain_default_value, supply_chain_dafault_types_logic):
    """Test successful retrieval of supply chain defaults."""
    mocker.patch.object(
        supply_chain_defaults, 'get_all_defaults',
        return_value=supply_chain_default_value)
    result = product_configuration.get_supply_chain_defaults()
    assert result.status == 200
    assert result.message == supply_chain_dafault_types_logic


def test_get_distribution_format_by_distribution_format_id(
        mocker, distribution_format_value):
    """Test retrieving distribution format record based on id."""
    distribution_format_id = 2

    mocker.patch.object(
        distribution_format,
        'get_distribution_format_by_distribution_format_id',
        return_value=distribution_format_value)

    result = product_configuration. \
        get_distribution_format_by_distribution_format_id(
            distribution_format_id)

    assert result.status == 200
    assert result.message == distribution_format_value[0]