"""Unit tests for formatting."""

import datetime

import pytest

from src.constants import error_correction_field as ec
from src.logic import format as fm


def test_format_basic_fields(mock_input_data):
    """Test format basic fields."""
    expected_final_result = {}
    fm._format_basic_fields(mock_input_data, expected_final_result)
    assert expected_final_result == {
        'p_info': '2024 x',
        'volume_number': 2,
        'version': '4',
        'duration_seconds': 10,
        'duration_minutes': 1,
        'focus_track': 'Y',
        'focus_track_end_date': datetime.date(2024, 1, 11),
        'focus_track_start_date': datetime.date(2024, 1, 11)}


def test_format_track_artist_fields(mock_input_data):
    """Test format track artist fields."""
    expected_final_result = {}
    fm._format_track_artist_fields(mock_input_data, expected_final_result)
    assert expected_final_result == {'artists': [
        {
            'type': 'performer',
            'name': 'some performer'
        },
        {
            'type': 'feature_to_primary',
            'name': 'some ftp'
        }
    ]}


@pytest.mark.parametrize(
    ('description', 'mock_input', 'expected_result'),
    [
        ('test corrections',
         {'track_writer': ['xyz'], 'foo': 'bar'},
         {'writers': [{'type': 'writer', 'name': 'xyz'}]}
         ),
        ('test no corrections', {'foo': 'bar'}, {})
    ]
)
def test_format_track_writers(description, mock_input, expected_result):
    """Test format track writers."""
    mock_result = {}
    fm._format_track_writers(mock_input, mock_result)
    assert mock_result == expected_result


def test_format_track_correction_data(mocker):
    """Test format_track_correction_data."""
    mock_input = {
        'originalRightsHolderCountryId': 1,
        'ownershipRights': '',
        'vendor_track_identifier': '',
        'track_itunes_pricing': [],
        'performer': [],
        'previewstarttime': '',
        'originalFileName': '',
        'track_publisher': [],
        'metaLanguageCode': '',
        'track_amazon_pricing': [],
        'recordingCountryId': 2,
        'performers': [],
        'participants': [],
        'last_updated': '',
        'track': 'true'
    }
    assert set(ec.NOT_FOR_UPDATE).issubset(mock_input.keys())
    mock_format_basic = mocker.patch('src.logic.format._format_basic_fields')
    mock_format_artists = mocker.patch('src.logic.format._format_track_artist_fields')
    mock_format_writers = mocker.patch('src.logic.format._format_track_writers')
    result = fm.format_track_correction_data(mock_input)
    mock_format_basic.assert_called_once()
    mock_format_artists.assert_called_once()
    mock_format_writers.assert_called_once()
    assert result == {}


def test_structure_corrections_by_tuid(mocker):
    """Test structure_corrections_by_tuid."""
    mock_include_artists = mocker.patch('src.logic.format._include_existing_track_role_fields')
    mock_track_revisions = [
        {'key_id': 1, 'field_name': 'a', 'key_value': 'c'},
        {'key_id': 1, 'field_name': 'b', 'key_value': 'd'},
        {'key_id': 2, 'field_name': 'a', 'key_value': 'g'},
        {'key_id': 2, 'field_name': 'b', 'key_value': 'h'},
    ]
    result = fm.structure_corrections_by_tuid(mock_track_revisions)
    mock_include_artists.assert_called_once()
    assert result == {
        '1': {'a': 'c', 'b': 'd'},
        '2': {'a': 'g', 'b': 'h'}
    }


@pytest.mark.parametrize(
    ('test_description', 'mock_input', 'expected_result'),
    [
        ('both duration fields', {
            'foo': 'baz',
            'duration_minutes': 0,
            'duration_seconds': 0
        }, {
            'duration_minutes': 0,
            'duration_seconds': 0
        }
        ),
        ('1 duration field', {
            'foo': 'baz',
            'duration_seconds': 0
        }, {'duration_seconds': 0}
        ),
        ('no duration fields', {'foo': 'baz'}, {})
    ]
)
def test_remove_track_duration(mocker, test_description, mock_input, expected_result):
    """Test remove_track_duration."""
    result = fm.remove_track_duration(mock_input)
    assert result == expected_result