"""Unit tests for track_pricing_override model."""

from pricing.models import track_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_track_pricing_override_id(db_fixture):
    """Test that track pricing override can be returned."""
    result = track_pricing_override.get_by_track_pricing_override_id(1)

    assert result

    retrieved = result.message

    assert retrieved['track_pricing_override_id'] == 1
    assert retrieved['track_id'] == 1


def test_get_by_track_pricing_id_not_found(db_fixture):
    """Test that a 404 response is returned if no result is found."""
    result = track_pricing_override.get_by_track_pricing_override_id(100)

    assert result.status == 404


def test_get_by_track_id(db_fixture):
    """Test that the track pricing overrides can be returned."""
    result = track_pricing_override.get_by_track_id(1)
    assert result
    assert len(result.message['items']) == 2
    assert len(result.message['items'][0]['territories']) == 2
    assert len(result.message['items'][0]['stores']) == 2
    assert len(result.message['items'][1]['territories']) == 0
    assert len(result.message['items'][1]['stores']) == 0


def test_get_by_track_id_not_found(db_fixture):
    """Test no result is found."""
    result = track_pricing_override.get_by_track_id(100)

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


def test_create_track_pricing_override(db_fixture):
    """Test that creates a track pricing override."""
    data = {
        'track_id': 4,
        'track_pricing_override_id': 5,
        'applies_worldwide': True,
        'orchard_pricing_tier_id': 2
    }

    result = track_pricing_override.create_track_pricing_override(4, data)

    created_track_pricing_override = result.message

    assert created_track_pricing_override['track_id'] == 4
    assert created_track_pricing_override['track_pricing_override_id'] == 5
    assert created_track_pricing_override['applies_worldwide'] is True
    assert created_track_pricing_override['orchard_pricing_tier_id'] == 2


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

    result = track_pricing_override.create_track_pricing_override(1, data)

    assert result.status == 400


def test_update_track_pricing_override(db_fixture):
    """Test that an track pricing override can be updated."""
    data = {
        'track_pricing_override_id': 2,
        'track_id': 2,
        'orchard_pricing_tier_id': 3
    }

    result = track_pricing_override.update_track_pricing_override(
        2, 2, data)

    updated_track_pricing_override = result.message

    assert updated_track_pricing_override['orchard_pricing_tier_id'] == 3


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

    result = track_pricing_override.update_track_pricing_override(
        2, 2, data)

    assert result.status == 400


def test_update_track_pricing_override_not_found_response(db_fixture):
    """Test that update returns error if not found."""
    data = {
        'track_pricing_override_id': 2,
        'track_id': 2,
        'orchard_pricing_tier_id': 1
    }

    result = track_pricing_override.update_track_pricing_override(
        2, 9, data)

    assert result.status == 404


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

    result = track_pricing_override.find_duplicate(
        track_id, data)

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


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

    result = track_pricing_override.find_duplicate(
        track_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."""
    track_id = 1
    data = {}

    result = track_pricing_override.find_duplicate(
        track_id, data)

    assert result.status == 400


def test_delete_by_track_id(db_fixture):
    """Test that the overrides for a track can be deleted."""
    track_id = 10
    data = {
        'track_pricing_override_id': 10,
        'track_id': track_id,
        'applies_worldwide': True,
        'orchard_pricing_tier_id': 3
    }

    created_track_pricing_override = track_pricing_override\
        .create_track_pricing_override(track_id, data)

    assert created_track_pricing_override.message
    assert created_track_pricing_override.status == 200

    result = track_pricing_override.delete_by_track_id(track_id)

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