"""Functional tests for delete a track lyrics.

Test endpoints:
    DELETE /tracks/<int:track_id>/lyrics
    DELETE /tracks/lyrics
"""

import datetime
import json

from oto import status as http_status
import pytest

from tests.factories import lyrics_factory
from tests.test_utils import db


authorization_header = {'Authorization': 'ows-track/ows-lyrics:randomhmac123'}
blank_authorization_header = {'Authorization': ''}


@db.test_schema
@pytest.mark.parametrize(
    'headers, response_status',
    ((authorization_header, http_status.OK), ({}, http_status.FORBIDDEN),
     (blank_authorization_header, http_status.FORBIDDEN)))
def test_delete_lyrics_success(
        client, authorization_mock, headers, response_status):
    """Check that delete lyrics works."""
    track_id = 42
    lyrics = 'na na na'
    lyrics_obj = lyrics_factory.LyricsFactory(
        entity_id=track_id, description=lyrics)
    db.seed_models([lyrics_obj])
    response = client.delete(
        'tracks/{}/lyrics'.format(track_id), headers=headers)
    assert response.status_code == response_status
    if response_status == 200:
        response = client.get(
            'tracks/{}/lyrics'.format(track_id), headers=headers)
        assert response.status_code == 404


@db.test_schema
@pytest.mark.parametrize(
    'headers, response_status',
    ((authorization_header, http_status.NOT_FOUND),
     ({}, http_status.FORBIDDEN)))
def test_delete_lyrics_failure(
        client, authorization_mock, headers, response_status):
    """Check delete lyrics when data is missing."""
    track_id = 42
    response = client.delete(
        'tracks/{}/lyrics'.format(track_id), headers=headers)
    assert response.status_code == response_status


@pytest.mark.parametrize(
    'headers, response_status, response_message',
    ((authorization_header, http_status.BAD_REQUEST,
      'GRASS requests are forbidden'),
     ({}, http_status.FORBIDDEN, 'user is forbidden')))
def test_delete_lyrics_grass(
        client, grass_headers, authorization_mock,
        headers, response_status, response_message):
    """Check that endpoint is not accessible via GRASS."""
    grass_headers.update(headers)
    response = client.delete(
        'tracks/{}/lyrics'.format(11), headers=grass_headers)
    assert response.status_code == response_status
    data = json.loads(response.data.decode())
    assert data['message'] == response_message


@db.test_schema
@pytest.mark.parametrize(
    'headers, response_status',
    ((authorization_header, http_status.OK),
     ({}, http_status.FORBIDDEN)))
def test_delete_lyrics_multiple_records(
        client, authorization_mock, headers, response_status):
    """Check that delete lyrics works with multiple records."""
    track_id = 42
    lyrics = 'la la la'
    now = datetime.datetime.now()
    db.seed_models([
        lyrics_factory.LyricsFactory(
            entity_id=track_id, description='nanana',
            last_updated=(now - datetime.timedelta(hours=1))),
        lyrics_factory.LyricsFactory(
            entity_id=track_id, description=lyrics, last_updated=now)
    ])
    response = client.delete(
        'tracks/{}/lyrics'.format(track_id), headers=headers)
    assert response.status_code == response_status
    if response.status_code == 200:
        response = client.get(
            'tracks/{}/lyrics'.format(track_id), headers=headers)
        assert response.status_code == 404


@db.test_schema
@pytest.mark.parametrize(
    'headers, response_status',
    ((authorization_header, http_status.OK),
     ({}, http_status.FORBIDDEN)))
def test_delete_tracks_lyrics_success(
        client, client_headers, authorization_mock, headers, response_status):
    """Check that delete lyrics works."""
    lyrics_list = [
        lyrics_factory.LyricsFactory(entity_id=1),
        lyrics_factory.LyricsFactory(entity_id=1),
        lyrics_factory.LyricsFactory(entity_id=2),
        lyrics_factory.LyricsFactory(entity_id=3)]
    db.seed_models(lyrics_list)
    body = {
        'tuids': [1, 2]
    }
    client_headers.update(headers)
    response = client.delete(
        '/tracks/lyrics', headers=client_headers, data=json.dumps(body))
    assert response.status_code == response_status
    if response.status_code == 200:
        response = client.get('tracks/{}/lyrics'.format(1), headers=headers)
        assert response.status_code == 404
        response = client.get('tracks/{}/lyrics'.format(2), headers=headers)
        assert response.status_code == 404
        response = client.get('tracks/{}/lyrics'.format(3), headers=headers)
        assert response.status_code == 200


@db.test_schema
@pytest.mark.parametrize(
    'headers, response_status',
    ((authorization_header, http_status.OK),
     ({}, http_status.FORBIDDEN)))
def test_delete_tracks_lyrics_missed(
        client, client_headers, authorization_mock, headers, response_status):
    """Check that delete lyrics works even data is missed."""
    body = {
        'tuids': [1, 2]
    }
    client_headers.update(headers)
    response = client.delete(
        '/tracks/lyrics', headers=client_headers, data=json.dumps(body))
    assert response.status_code == response_status


@pytest.mark.parametrize(
    'headers, response_status, response_message',
    ((authorization_header, http_status.BAD_REQUEST,
      'GRASS requests are forbidden'),
     ({}, http_status.FORBIDDEN, 'user is forbidden')))
def test_delete_tracks_lyrics_grass(
        client, grass_headers, authorization_mock,
        headers, response_status, response_message):
    """Check that endpoint is not accessible via GRASS."""
    body = {
        'tuids': [1, 2]
    }
    grass_headers.update(headers)
    response = client.delete(
        '/tracks/lyrics', headers=grass_headers, data=json.dumps(body))
    assert response.status_code == response_status
    data = json.loads(response.data.decode())
    assert data['message'] == response_message


@pytest.mark.parametrize(
    'headers, response_status, response_message',
    ((authorization_header, http_status.BAD_REQUEST, 'validation_message'),
     ({}, http_status.FORBIDDEN,
      {'code': 'authorization_error', 'message': 'user is forbidden'})))
def test_delete_tracks_lyrics_validation(
        client, client_headers, authorization_mock,
        headers, response_status, response_message):
    """Check that delete lyrics validation works."""
    body = {
        'tuids': 'str'
    }
    client_headers.update(headers)
    response = client.delete(
        '/tracks/lyrics', headers=client_headers, data=json.dumps(body))
    assert response.status_code == response_status
    data = json.loads(response.data.decode())
    if response_message == 'validation_message':
        assert data['message'] == {'tuids': ['Not a valid list.']}
    else:
        assert data == response_message