"""Tests for track schemas."""

from datetime import date

import pytest

from backend.models import ows_lyrics
from backend.schemas.track import TrackArtistSchema
from backend.schemas.track import TrackDurationSchema
from backend.schemas.track import TrackPostSchema
from backend.schemas.track import TrackUpdateSchema
from backend.schemas.track import TrackWriterSchema


def _make_update_data(**kwargs):
    """Make an update request."""
    data = {
        'track_name': 'x',
        'meta_language_code': '',
        'version': '',
        'p_info': '',
        'explicit': 'N',
        'ownership_rights': None,
        'recording_country_id': None,
        'original_rights_holder_country_id': None,
        'preview_start_time': None
    }
    data.update(kwargs)
    return data


def _make_track_artist_update_data(**kwargs):
    """Data to update track artist."""
    data = {
        'track_artist_id': 1,
        'type': 'performer',
        'name': 'Joe Cool',
        'artist_info_id': None
    }
    data.update(kwargs)
    return data


def _make_track_writer_update_data(**kwargs):
    data = {
        'track_writer_id': 1,
        'type': 'writer',
        'name': 'Shakespeare',
        'artist_info_id': None
    }
    data.update(kwargs)
    return data


VALID_UPDATE_TRACK_ARTIST_PAYLOAD = [
    _make_track_artist_update_data(),
    _make_track_artist_update_data(artist_info_id=12),
    _make_track_artist_update_data(track_artist_id='some-uuid')
]

VALID_UPDATE_TRACK_WRITER_PAYLOAD = [
    _make_track_writer_update_data(),
    _make_track_writer_update_data(artist_info_id=27),
    _make_track_writer_update_data(track_writer_id='some-uuid')
]

VALID_POST_TRACK_REQUESTS = [
    {'product_id': 1, 'track_name': ''},
    {'product_id': 1, 'track_name': 'x'},
    {'product_id': 1, 'track_name': 'x '},
    {'product_id': 1, 'track_name': 'x', 'volume_number': 2}
]

INVALID_POST_TRACK_REQUESTS = [
    {'track_name': 'x'},
    {'product_id': 'a', 'track_name': 'x'},
    {'product_id': 0, 'track_name': 'x'},
    {'product_id': 1},
    {'product_id': 1, 'track_name': 'x', 'volume_number': 0},
    {'product_id': 1, 'track_name': 'x', 'volume_number': 256}
]

VALID_UPDATE_TRACK_REQUESTS = [
    _make_update_data(),
    _make_update_data(track_name=''),
    _make_update_data(track_name='x '),
    _make_update_data(track_name=' ', version=' '),
    _make_update_data(meta_language_code='ENG'),
    _make_update_data(version='blue'),
    _make_update_data(isrc='US-123-17-12345'),
    _make_update_data(isrc='USABC1712345'),
    _make_update_data(isrc=''),
    _make_update_data(p_info='2017 Label'),
    _make_update_data(ownership_rights='original_owner'),
    _make_update_data(ownership_rights='acquired_rights'),
    _make_update_data(ownership_rights='exclusive_licensee'),
    _make_update_data(ownership_rights='non_exclusive_licensee'),
    _make_update_data(ownership_rights='no_rights'),
    _make_update_data(recording_country_id=None),
    _make_update_data(recording_country_id=1),
    _make_update_data(original_rights_holder_country_id=None),
    _make_update_data(original_rights_holder_country_id=1),
    _make_update_data(preview_start_time=None),
    _make_update_data(preview_start_time=0),
    _make_update_data(preview_start_time=1),
    _make_update_data(artists=[]),
    _make_update_data(artists=[{'type': 'performer', 'name': 'Snowball'}]),
    _make_update_data(artists=[
        {'type': 'performer', 'name': 'Snowball'},
        {'type': 'remixer', 'name': 'Pumpkin'}]),
    _make_update_data(writers=[{'name': 'Tubs'}]),
    _make_update_data(writers=[{'name': 'Tubs', 'type': 'writer'}]),
    _make_update_data(writers=[{'name': 'Tubs'}, {'name': 'Guy Furry'}]),
    _make_update_data(track_name='', explicit=''),
    _make_update_data(track_name='x', explicit=''),
    _make_update_data(explicit='C', lyrics='Fucka ducka'),
    _make_update_data(explicit='N', lyrics='Fuck a duck', track_type='video'),
    _make_update_data(focus_track='Y', focus_track_start_date='2022-10-24'),
    _make_update_data(focus_track='Y', focus_track_start_date='2022-10-24',
                      focus_track_end_date='2022-11-24'),
    _make_update_data(focus_track='N'),
]

INVALID_UPDATE_TRACK_REQUESTS = [
    {},
    _make_update_data(meta_language_code='EN'),
    _make_update_data(p_info='201 bad'),
    _make_update_data(p_info='2017'),
    _make_update_data(p_info='label'),
    _make_update_data(isrc='USAB171234-5'),
    _make_update_data(isrc='USAB171234'),
    _make_update_data(explicit='N', lyrics='Fuck a duck'),
    _make_update_data(explicit='C', lyrics='okay fuckers'),
    _make_update_data(ownership_rights='owner'),
    _make_update_data(ownership_rights='invalid_value'),
    _make_update_data(recording_country_id=0),
    _make_update_data(original_rights_holder_country_id=0),
    _make_update_data(preview_start_time=-1),
    _make_update_data(artists=None),
    _make_update_data(artists=[{'name': 'Snowball'}]),
    _make_update_data(artists=[{'type': 'performer'}]),
    _make_update_data(artists=[{'type': '', 'name': 'Snowball'}]),
    _make_update_data(artists=[{'type': 'performer', 'name': ' '}]),
    _make_update_data(artists=[
        {'type': 'performer', 'name': 'Snowball'},
        {'type': 'performer', 'name': 'Snowball'}]),
    _make_update_data(writers=[{'name': ' '}]),
    _make_update_data(writers=[{'name': 'Tubs', 'type': ''}]),
    _make_update_data(writers=[{'name': 'Tubs', 'type': 'cowriter'}]),
    _make_update_data(writers=[{'name': 'Tubs'}, {'name': 'Tubs'}]),
    _make_update_data(focus_track='Y'),
    _make_update_data(focus_track='Y', focus_track_end_date='2022-10-23'),
]

VALID_TRACK_DURATION_UPDATE_REQUESTS = [
    {
        'duration_minutes': 0,
        'duration_seconds': 0
    },
    {
        'duration_minutes': 5,
        'duration_seconds': 24
    },
    {
        'duration_minutes': 1
    },
    {
        'duration_seconds': 1
    }
]

INVALID_TRACK_DURATION_UPDATE_REQUESTS = [
    {
        'duration_minutes': -1,
        'duration_seconds': -1
    }
]


@pytest.mark.parametrize('data', VALID_POST_TRACK_REQUESTS)
def test_track_post_schema(data):
    """Test track post schema."""
    result = TrackPostSchema().load(data.copy())
    data['track_name'] = data['track_name'].strip()
    assert not result.errors
    assert result.data == data


@pytest.mark.parametrize('data', INVALID_POST_TRACK_REQUESTS)
def test_track_post_schema_bad_request(data):
    """Test track post schema."""
    result = TrackPostSchema().load(data)
    assert result.errors


@pytest.mark.parametrize('data', VALID_UPDATE_TRACK_REQUESTS)
def test_track_update_schema(mocker, mock_app, data):
    """Test track post schema."""
    mocker.patch.object(
        ows_lyrics, 'has_explicit_lyrics', return_value=False)

    result = TrackUpdateSchema().load(data.copy())
    data['track_name'] = data['track_name'].strip()
    data['version'] = data['version'].strip()

    if data.get('focus_track_start_date', None):
        data['focus_track_start_date'] = \
            date.fromisoformat(data['focus_track_start_date'])

    if data.get('focus_track_end_date', None):
        data['focus_track_end_date'] = \
            date.fromisoformat(data['focus_track_end_date'])

    assert not result.errors
    assert result.data == data


@pytest.mark.parametrize('data', VALID_UPDATE_TRACK_ARTIST_PAYLOAD)
def test_track_artist_update_schema(data):
    """Test track artist update schema."""
    result = TrackArtistSchema().load(data)
    assert not result.errors
    assert result.data == {
        **data,
        'track_artist_id': str(data['track_artist_id'])
        if isinstance(data['track_artist_id'], str)
        else data['track_artist_id']
    }


@pytest.mark.parametrize('data', VALID_UPDATE_TRACK_WRITER_PAYLOAD)
def test_track_writer_update_schema(data):
    """Test track writer update schema."""
    result = TrackWriterSchema().load(data)
    assert not result.errors
    assert result.data == {
        **data,
        'track_writer_id': str(data['track_writer_id'])
        if isinstance(data['track_writer_id'], str)
        else data['track_writer_id']
    }


def test_track_writer_update_schema_error():
    """Test track writer update schema."""
    data = _make_track_writer_update_data(track_writer_id={'bad': 'data'})
    result = TrackWriterSchema().load(data)
    assert result.errors
    assert result.errors == {
        'track_writer_id': ['Not a valid number or string.']}


@pytest.mark.parametrize('data', INVALID_UPDATE_TRACK_REQUESTS)
def test_track_update_schema_bad_request(mocker, mock_app, data):
    """Test track post schema."""
    mocker.patch.object(
        ows_lyrics, 'has_explicit_lyrics', return_value=True)

    result = TrackUpdateSchema().load(data)
    assert result.errors


@pytest.mark.parametrize('data', VALID_TRACK_DURATION_UPDATE_REQUESTS)
def test_track_duration_update_schema(data):
    """Test track duration update schema."""
    result = TrackDurationSchema().load(data)
    assert not result.errors
    assert result.data == data


@pytest.mark.parametrize('data', INVALID_TRACK_DURATION_UPDATE_REQUESTS)
def test_track_duration_update_schema_bad_request(data):
    """Test track duration update schema."""
    result = TrackDurationSchema().load(data)
    assert result.errors