"""Functional tests for deleting a track role.

Test endpoint:
    DELETE /track/<tuid>/<role>/<track_role_id>
"""
import json

from oto import status as response_code

from backend.constants import error
from backend.constants import track_field as tf
from backend.models.track_persister import TrackPersister
from tests.testutils import db
from tests.testutils import mocks


def _delete_role(client, headers, tuid, subrole, track_role_id):
    """Make POST request to delete role."""
    endpoint = 'track/{}/{}/{}'.format(tuid, subrole, track_role_id)
    return client.delete(endpoint, headers=headers)


@db.test_schema
def test_delete_track_artist_role(
        client, mocker, client_headers, test_track,
        validate_role_deleted):
    """Test delete track artist role is successful."""
    tuid = test_track[tf.TUID]
    track_response = TrackPersister.get_by_tuid(tuid)
    track_artist = track_response.message['artists'][0]
    role = track_artist['type']
    track_role_id = track_artist['track_artist_id']

    mocks.head_response(mocker)

    res = _delete_role(client, client_headers, tuid, role, track_role_id)
    assert res.status_code == response_code.OK

    validate_role_deleted(
        client_headers, tuid, 'artist', track_role_id)


@db.test_schema
def test_delete_track_artist_role_without_grass_headers(
        client, mocker, valid_headers, test_track,
        validate_role_deleted):
    """Test delete track artist role is successful without grass headers."""
    tuid = test_track[tf.TUID]
    track_response = TrackPersister.get_by_tuid(tuid)
    track_artist = track_response.message['artists'][0]
    role = track_artist['type']
    track_role_id = track_artist['track_artist_id']

    mocks.head_response(mocker)

    res = _delete_role(client, valid_headers, tuid, role, track_role_id)
    assert res.status_code == response_code.OK

    validate_role_deleted(
        valid_headers, tuid, 'artist', track_role_id)


@db.test_schema
def test_delete_track_artist_role_with_invalid_grass_headers(
        client, mocker, invalid_grass_headers, test_track):
    """Test delete track artist role with invalid grass headers."""
    tuid = test_track[tf.TUID]
    track_response = TrackPersister.get_by_tuid(tuid)
    track_artist = track_response.message['artists'][0]
    role = track_artist['type']
    track_role_id = track_artist['track_artist_id']

    mocks.head_response(mocker)

    res = _delete_role(
        client, invalid_grass_headers, tuid, role, track_role_id)
    assert res.status_code == response_code.BAD_REQUEST


@db.test_schema
def test_delete_track_writer_role(
        client, mocker, client_headers, test_track,
        validate_role_deleted):
    """Test delete track writer role is successful."""
    tuid = test_track[tf.TUID]
    track_response = TrackPersister.get_by_tuid(tuid)
    track_writer = track_response.message['writers'][0]
    track_role_id = track_writer['track_writer_id']

    mocks.head_response(mocker)

    res = _delete_role(client, client_headers, tuid, 'writer', track_role_id)
    assert res.status_code == response_code.OK

    validate_role_deleted(
        client_headers, tuid, 'writer', track_role_id)


@db.test_schema
def test_delete_track_writer_role_without_grass_headers(
        client, mocker, valid_headers, test_track,
        validate_role_deleted):
    """Test delete track writer role is successful without grass headers."""
    tuid = test_track[tf.TUID]
    track_response = TrackPersister.get_by_tuid(tuid)
    track_writer = track_response.message['writers'][0]
    track_role_id = track_writer['track_writer_id']

    mocks.head_response(mocker)

    res = _delete_role(client, valid_headers, tuid, 'writer', track_role_id)
    assert res.status_code == response_code.OK

    validate_role_deleted(
        valid_headers, tuid, 'writer', track_role_id)


@db.test_schema
def test_delete_track_writer_role_with_invalid_grass_headers(
        client, mocker, invalid_grass_headers, test_track):
    """Test delete track writer role fails with invalid grass headers."""
    tuid = test_track[tf.TUID]
    track_response = TrackPersister.get_by_tuid(tuid)
    track_writer = track_response.message['writers'][0]
    track_role_id = track_writer['track_writer_id']

    mocks.head_response(mocker)

    res = _delete_role(
        client, invalid_grass_headers, tuid, 'writer', track_role_id)
    assert res.status_code == response_code.BAD_REQUEST


@db.test_schema
def test_delete_track_invalid_role(
        mocker, client, client_headers, test_track):
    """Test delete track role with invalid role returns error response."""
    tuid = test_track[tf.TUID]
    mocks.head_response(mocker)

    res = _delete_role(
        client, client_headers, tuid,
        subrole='publisher', track_role_id=1)

    res_body = json.loads(res.data.decode())
    assert res.status_code == response_code.BAD_REQUEST
    assert res_body['code'] == error.INVALID_ROLE_ERROR_CODE