"""End to End Tests for Product Store Pricing."""

import datetime
import json
import os
from ast import literal_eval
from unittest.mock import MagicMock

from oto import response

from pricing.logic import product_store_pricing
from pricing.logic import territories_helper
from pricing.models import orchard_pricing_tier
from pricing.models import product_orchard_pricing_tier
from pricing.models import product_pricing_override
from pricing.models import store_pricing_scheme
from pricing.models import track_pricing_override

import pytest

from tests.utils import db_legacy_operations
from tests.utils import db_operations
from tests.utils import territory_pricing_helper
from tests.utils.constants import DEFAULT_ALL_TERRITORIES


@pytest.fixture
def create_legacy_db():
    """Drop and re-create all the legacy SQLite tables."""
    db_legacy_operations.create_legacy_tables()


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


def monkey(monkeypatch, obj, test_data):
    """Use monkeypatch to stub out method on obj with test_data."""
    monkeypatch.setattr(
        obj,
        test_data['model_function'],
        MagicMock(return_value=response.Response(test_data['data'])))


@pytest.mark.parametrize('test_file_name', [
    ('audio_album_not_migrated'),
    ('audio_album_not_migrated_russia_itunes_same'),
    ('audio_album_not_migrated_russia_itunes_different'),
    ('audio_album_not_migrated_russia_canada_different'),
    ('film_migrated'),
    ('film_default_tier'),
    ('film_migrated_with_worldwide_override'),
    ('film_migrated_with_worldwide_SD_override'),
    ('film_migrated_with_positive_territory_SD_override'),
    ('film_migrated_with_negative_territory_SD_override'),
    ('non_interval_film'),
    ('audio_album_not_migrated_product_override_custom')])
def test_get_product_store_pricing(
        monkeypatch, create_legacy_db, create_new_db, test_file_name):
    """Test getting VECTOR route."""
    with open(os.path.dirname(
            os.path.realpath(__file__))
            + '/data/product_store_pricing/'
            + test_file_name + '.json') \
            as data_file:
        test_data = json.load(data_file)

    if 'legacy_input' in test_data:
        print('SEED LEGACY INPUT')
        seed_legacy_input(test_data['legacy_input'])
        print('DONE SEEDING LEGACY INPUT')

    mock_territories_helper(monkeypatch, test_data)

    if 'new_input' in test_data:
        if 'product_pricing_overrides' in test_data['new_input']:
            overrides = test_data['new_input']['product_pricing_overrides']
            if 'data' in overrides and 'items' in overrides['data']:
                items = overrides['data']['items']
                for item in items:
                    if 'start_date' in item and \
                            item['start_date'] == '{{TODAY}}':
                        item['start_date'] = str(datetime.date.today())

                    if 'end_date' in item and item['end_date'] == '{{TODAY}}':
                        item['end_date'] = str(datetime.date.today())

        fake_new_data(monkeypatch, test_data['new_input'])

    result = product_store_pricing.get_product_store_pricing(
        test_data['pricing_family_id'], test_data['product_id'],
        test_data['store_id'])

    assert result
    territory_pricing_helper.check_pricing_results_match(
        test_data['expected_output']['items'], result.message['items'])


@pytest.mark.parametrize('test_file_name', [
    ('track_audio_album_not_migrated'),
    ('track_audio_album_not_migrated_with_override'),
    ('track_audio_album_not_migrated_with_overlapping_overrides'),
    ('track_audio_album_not_migrated_with_pricing_scheme'),
    ('track_audio_album_not_migrated_default'),
    ('track_audio_album_not_migrated_with_track_override'),
    ('track_audio_album_not_migrated_with_product_and_track_override'),
    ('track_audio_album_not_migrated_track_custom_price'),
    ('track_audio_album_not_migrated_russia_itunes_same'),
    ('track_audio_album_not_migrated_all_track_custom_price'),
    ('track_audio_album_not_migrated_russia_itunes_same_track_different'),
    ('track_audio_album_migrated_ww_mid'),
    ('track_audio_album_migrated_ww_front'),
    ('track_audio_album_migrated_default_ag'),
    ('track_audio_album_migrated_exclude_ag'),
    ('track_audio_album_migrated_with_product_override'),
    ('track_audio_album_migrated_with_track_override'),
    ('track_audio_album_migrated_with_product_and_track_overrides')])
def test_get_track_store_pricing(
        monkeypatch, create_legacy_db, create_new_db, test_file_name):
    """Test getting VECTOR route."""
    with open(os.path.dirname(
            os.path.realpath(__file__))
            + '/data/product_store_pricing/'
            + test_file_name + '.json') \
            as data_file:
        test_data = json.load(data_file)

    if 'legacy_input' in test_data:
        print('SEED LEGACY INPUT')
        seed_legacy_input(test_data['legacy_input'])
        print('DONE SEEDING LEGACY INPUT')

    mock_territories_helper(monkeypatch, test_data)

    if 'new_input' in test_data:
        fake_new_data(monkeypatch, test_data['new_input'])

    result = product_store_pricing.get_product_store_pricing(
        test_data['pricing_family_id'], test_data['product_id'],
        test_data['store_id'])

    assert result
    territory_pricing_helper.check_pricing_results_match(
        test_data['expected_output']['items'], result.message['items'])


def mock_territories_helper(monkeypatch, test_data):
    """Mock territories helper functions."""
    all_territories = DEFAULT_ALL_TERRITORIES
    if 'all_territories' in test_data:
        all_territories = test_data['all_territories']

    def convert_territories_to_positive_orchard_side_effect(item):
        """Side effect to mock convert_territories_to_positive_orchard."""
        if item['applies_worldwide']:
            return all_territories
        elif item['territory_list_include']:
            return item['territories']
        else:
            return list(set(all_territories) - set(item['territories']))

    monkeypatch.setattr(
        territories_helper,
        'convert_territories_to_positive_orchard',
        MagicMock(
            side_effect=convert_territories_to_positive_orchard_side_effect))

    monkeypatch.setattr(
        territories_helper,
        'convert_territories_to_iso',
        MagicMock(side_effect=lambda value: literal_eval(value)))

    monkeypatch.setattr(
        territories_helper,
        'get_all_orchard_territories',
        MagicMock(return_value=all_territories))

    monkeypatch.setattr(
        territories_helper,
        'get_all_iso_territories',
        MagicMock(return_value=all_territories))

    monkeypatch.setattr(
        territories_helper,
        'convert_territories_to_positive_iso',
        MagicMock(
            side_effect=lambda value: list(set(all_territories) - set(value))))


def seed_legacy_input(seed_input):
    """Seed the legacy SQLite tables from the input."""
    if 'legacy_pricing_schemes' in seed_input:
        for scheme in seed_input['legacy_pricing_schemes']:
            db_legacy_operations.seed_dms_master_pricing_scheme(scheme)

    if 'legacy_release' in seed_input:
        db_legacy_operations.seed_release(seed_input['legacy_release'])


def fake_new_data(monkeypatch, seed_input):
    """Use monkeypatch to set up the data for the new pricing db."""
    if 'store_pricing_scheme' in seed_input:
        monkey(monkeypatch, store_pricing_scheme,
               seed_input['store_pricing_scheme'])

    if 'product_orchard_pricing_tier' in seed_input:
        monkey(monkeypatch, product_orchard_pricing_tier,
               seed_input['product_orchard_pricing_tier'])

    if 'product_pricing_overrides' in seed_input:
        monkey(monkeypatch, product_pricing_override,
               seed_input['product_pricing_overrides'])

    if 'track_pricing_overrides' in seed_input:
        monkey(monkeypatch, track_pricing_override,
               seed_input['track_pricing_overrides'])

    if 'orchard_pricing_tier' in seed_input:
        monkey(monkeypatch, orchard_pricing_tier,
               seed_input['orchard_pricing_tier'])