"""Test Tracks Model."""
import copy
import random

from ows_product_physical.models import track


def test_persister_get_tracks(
        db_fixture, multiple_tracks_for_update, minimal_product_for_tracks):
    """Assert tracks retrieved from the database by product_id."""
    tracks_data_for_update = copy.deepcopy(
        multiple_tracks_for_update)
    multiple_publisher_names = ['First', 'Second', 'Third']
    track_to_add_publishers = next(
        track_data for track_data in tracks_data_for_update
        if track_data['track_number'] == 1)
    track_to_add_publishers['publisher_names'] = multiple_publisher_names

    track.process_tracks(
        minimal_product_for_tracks['product_id'],
        minimal_product_for_tracks['upc'],
        tracks_data_for_update)

    expected_message = {'items': [{
        'track_id': 'generated_id',
        'track_number': 1,
        'track_name': 'First track',
        'performer': ['John Doe'],
        'isrc': 'US123456789',
        'side': None,
        'song_writers': [],
        'disc': 1,
        'length': {
            'formatted': '01:12:32',
            'hours': 1,
            'minutes': 12,
            'seconds': 32
        },
        'us_publishing_obligation': 'Composition',
        'third_party_publisher': 'Y',
        'publisher_names': multiple_publisher_names
    }, {
        'track_id': 'generated_id',
        'track_number': 2,
        'track_name': 'Second track',
        'performer': ['John Doe'],
        'isrc': 'US123456789X',
        'side': None,
        'song_writers': [],
        'disc': 1,
        'length': {
            'formatted': '00:04:23',
            'hours': 0,
            'minutes': 4,
            'seconds': 23
        },
        'us_publishing_obligation': 'ControlledByYourLabel',
        'third_party_publisher': 'Y',
        'publisher_names': []
    }, {
        'track_id': 'generated_id',
        'track_number': 3,
        'track_name': 'Third Track',
        'performer': ['John Doe Brown'],
        'isrc': 'US987654321X',
        'side': None,
        'song_writers': [],
        'disc': 1,
        'length': {
            'formatted': '00:04:23',
            'hours': 0,
            'minutes': 4,
            'seconds': 23
        },
        'us_publishing_obligation': 'PublicDomain',
        'third_party_publisher': 'N',
        'publisher_names': []
    }], 'pagination': {
        'type': 'standard',
        'offset': 0,
        'limit': 3,
        'total_records': 3
    }}

    result = track.get_tracks(minimal_product_for_tracks['product_id'])
    for tracks in result.message['items']:
        tracks['track_id'] = 'generated_id'

    assert result.message == expected_message


def test_persister_get_tracks_in_sorted_order(
        db_fixture, minimal_product_for_tracks):
    """Assert tracks retrieved in disc and track number order."""
    def formatted_track(disc, side, track_number):
        return {
            'disc': disc,
            'side': side,
            'track_number': track_number,
            'track_name': 'Some track',
            'performer': ['John Doe'],
        }

    data = [
        formatted_track(1, 'A', 1),
        formatted_track(1, 'A', 2),
        formatted_track(1, 'A', 3),
        formatted_track(1, 'B', 1),
        formatted_track(1, 'B', 2),
        formatted_track(1, 'B', 3),
        formatted_track(2, 'A', 1),
        formatted_track(2, 'A', 2),
        formatted_track(2, 'A', 3),
        formatted_track(2, 'B', 1),
        formatted_track(2, 'B', 2),
        formatted_track(2, 'B', 3),
    ]
    random.shuffle(data)

    track.process_tracks(
        minimal_product_for_tracks['product_id'],
        minimal_product_for_tracks['upc'], data)

    result = track.get_tracks(minimal_product_for_tracks['product_id'])

    sorted_by_disc_side_number = [(
        tracks['disc'],
        tracks['side'],
        tracks['track_number'])
        for tracks in result.message['items']]

    assert sorted_by_disc_side_number == [
        (1, 'A', 1),
        (1, 'A', 2),
        (1, 'A', 3),
        (1, 'B', 1),
        (1, 'B', 2),
        (1, 'B', 3),
        (2, 'A', 1),
        (2, 'A', 2),
        (2, 'A', 3),
        (2, 'B', 1),
        (2, 'B', 2),
        (2, 'B', 3)
    ]