"""Functional tests for GET /conflicts/new endpoint."""
import json

from oto import status as response_code
import pytest

from conflict_manager.constants import feature_flag
from conflict_manager.constants import query_parameters as query_consts
from conflict_manager.utils import filter_utils
from tests import mocks


@pytest.fixture
def yt_new_conflict_data(yt_conflict_data):
    """Fixture data for youtube conflicts."""
    for conflict in yt_conflict_data:
        conflict['status'] = 'NEW'

    return yt_conflict_data


@pytest.fixture
def es_new_conflict_data(yt_new_conflict_data):
    """Fixture data for conflicts in ElasticSearch."""
    for index, conflict in enumerate(yt_new_conflict_data):
        conflict['es_id'] = 'test_es_id_' + str(index)

    return yt_new_conflict_data


@pytest.fixture
def yt_new_conflict_count_data():
    """Fixture data for youtube conflicts count."""
    return {
        'pagination': {
            'type': 'standard',
            'offset': 0,
            'limit': 0,
            'total_records': 52
        },
        'items': []
    }


def test_get_new_conflicts_success(
        client, mocker, headers, test_vendor_id, test_values, test_values2,
        yt_new_conflict_data, territories_data, feature_engine):
    """Test get new conflicts is successful and territory info is filled."""
    feature_engine.force_flag(
        feature_flag.CONFLICT_MGR_VIEWS_IN_CONFLICT_DATA, True)
    mocks.fact_conflict.get_new_youtube_conflicts_for_account(
        mocker, yt_new_conflict_data)
    mocks.ows_territories.get_territories_map(mocker, territories_data)

    res = client.get('/conflicts/new', headers=headers)
    payload = json.loads(res.data.decode())

    assert res.status_code == response_code.OK

    assert payload == {
        'items': [
            {
                'tuid': test_values['tuid'],
                'track_name': 'Track name',
                'version': '',
                'track_artists': ['Flurry', 'Snowball'],
                'product_name': 'Snowball on Ice',
                'product_id': test_values['product_id'],
                'display_upc': test_values['display_upc'],
                'conflict_date': '2017-01-01',
                'conflicting_owner': 'owner',
                'status': 'NEW',
                'isrc': 'QM4TW1500001',
                'territory_standard': 'ISO_3166_2106',
                'es_id': '8ed039283817fb00f9d271d136959da1'
                         '18f403c0647ee33768aeacf84089ba7e',
                'territories': [
                    {
                        'conflict_id': 31,
                        'code': 'US',
                        'continent_name': 'North America',
                        'name': 'United States of America'
                    },
                    {
                        'conflict_id': 32,
                        'code': 'FR',
                        'continent_name': 'Europe',
                        'name': 'France'
                    }
                ],
                'vendor_id': test_vendor_id,
                'subaccount_id': None,
                'daily_average_views': 2
            },
            {
                'tuid': test_values2['tuid'],
                'track_name': 'Other',
                'version': 'Remix',
                'track_artists': ['Icicle', 'Snowball'],
                'product_name': 'Snowflakes are falling',
                'product_id': test_values2['product_id'],
                'display_upc': test_values2['display_upc'],
                'conflict_date': '2017-01-02',
                'conflicting_owner': 'owner',
                'status': 'NEW',
                'isrc': 'US6TA1600031',
                'territory_standard': 'ISO_3166_2106',
                'es_id': 'c6f3ac57944a531490cd39902d0f7777'
                         '15fd005efac9a30622d5f5205e7f6894',
                'territories': [
                    {
                        'conflict_id': 33,
                        'code': 'US',
                        'continent_name': 'North America',
                        'name': 'United States of America'
                    }
                ],
                'vendor_id': test_vendor_id,
                'subaccount_id': None,
                'daily_average_views': 5
            }
        ],
        'pagination': {
            'type': 'standard',
            'offset': 0,
            'limit': 50,
            'total_records': 2
        }
    }


def test_get_new_conflicts_success_pagination(
        client, mocker, headers, yt_new_conflict_data, territories_data,
        feature_engine):
    """Test pagination data is properly copied from model response."""
    mocks.fact_conflict.get_new_youtube_conflicts_for_account(
        mocker, yt_new_conflict_data, total_records=20, offset=18, limit=2)
    mocks.ows_territories.get_territories_map(mocker, territories_data)

    res = client.get('/conflicts/new', headers=headers)
    payload = json.loads(res.data.decode())

    assert payload['pagination']['total_records'] == 20
    assert payload['pagination']['offset'] == 18
    assert payload['pagination']['limit'] == 2


def test_get_new_conflicts_filter_params_success(
        client, mocker, headers, account_tuple, feature_engine,
        es_new_conflict_data, territories_data):
    """Test pagination data is properly copied from model response."""
    mock_call = \
        mocks.fact_conflict_elasticsearch.get_new_conflicts_for_account(
            mocker, es_new_conflict_data)

    mocks.ows_territories.get_territories_map(mocker, territories_data)

    url_params = '?query=remix&fields=track_name'

    res = client.get(
        '/conflicts/new{}'.format(url_params), headers=headers)
    payload = json.loads(res.data.decode())

    mock_call.assert_called_with(
        account_tuple, fields=['track_name'], limit=50, offset=0,
        query='remix', sort_by='daily_average_views', sort_order='asc')

    assert payload['items'][0]['es_id'] == 'test_es_id_0'


def test_get_new_conflicts_filter_success_blank(
        client, mocker, es_new_conflict_data, headers, account_tuple,
        feature_engine, territories_data, yt_new_conflict_data,
        yt_conflict_data):
    """Test pagination data is properly copied from model response."""
    mocks.fact_conflict.get_new_youtube_conflicts_for_account(
        mocker, yt_new_conflict_data, total_records=20, offset=18, limit=2)

    mocks.ows_territories.get_territories_map(mocker, territories_data)

    res = client.get('/conflicts/new', headers=headers)
    payload = json.loads(res.data.decode())

    for i, conflict in enumerate(yt_conflict_data):
        assert payload['items'][i]['es_id'] == conflict['es_id']

    assert payload['pagination']['total_records'] == 20
    assert payload['pagination']['offset'] == 18
    assert payload['pagination']['limit'] == 2


def test_marshmallow_execute(
        client, mocker, headers, feature_engine, territories_data):
    """Test the ElasticSearch Search object is created properly."""
    mock_call = mocker.patch.object(filter_utils, 'get_filter_options')

    mocks.ows_territories.get_territories_map(mocker, territories_data)

    client.get(
        '/conflicts/new?query=remix&fields=track_name', headers=headers)

    mock_call.assert_called_with(
        filter_fields=query_consts.ANY_CONFLICT_FILTERABLE_COLUMNS,
        query='remix',
        fields=['track_name'])


def test_get_new_conflicts_count(
        client, mocker, yt_new_conflict_count_data, headers, account_tuple,
        feature_engine):
    """Test pagination data returns only total_records when limit is zero."""
    mocks.fact_conflict_elasticsearch.get_new_conflicts_count_for_account(
        mocker, yt_new_conflict_count_data)

    res = client.get('/conflicts/new?page_limit=0', headers=headers)
    payload = json.loads(res.data.decode())

    assert payload['pagination']['total_records'] == 52
    assert payload['items'] == []