"""Functional tests for updating a track  (partial).

Test endpoint:
    PATCH /track/<tuid>
"""

from copy import deepcopy
import json

from oto import status as response_code
import pytest

from backend.constants import track_field as tf
from tests.testutils import constants as test_consts
from tests.testutils import db
from tests.testutils import mocks
import tests.testutils.functions as test_funcs


@db.test_schema_no_seed
def test_patch_track(
        client_patch_track, mocker, track_factory):
    """Test PATCH track is successful."""
    track = track_factory()
    db.merge_model_objects([track])

    # Create test data
    track_patch_request_data = {
        tf.VERSION: 'Meow Mix',
        tf.EXPLICIT: 'Y',
        tf.UPC: 1221321344459
    }
    track_patch_response_data = deepcopy(track_patch_request_data)
    track_patch_response_data[tf.TUID] = track.tuid
    mocks.ows_product_get_track_localizations(mocker)
    mocks.ows_product_get_localization_languages(mocker)
    mocks.ows_product_digital_get_chinese_product_by_id(mocker)
    res = client_patch_track(track.tuid, track_patch_request_data)
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.OK
    assert res_body == track_patch_response_data


@db.test_schema_no_seed
def test_patch_track_no_data(
        client_patch_track, mocker, track_factory):
    """Test PATCH track fails when no data specified."""
    track = track_factory()
    db.merge_model_objects([track])

    res = client_patch_track(track.tuid, {})
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.BAD_REQUEST
    assert res_body['code'] == 'bad_request'


@db.test_schema_no_seed
def test_patch_track_with_artists_and_writers(
        client_patch_track, mocker, track_factory):
    """Test PATCH track updates artists and writers data."""
    track = track_factory()
    db.merge_model_objects([track])

    update_request = {
        'artists': [
            {'type': 'performer', 'name': 'Performer 1'}],
        'writers': [{'type': 'writer', 'name': 'Writer 1'}]
    }

    mocks.ows_product_get_track_localizations(mocker)
    mocks.ows_product_get_localization_languages(mocker)
    mocks.ows_product_digital_get_chinese_product_by_id(mocker)

    res = client_patch_track(track.tuid, deepcopy(update_request))
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.OK
    test_funcs.validate_artists_are_same(
        res_body[tf.ARTISTS], update_request['artists'])

    assert tf.WRITERS in res_body
    writers = res_body[tf.WRITERS]
    assert len(writers) == 1
    assert writers[0]['name'] == 'Writer 1'


@db.test_schema
@pytest.mark.parametrize('track_name', test_consts.TEST_INVALID_TRACK_NAMES)
def test_patch_track_invalid_name(
        client_patch_track, track_update_tuid, track_name):
    """Test patch track fails with invalid track name."""
    res = client_patch_track(
        track_update_tuid, data={'track_name': track_name})
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.BAD_REQUEST
    assert 'track_name' in res_body['message']


@pytest.mark.parametrize('p_info', test_consts.TEST_INVALID_P_INFOS_LIST)
def test_patch_track_invalid_p_info(
        client_patch_track, track_update_tuid, p_info):
    """Test PATCH track fails with invalid p_info."""
    res = client_patch_track(track_update_tuid, data={'p_info': p_info})
    res_body = json.loads(res.data.decode())

    assert res.status_code == response_code.BAD_REQUEST
    assert 'p_info' in res_body['message']


def test_patch_track_wth_invalid_writer_role_type(
        client_patch_track, track_factory):
    """Test PATCH track fails if invalid writer type is specified."""
    track = track_factory()

    update_data = {
        'writers': [{'type': 'not_a_writer', 'name': 'Writer 1'}]
    }
    update_request = test_funcs.create_track_update_request(
        track.to_dict(), update_data)

    res = client_patch_track(track.tuid, update_request)
    assert res.status_code == response_code.BAD_REQUEST


@db.test_schema_no_seed
@pytest.mark.parametrize(
    (
        'data',
        'expected_status_code',
    ),
    test_consts.TEST_FOCUS_TRACK_VALID
)
def test_patch_track_focus_track_valid(
    data,
    expected_status_code,
    client_patch_track,
    track_factory,
    mocker
):
    """Test PATCH track with focus track data."""
    track = track_factory()
    db.merge_model_objects([track])

    track_patch_response_data = deepcopy(data)
    if data['focus_track'] == 'N':
        track_patch_response_data['focus_track_start_date'] = None
        track_patch_response_data['focus_track_end_date'] = None
    track_patch_response_data[tf.TUID] = track.tuid
    mocks.ows_product_get_track_localizations(mocker)
    mocks.ows_product_get_localization_languages(mocker)
    mocks.ows_product_digital_get_chinese_product_by_id(mocker)
    res = client_patch_track(track.tuid, data)
    res_body = json.loads(res.data.decode())

    assert res.status_code == expected_status_code
    assert res_body == track_patch_response_data


@db.test_schema_no_seed
@pytest.mark.parametrize(
    (
        'data',
        'expected_status_code',
        'expected_error'
    ),
    test_consts.TEST_FOCUS_TRACK_INVALID
)
def test_patch_track_focus_track_invalid(
    data,
    expected_status_code,
    expected_error,
    client_patch_track,
    track_factory,
    mocker
):
    """Test PATCH track with invalid focus track data."""
    track = track_factory()
    db.merge_model_objects([track])

    track_patch_response_data = deepcopy(data)
    track_patch_response_data[tf.TUID] = track.tuid
    mocks.ows_product_get_track_localizations(mocker)
    mocks.ows_product_get_localization_languages(mocker)
    mocks.ows_product_digital_get_chinese_product_by_id(mocker)
    res = client_patch_track(track.tuid, data)
    res_body = json.loads(res.data.decode())

    assert res.status_code == expected_status_code
    assert expected_error in res_body['message']['_schema']