"""Functional tests for deleting a track.

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

import json

from oto import response
from oto import status as response_code

from backend.connectors import mysql
from backend.models import ows_lyrics
from backend.models import ows_video
from backend.models.language import Language
from backend.models.performer_persister import PerformerPersister
from backend.utils import api as api_utils
from tests.testutils import db
from tests.testutils import mocks


@db.test_schema_no_seed
def test_delete_track(
        client, mocker, track_factory, performer_factory,
        track_localization_factory):
    """Test DELETE track is successful."""
    track = track_factory.create(
        writers__count=1, performer__count=1, ownership_rights=None)
    performer = performer_factory(tuid=track.tuid, performer_type='primary')
    db.merge_model_objects([track])
    db.merge_ows_track_model_objects([performer])

    localizations = track_localization_factory(track, [1])
    mocks.ows_product_get_track_localizations(mocker, localizations)
    mocks.ows_product_verify_product_ownership(mocker)
    mocker.patch(
        'backend.logic.track.ows_product.delete_track_localizations',
        return_value=api_utils.create_ok_response())
    mocker.patch.object(
        ows_lyrics, 'delete_track_lyrics', return_value=response.Response())
    mocker.patch.object(
        ows_video, 'disassociate_tracks', return_value=response.Response())
    mock_assets = mocker.patch(
        'backend.logic.track.ows_assets.bulk_delete_track_assets')

    delete_response = client.delete('/track/{}'.format(track.tuid))
    get_track_response = client.get('/track/{}'.format(track.tuid))

    assert delete_response.status_code == response_code.OK
    assert get_track_response.status_code == response_code.NOT_FOUND
    mock_assets.assert_called_with([track.tuid])
    # FIXME replace with check via api call when endpoint is ready
    expected_performers_response = api_utils.create_get_list_response([])
    performers_response = PerformerPersister.get_performers_by_tuids(
        [track.tuid])
    assert performers_response.message == expected_performers_response.message


@db.test_schema_no_seed
def test_delete_track_does_not_delete_language_table_data(
        client, mocker, track_factory, performer_factory,
        track_localization_factory):
    """Test DELETE track does not delete language table data."""
    track = track_factory.create(
        writers__count=1, performer__count=1, ownership_rights=None)
    performer = performer_factory(tuid=track.tuid, performer_type='primary')
    db.merge_model_objects([track])
    db.merge_ows_track_model_objects([performer])

    localizations = track_localization_factory(track, [1])
    mocks.ows_product_get_track_localizations(mocker, localizations)
    mocks.ows_product_verify_product_ownership(mocker)
    mocker.patch(
        'backend.logic.track.ows_product.delete_track_localizations',
        return_value=api_utils.create_ok_response())
    mocker.patch.object(
        ows_lyrics, 'delete_track_lyrics', return_value=response.Response())
    mocker.patch.object(
        ows_video, 'disassociate_tracks', return_value=response.Response())
    mock_assets = mocker.patch(
        'backend.logic.track.ows_assets.bulk_delete_track_assets')

    delete_response = client.delete('/track/{}'.format(track.tuid))

    assert delete_response.status_code == response_code.OK
    mock_assets.assert_called_with([track.tuid])
    with mysql.db_session() as session:
        result = session.query(Language).get('ENG').to_dict()
        fixture_data = session.query(Language).count()
    assert result['language_code'] == 'ENG'
    assert fixture_data


def test_delete_track_invalid_id_type(client):
    """Test delete invalid track with id of type string."""
    res = client.delete('/track/abc')
    assert res.status_code == response_code.NOT_FOUND


@db.test_schema
def test_delete_last_track_from_product(
        client, mocker, test_single_track_product_id,
        client_get_product_tracks, track_localization_put_data):
    """Test last track in product can be deleted."""
    mocker.patch(
        'backend.logic.track.ows_assets.bulk_delete_track_assets')
    mocks.ows_product_get_track_localizations(
        mocker, track_localization_put_data)
    mocks.ows_product_verify_product_ownership(mocker)
    delete_localizations_response = response.Response(status=response_code.OK)
    mocker.patch.object(
        ows_lyrics, 'delete_track_lyrics', return_value=response.Response())
    mocker.patch.object(
        ows_video, 'disassociate_tracks', return_value=response.Response())
    mocker.patch(
        'backend.logic.track.ows_product.delete_track_localizations',
        return_value=delete_localizations_response)
    get_tracks_response = client_get_product_tracks(
        test_single_track_product_id)
    assert get_tracks_response.status_code == response_code.OK
    tracks = json.loads(get_tracks_response.data.decode())['items']
    assert len(tracks) == 1
    tuid = tracks[0]['tuid']
    res = client.delete('/track/{}'.format(tuid))
    assert res.status_code == response_code.OK
    res = client.get('/track/{}'.format(tuid))
    assert res.status_code == response_code.NOT_FOUND