"""End to End Tests for the music migration."""
import json
import os
from ast import literal_eval
from unittest.mock import MagicMock

from oto import response

from pricing.logic import legacy_product_mapping
from pricing.logic import territories_helper

import pytest

from tests.utils import db_legacy_operations
from tests.utils import db_operations
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()


@pytest.mark.parametrize('test_file_name', [
    ('music_migration_default'),
    ('music_migration_itunes_us'),
    ('music_migration_itunes_us_ca'),
    ('music_migration_itunes_amazon_identical'),
    ('music_migration_itunes_amazon_different'),
    ('music_migration_itunes_amazon_custom'),
    ('music_migration_itunes_us_track_different'),
    ('music_migration_itunes_amazon_track_custom'),
    ('music_migration_itunes_missing_territories'),
    ('music_migration_itunes_track_missing_territories'),
    ('music_migration_itunes_jp'),
    ('music_migration_itunes_us_post_golive'),
    ('music_migration_itunes_us_track_different_post_golive'),
    ('music_migration_default_post_golive')])
def test_music_migration_preview(
        monkeypatch, create_legacy_db, create_new_db, test_file_name):
    """Test music migration preview route."""
    with open(os.path.dirname(
            os.path.realpath(__file__))
        + '/data/music_migration/'
        + 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')

    all_territories = DEFAULT_ALL_TERRITORIES
    if 'all_territories' in test_data:
        all_territories = test_data['all_territories']

    monkeypatch.setattr(territories_helper,
                        'convert_territories_to_positive_orchard', MagicMock(
                            side_effect=lambda value: value['territories']))
    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(legacy_product_mapping,
                        'get_jp_orchard_pricing_tier_id',
                        MagicMock(return_value=27))

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

    result = legacy_product_mapping.preview_music_migration(
        test_data['product_id'])

    actual_product = result.message['product_migration_plan']
    actual_tracks = result.message['track_migration_plans']
    expected_product = test_data['expected_output']['product_migration_plan']
    expected_tracks = test_data['expected_output']['track_migration_plans']
    print('ACTUAL PRODUCT', actual_product)
    print('EXPECTED PRODUCT', expected_product)
    print('ACTUAL TRACKS', actual_tracks)
    print('EXPECTED TRACKS', expected_tracks)
    assert result
    assert actual_product['orchard_pricing_tier_id'] == \
        expected_product['orchard_pricing_tier_id']

    if 'product_pricing_overrides_to_create' in actual_product:
        assert actual_product['product_pricing_overrides_to_create'] == \
            expected_product['product_pricing_overrides_to_create']

    for track_id, actual_track in actual_tracks.items():
        expected_track = expected_tracks[str(track_id)]

        if track_id == 'All':
            assert actual_track['orchard_pricing_tier_id'] == \
                expected_track['orchard_pricing_tier_id']
            if 'product_pricing_overrides_to_create' in actual_track:
                assert actual_track['product_pricing_overrides_to_create'] == \
                    expected_track['product_pricing_overrides_to_create']
        else:
            assert actual_track['orchard_pricing_tier_id'] == \
                expected_track['orchard_pricing_tier_id']
            assert actual_track['track_pricing_overrides_to_create'] == \
                expected_track['track_pricing_overrides_to_create']


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_releases' in seed_input:
        for release in seed_input['legacy_releases']:
            db_legacy_operations.seed_release(release)


def fake_new_data(monkeypatch, seed_input):
    """Use monkeypatch to set up the data for the new pricing db."""
    if 'store_pricing_schemes' in seed_input:
        def store_pricing_schemes_side_effect(pricing_family_id, store_id):
            data = get_store_pricing_scheme_data(
                seed_input['store_pricing_schemes'],
                pricing_family_id,
                store_id)
            return data

        monkeypatch.setattr(
            legacy_product_mapping,
            'get_store_pricing_scheme',
            MagicMock(side_effect=store_pricing_schemes_side_effect))

    if 'default_orchard_pricing_tiers' in seed_input:
        def default_orchard_pricing_tiers_side_effect(pricing_family_id):
            data = get_default_orchard_pricing_tier_data(
                seed_input['default_orchard_pricing_tiers'],
                pricing_family_id)
            return response.Response(data)

        monkeypatch.setattr(
            legacy_product_mapping,
            'get_default_orchard_pricing_tier',
            MagicMock(side_effect=default_orchard_pricing_tiers_side_effect))


def get_store_pricing_scheme_data(
        store_pricing_schemes, pricing_family_id, store_id):
    """Get the scheme based on the pricing family and the store."""
    for spc in store_pricing_schemes:
        if spc['pricing_family_id'] == pricing_family_id and \
                spc['store_id'] == store_id:
            return spc['data']
    return None


def get_default_orchard_pricing_tier_data(
        default_orchard_pricing_tiers, pricing_family_id):
    """Get the orchard pricing tier based on the pricing family."""
    for dopt in default_orchard_pricing_tiers:
        if dopt['pricing_family_id'] == pricing_family_id:
            return dopt['data']
    return None