"""Functional tests for retrieving a track.

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

import json

from oto import response
from oto import status as response_code

from backend.constants import error
from backend.constants import header
from backend.constants import track_field
from backend.logic import track as track_logic
from tests.testutils import db
from tests.testutils import functions as test_funcs
from tests.testutils import mocks


@db.test_schema_no_seed
def test_get_track(
        client, mocker, track_factory, track_localization_factory):
    """Test get track is successful."""
    track = track_factory(
        publishers__count=2, performer__count=2, writers__count=1)
    localizations = track_localization_factory(track, [1])

    db.merge_model_objects([track])

    mocks.ows_product_get_track_localizations(
        mocker, localizations)
    res = client.get('track/{}'.format(track.tuid))
    res_body = json.loads(res.data.decode())

    res.status_code == response_code.OK
    track_dict = track.to_dict()
    res_body[track_field.LOCALIZATIONS] == localizations
    for field_name, value in res_body.items():
        if field_name != track_field.LOCALIZATIONS:
            assert value == track_dict[field_name]

    error_msg = test_funcs.validate_track_response(res_body)
    assert not error_msg


@db.test_schema
def test_get_track_localizations_failed(
        client, test_track, mocker, track_localization_failed_response):
    """Test get track localizations failed."""
    mocker.patch(
        'backend.models.ows_product.get_track_localizations',
        return_value=track_localization_failed_response)
    res = client.get('track/{}'.format(test_track[track_field.TUID]))
    res_body = json.loads(res.data.decode())

    ows_product_failed_json = {
        'code': error.OWS_PRODUCT_ERROR_CODE,
        'message': 'Server error'
    }
    assert res_body == ows_product_failed_json
    assert res.status_code == response_code.INTERNAL_ERROR


@db.test_schema
def test_get_track_invalid_id_type(client):
    """Test get invalid track with id of type string."""
    res = client.get('track/abc')
    assert res.status_code == response_code.NOT_FOUND


@db.test_schema_no_seed
def test_get_track_no_localizations(
        client, mocker, track_factory):
    """Test get track is successful."""
    track = track_factory(
        publishers__count=2, performer__count=2, writers__count=1)

    db.merge_model_objects([track])

    get_localization_mock = mocker.patch(
        'backend.models.ows_product.get_track_localizations')

    res = client.get('track/{}?exclude=localizations'.format(track.tuid))
    res_body = json.loads(res.data.decode())

    get_localization_mock.assert_not_called()
    assert res.status_code == response_code.OK
    track_dict = track.to_dict()
    assert res_body[track_field.LOCALIZATIONS] == []

    for field_name, value in res_body.items():
        if field_name != track_field.LOCALIZATIONS:
            assert value == track_dict[field_name]

    error_msg = test_funcs.validate_track_response(res_body)
    assert not error_msg


def test_get_track_with_headers(client, mocker, client_headers):
    """Get track with grass header data."""
    expected = response.Response(message={'foo': 'bar'}, status=200)
    mock_logic = mocker.patch.object(
        track_logic, 'get_by_tuid', return_value=expected)
    tuid = 27825628

    url = 'track/{}?include=track_samples'.format(tuid)
    res = client.get(url, headers=client_headers)
    res_body = json.loads(res.data.decode())
    assert res_body == expected.message
    mock_logic.assert_called_once_with(
        tuid=tuid,
        account_type=client_headers[header.GRASS_ACCOUNT_TYPE],
        account_id=str(client_headers[header.GRASS_ACCOUNT_ID]),
        exclude=[''],
        include=['track_samples'],
    )