"""Unit tests for product_pricing_override model."""

from pricing.models import product_pricing_override

import pytest

from tests.utils import db_operations


@pytest.fixture
def db_fixture():
    """Drop and re-create all the SQLite tables and seed them."""
    db_operations.create_tables()
    db_operations.seed_data()


def test_get_by_product_id(db_fixture):
    """Test that the product pricing overrides can be returned."""
    result = product_pricing_override.get_by_product_id(1)

    assert result
    assert len(result.message['items']) == 2


def test_get_by_product_id_not_found(db_fixture):
    """Test that an empty list response is returned if no result is found."""
    result = product_pricing_override.get_by_product_id(100)

    assert result.status == 200
    assert len(result.message['items']) == 0


def test_create_product_pricing_override(db_fixture):
    """Test that a product pricing override can be created."""
    data = {
        'product_id': 4,
        'product_pricing_override_id': 5,
        'applies_worldwide': True,
        'store_id': 1,
        'pricing_family_id': 1,
        'orchard_pricing_tier_id': 2
    }

    result = product_pricing_override.create_product_pricing_override(4, data)

    created_product_pricing_override = result.message

    assert created_product_pricing_override['product_id'] == 4
    assert created_product_pricing_override['product_pricing_override_id'] == 5
    assert created_product_pricing_override['applies_worldwide'] is True
    assert created_product_pricing_override['store_id'] == 1
    assert created_product_pricing_override['orchard_pricing_tier_id'] == 2


def test_create_product_pricing_override_no_pricing_family(db_fixture):
    """Test that a product with no pricing family id is validated."""
    data = {
        'product_id': 4,
        'product_pricing_override_id': 5,
        'applies_worldwide': True,
        'store_id': 1,
        'orchard_pricing_tier_id': 3
    }

    result = product_pricing_override.create_product_pricing_override(4, data)

    assert result.status == 400


def test_create_product_pricing_override_wrong_pricing_family(db_fixture):
    """Test that a wrong product pricing override is validated."""
    data = {
        'product_id': 4,
        'product_pricing_override_id': 5,
        'applies_worldwide': True,
        'store_id': 1,
        'pricing_family_id': 2,
        'orchard_pricing_tier_id': 3
    }

    result = product_pricing_override.create_product_pricing_override(4, data)

    assert result.status == 400


def test_create_product_pricing_override_empty_body(db_fixture):
    """Test that a product pricing override requires fields to be created."""
    data = {}

    result = product_pricing_override.create_product_pricing_override(1, data)

    assert result.status == 400


def test_update_product_pricing_override(db_fixture):
    """Test that a product pricing override can be updated."""
    data = {
        'product_pricing_override_id': 2,
        'product_id': 2,
        'resolution': '4K'
    }

    result = product_pricing_override.update_product_pricing_override(
        2, 2, data)

    updated_product_pricing_override = result.message

    assert updated_product_pricing_override['resolution'] == '4K'


def test_update_product_pricing_override_empty_body(db_fixture):
    """Test that product pricing override cannot be updated with no data."""
    data = {}

    result = product_pricing_override.update_product_pricing_override(
        2, 2, data)

    assert result.status == 400


def test_update_product_pricing_override_not_found_response(db_fixture):
    """Test that product pricing override cannot be updated if not exists."""
    data = {
        'product_pricing_override_id': 2,
        'product_id': 2,
        'resolution': '4K'
    }

    result = product_pricing_override.update_product_pricing_override(
        2, 9, data)

    assert result.status == 404


def test_find_duplicate_true(db_fixture):
    """Test finding an existing duplicate track pricing override."""
    product_id = 1
    data = {
        'applies_worldwide': True,
        'store_id': 1,
        'orchard_pricing_tier_id': 3
    }

    result = product_pricing_override.find_duplicate(
        product_id, data)

    assert result
    assert result.message['found']
    assert result.message['item']['product_id'] == 1


def test_find_duplicate_false(db_fixture):
    """Test finding a non-exisiting duplicate product pricing override."""
    product_id = 3
    data = {
        'applies_worldwide': True,
        'store_id': 1,
        'orchard_pricing_tier_id': 3
    }

    result = product_pricing_override.find_duplicate(
        product_id, data)

    assert result
    assert not result.message['found']


def test_find_duplicate_empty_body(db_fixture):
    """Test that a data dict is required to find a duplicate."""
    product_id = 1
    data = {}

    result = product_pricing_override.find_duplicate(
        product_id, data)

    assert result.status == 400


def test_delete_by_product_id(db_fixture):
    """Test that can remove a test_product."""
    product_id = 6
    data = {
        'product_pricing_override_id': 5,
        'product_id': product_id,
        'resolution': 'HD',
        'applies_worldwide': True,
        'pricing_family_id': 1,
        'orchard_pricing_tier_id': 3}

    created_product_pricing_override = product_pricing_override\
        .create_product_pricing_override(product_id, data)

    assert created_product_pricing_override.message
    assert created_product_pricing_override.status == 200

    result = product_pricing_override.delete_by_product_id(product_id)

    assert result.status == 200
    assert result.message['deleted'] == 1