"""Tests for Store Pricing Tier Code logic."""

from unittest.mock import MagicMock

from oto import response

from pricing.constants import error
from pricing.logic import store_pricing_tier_code
from pricing.models import store_pricing_tier_code as \
    store_pricing_tier_code_model
from pricing.models import store_pricing_tier_code_territory as \
    store_pricing_tier_code_territory_model

import pytest


@pytest.fixture
def fixture_store_pricing_tier_code():
    """Fixture for single store pricing tier code."""
    return response.Response({
        'store_pricing_tier_code_id': 10,
        'price_code': '100',
        'resolution': 'HD'})


@pytest.fixture
def fixture_store_pricing_tier_code_territories():
    """Fixture for a store pricing tier code territories update response."""
    return response.Response({
        'items': {
            'created': [
                {
                    'territory_code': 'US'
                }
            ],
            'deleted': []
        }
    })


@pytest.fixture
def fixture_error():
    """Fixture for an error response."""
    return response.Response(status=500)


@pytest.fixture
def fixture_find_duplicate_true():
    """Fixture for a positive find_duplicate response."""
    return response.Response({
        'found': True,
        'item': {
            'store_pricing_tier_code_id': 1
        }
    })


@pytest.fixture
def fixture_find_duplicate_false():
    """Fixture for a negative find_duplicate response."""
    return response.Response({'found': False})


@pytest.fixture
def fixture_get_territories():
    """Fixure for a get territories response."""
    return response.Response({
        'items': [
            {
                'territory_code': 'US'
            },
            {
                'territory_code': 'CA'
            }
        ]
    })


def test_create(
        monkeypatch, fixture_store_pricing_tier_code):
    """Test creating a store pricing tier code."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'create',
        MagicMock(return_value=fixture_store_pricing_tier_code))

    monkeypatch.setattr(
        store_pricing_tier_code,
        'has_duplicate',
        MagicMock(return_value=False))

    store_pricing_tier_id = 1
    data = {
        'price_code': '100',
        'resolution': 'HD'}

    result = store_pricing_tier_code.create(store_pricing_tier_id, data)

    store_pricing_tier_code_model.create.assert_called_with(
        store_pricing_tier_id, data)

    assert result
    assert result.message == fixture_store_pricing_tier_code.message


def test_create_with_error(monkeypatch, fixture_error):
    """Test error response when creating a store pricing tier code."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'create',
        MagicMock(return_value=fixture_error))

    monkeypatch.setattr(
        store_pricing_tier_code,
        'has_duplicate',
        MagicMock(return_value=False))

    store_pricing_tier_id = 1
    data = {}

    result = store_pricing_tier_code.create(store_pricing_tier_id, data)

    assert result.status == fixture_error.status


def test_create_with_territories(
        monkeypatch, fixture_store_pricing_tier_code,
        fixture_store_pricing_tier_code_territories):
    """Test creating a store pricing tier code with some territories."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'create',
        MagicMock(return_value=fixture_store_pricing_tier_code))

    monkeypatch.setattr(
        store_pricing_tier_code_territory_model,
        'update_territories',
        MagicMock(return_value=fixture_store_pricing_tier_code_territories))

    monkeypatch.setattr(
        store_pricing_tier_code,
        'has_duplicate',
        MagicMock(return_value=False))

    store_pricing_tier_id = 1
    create_data = {
        'price_code': '100',
        'resolution': 'HD'
    }
    territories = ['US']
    data = dict(create_data)
    data['territories'] = territories

    expected_result = fixture_store_pricing_tier_code.message
    expected_result['territories'] = \
        fixture_store_pricing_tier_code_territories.message

    result = store_pricing_tier_code.create(store_pricing_tier_id, data)

    assert result

    store_pricing_tier_code_id = result.message['store_pricing_tier_code_id']

    store_pricing_tier_code_model.create.assert_called_with(
        store_pricing_tier_id, create_data)
    store_pricing_tier_code_territory_model.update_territories.\
        assert_called_with(store_pricing_tier_code_id, territories)

    assert result.message == expected_result


def test_create_with_territories_and_error(
        monkeypatch, fixture_store_pricing_tier_code, fixture_error):
    """Test error response during territories update."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'create',
        MagicMock(return_value=fixture_store_pricing_tier_code))

    monkeypatch.setattr(
        store_pricing_tier_code_territory_model,
        'update_territories',
        MagicMock(return_value=fixture_error))

    monkeypatch.setattr(
        store_pricing_tier_code,
        'has_duplicate',
        MagicMock(return_value=False))

    store_pricing_tier_id = 1
    data = {'territories': ['US']}

    result = store_pricing_tier_code.create(store_pricing_tier_id, data)
    assert result.status == 500


def test_create_duplicate(monkeypatch):
    """Test duplicate response when creating a store pricing tier code."""
    monkeypatch.setattr(
        store_pricing_tier_code,
        'has_duplicate',
        MagicMock(return_value=True))

    store_pricing_tier_id = 1
    data = {}

    result = store_pricing_tier_code.create(store_pricing_tier_id, data)

    assert result.status == 400
    assert result.errors['message'] == error.ERROR_MESSAGE_DUPLICATE


def test_update(
        monkeypatch, fixture_store_pricing_tier_code):
    """Test updating a store pricing tier code by ID."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'update',
        MagicMock(return_value=fixture_store_pricing_tier_code))

    store_pricing_tier_id = 1
    store_pricing_tier_code_id = 10
    data = {
        'price_code': '100',
        'resolution': 'HD'}

    result = store_pricing_tier_code.update(
        store_pricing_tier_id, store_pricing_tier_code_id, data)

    store_pricing_tier_code_model.update.assert_called_with(
        store_pricing_tier_id, store_pricing_tier_code_id, data)

    assert result
    assert result.message == fixture_store_pricing_tier_code.message


def test_update_with_error(monkeypatch, fixture_error):
    """Test error response when update a store pricing tier code."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'update',
        MagicMock(return_value=fixture_error))

    store_pricing_tier_id = 1
    store_pricing_tier_code_id = 10
    data = {}

    result = store_pricing_tier_code.update(
        store_pricing_tier_id, store_pricing_tier_code_id, data)

    assert result.status == 500


def test_update_with_territories(
        monkeypatch, fixture_store_pricing_tier_code,
        fixture_store_pricing_tier_code_territories):
    """Test updating a store pricing tier code with some territories."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'update',
        MagicMock(return_value=fixture_store_pricing_tier_code))

    monkeypatch.setattr(
        store_pricing_tier_code_territory_model,
        'update_territories',
        MagicMock(return_value=fixture_store_pricing_tier_code_territories))

    store_pricing_tier_id = 1
    store_pricing_tier_code_id = 10
    update_data = {
        'price_code': '100',
        'resolution': 'HD'
    }
    territories = ['US']
    data = dict(update_data)
    data['territories'] = territories

    expected_result = fixture_store_pricing_tier_code.message
    expected_result['territories'] = \
        fixture_store_pricing_tier_code_territories.message

    result = store_pricing_tier_code.update(
        store_pricing_tier_id, store_pricing_tier_code_id, data)

    assert result

    store_pricing_tier_code_model.update.assert_called_with(
        store_pricing_tier_id, store_pricing_tier_code_id, update_data)
    store_pricing_tier_code_territory_model.update_territories.\
        assert_called_with(store_pricing_tier_code_id, territories)

    assert result.message == expected_result


def test_update_with_territories_and_error(
        monkeypatch, fixture_store_pricing_tier_code, fixture_error):
    """Test error response during territories update."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'update',
        MagicMock(return_value=fixture_store_pricing_tier_code))

    monkeypatch.setattr(
        store_pricing_tier_code_territory_model,
        'update_territories',
        MagicMock(return_value=fixture_error))

    store_pricing_tier_id = 1
    store_pricing_tier_code_id = 10
    data = {'territories': ['US']}

    result = store_pricing_tier_code.update(
        store_pricing_tier_id, store_pricing_tier_code_id, data)

    assert result.status == 500


def test_find_duplicate_true(
        monkeypatch, fixture_find_duplicate_true, fixture_get_territories):
    """Test finding an existing duplicate store pricing tier code."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'find_duplicate',
        MagicMock(return_value=fixture_find_duplicate_true))

    monkeypatch.setattr(
        store_pricing_tier_code_territory_model,
        'get_by_store_pricing_tier_code_id',
        MagicMock(return_value=fixture_get_territories))

    store_pricing_tier_id = 1
    data = {
        'price_code': '100',
        'resolution': '4K',
        'applies_worldwide': False,
        'territory_list_include': True
    }
    territories = ['US', 'CA']

    result = store_pricing_tier_code.has_duplicate(
        store_pricing_tier_id, data, territories)

    assert result is True


def test_find_duplicate_false(
        monkeypatch, fixture_find_duplicate_false):
    """Test finding a non-existing duplicate store pricing tier code."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'find_duplicate',
        MagicMock(return_value=fixture_find_duplicate_false))

    store_pricing_tier_id = 10
    data = {
        'price_code': '100',
        'resolution': '4K',
        'applies_worldwide': False,
        'territory_list_include': True
    }
    territories = []

    result = store_pricing_tier_code.has_duplicate(
        store_pricing_tier_id, data, territories)

    assert result is False


def test_find_duplicate_with_territories_false(
        monkeypatch, fixture_find_duplicate_true, fixture_get_territories):
    """Test finding a non-existing duplicate SPTC with territories."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'find_duplicate',
        MagicMock(return_value=fixture_find_duplicate_true))

    monkeypatch.setattr(
        store_pricing_tier_code_territory_model,
        'get_by_store_pricing_tier_code_id',
        MagicMock(return_value=fixture_get_territories))

    store_pricing_tier_id = 1
    data = {
        'price_code': '100',
        'resolution': '4K',
        'applies_worldwide': False,
        'territory_list_include': True
    }
    territories = ['US', 'CA', 'FR']

    result = store_pricing_tier_code.has_duplicate(
        store_pricing_tier_id, data, territories)

    assert result is False


def test_find_duplicate_error(monkeypatch, fixture_error):
    """Test that an exception is raised if an error occurred."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'find_duplicate',
        MagicMock(return_value=fixture_error))

    store_pricing_tier_id = 1
    data = {
        'price_code': '100',
        'resolution': '4K',
        'applies_worldwide': False,
        'territory_list_include': True
    }
    territories = []

    try:
        store_pricing_tier_code.has_duplicate(
            store_pricing_tier_id, data, territories)
    except Exception as err:
        assert err


def test_find_duplicate_with_territories_error(
        monkeypatch, fixture_find_duplicate_true, fixture_error):
    """Test that an exception is raised if an error occurred."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'find_duplicate',
        MagicMock(return_value=fixture_find_duplicate_true))

    monkeypatch.setattr(
        store_pricing_tier_code_territory_model,
        'get_by_store_pricing_tier_code_id',
        MagicMock(return_value=fixture_error))

    store_pricing_tier_id = 1
    data = {
        'price_code': '100',
        'resolution': '4K',
        'applies_worldwide': False,
        'territory_list_include': True
    }
    territories = ['US', 'CA']

    try:
        store_pricing_tier_code.has_duplicate(
            store_pricing_tier_id, data, territories)
    except Exception as err:
        assert err


def test_delete_store_pricing_tier(
        monkeypatch, fixture_store_pricing_tier_code):
    """Test deleting a store pricing tier code by ID."""
    monkeypatch.setattr(
        store_pricing_tier_code_model,
        'delete',
        MagicMock(return_value=fixture_store_pricing_tier_code))

    monkeypatch.setattr(
        store_pricing_tier_code_territory_model,
        'delete_by_store_pricing_tier_code_id',
        MagicMock(return_value=response.Response()))

    result = store_pricing_tier_code.delete(1)

    store_pricing_tier_code_territory_model.delete_by_store_pricing_tier_code_id.\
        assert_called_with(1)
    store_pricing_tier_code_model.delete.assert_called_with(1)
    assert result.status == 200
    assert result.message == fixture_store_pricing_tier_code.message