"""Test rules."""
from unittest.mock import MagicMock, patch

from bulk_metadata_ingester_common.models.bulk_release import BulkRelease
import pytest
import rules


def test_validate_mandatory_fields(test_multiple_releases_json):
    """Test validate_digital_upc_exists method."""
    models = {}

    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = None

    output = rules.validate_mandatory_fields(models, MagicMock())

    assert output == expected_output


def test_require_valid_pline(test_multiple_releases_json):
    """Test require_valid_pline method."""
    models = {}
    test_multiple_releases_json['7892920192100_____991397102'][0]['P-Line'] = 'Broken'  # noqa: E501

    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(
        validation_rule_id='INVALID_PLINE', response='Reject',
        message='Invalid product P-Line: Broken'
    )
    output = rules.require_valid_pline(models, MagicMock())

    assert output == expected_output


def test_require_valid_cline(test_multiple_releases_json):
    """Test require_valid_cline method."""
    models = {}
    test_multiple_releases_json['7892920192100_____991397102'][0]['[C] Information'] = 'Broken'  # noqa: E501

    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(
        validation_rule_id='INVALID_CLINE', response='Reject',
        message='Invalid product C-Line: Broken'
    )
    output = rules.require_valid_cline(models, MagicMock())
    assert output == expected_output


def test_require_valid_track_pline(test_multiple_releases_json):
    """Test require_valid_track_pline method."""
    models = {}
    test_multiple_releases_json['7892920192100_____991397102'][0]['[P] Information'] = 'Broken'  # noqa: E501

    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(
        validation_rule_id='INVALID_TRACK_PLINE', response='Reject',
        message='Invalid P-Line on track 1-1'
    )
    output = rules.require_valid_track_pline(models, MagicMock())

    assert output == expected_output


def test_validate_release_type(test_multiple_releases_json):
    """Test validate_release_type method."""
    models = {}
    test_multiple_releases_json['7892920192100_____991397102'][0]['Format: Full Length / EP / Single'] = 'Broken'  # noqa: E501

    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(
        validation_rule_id='INVALID_RELEASE_TYPE', response='Reject',
        message='Invalid release type: Broken'
    )
    output = rules.validate_release_type(models, MagicMock())

    assert output == expected_output


@patch('rules.graphql_gateway')
def test_validate_artist_country(mock_graphql, test_multiple_releases_json):
    """Test validate_artist_country method."""
    models = {}
    mock_graphql.execute.return_value = {'data': {'territories': ['Broken']}}

    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    payload = 'ORCH_1_2016'

    expected_output = rules.RuleResult(
        validation_rule_id='INVALID_ARTIST_COUNTRY', response='Reject',
        message='Invalid artist country: Brazil'
    )

    output = rules.validate_artist_country(models, MagicMock())

    call_keys = mock_graphql.execute.mock_calls[0][1][1]['data']
    mock_graphql.execute.assert_called_once()

    assert payload == call_keys
    assert output == expected_output


def test_validate_album_pricing(test_multiple_releases_json):
    """Test validate_album_pricing method."""
    models = {}
    test_multiple_releases_json['7892920192100_____991397102'][0]['Album Pricing'] = 'Broken'  # noqa: E501
    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(
        validation_rule_id='INVALID_ALBUM_PRICING', response='Reject',
        message='Invalid price type: Broken'
    )
    output = rules.validate_album_pricing(models, MagicMock())

    assert output == expected_output


def test_validate_track_pricing(test_multiple_releases_json):
    """Test validate_track_pricing method."""
    models = {}
    test_multiple_releases_json['7892920192100_____991397102'][0]['Track Pricing'] = 'Broken'  # noqa: E501
    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(
        validation_rule_id='INVALID_TRACK_PRICING', response='Reject',
        message='Invalid price type: Broken'
    )
    output = rules.validate_track_pricing(models, MagicMock())

    assert output == expected_output


def test_validate_release_date(test_multiple_releases_json):
    """Test validate_release_date method."""
    models = {}
    test_multiple_releases_json['7892920192100_____991397102'][0]['Release Date'] = 'Broken'  # noqa: E501
    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(
        validation_rule_id='INVALID_RELEASE_DATE', response='Reject',
        message='Invalid release date: Broken'
    )
    output = rules.validate_release_date(models, MagicMock())

    assert output == expected_output


def test_validate_sale_start_date(test_multiple_releases_json):
    """Test validate_sale_start_date method."""
    models = {}
    test_multiple_releases_json['7892920192100_____991397102'][0]['Sale Start Date'] = 'Broken'  # noqa: E501
    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(
        validation_rule_id='INVALID_SALE_START_DATE', response='Reject',
        message='Invalid release date: Broken')

    output = rules.validate_sale_start_date(models, MagicMock())

    assert output == expected_output


def test_validate_release_meta_language_mismatch(test_multiple_releases_json):
    """Test validate_release_meta_language method."""
    models = {}
    test_multiple_releases_json['7892920192100_____991397102'][0]['Release Meta Language'] = 'Broken'  # noqa: E501
    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(
        validation_rule_id='INVALID_RELEASE_META_LANGUAGE', response='Reject',
        message='Invalid metadata language: Broken')
    output = rules.validate_release_meta_language(models, MagicMock())

    assert output == expected_output


@patch('rules.graphql_gateway')
def test_validate_release_upc_in_content(
    mock_graphql, test_single_release_json
):
    """Test validate_release_upc method."""
    models = {}
    mock_graphql.execute.return_value = {
        'data': {
            'productByUpc': {
                'status': 'in_content'
            }
        }
    }

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(validation_rule_id='INVALID_UPC_IN_CONTENT', response='Reject', message='Invalid upc; status is in_content: 196871151023')  # noqa:E501

    output = rules.validate_release_upc(models, MagicMock())

    mock_graphql.execute.assert_called_once()

    assert output == expected_output


@patch('rules.graphql_gateway')
def test_validate_release_upc_failed_checksum(
    mock_graphql, test_single_release_json
):
    """Test validate_release_upc method."""
    models = {}
    test_single_release_json['196871151023_____1362655'][0]['Digital UPC'] = 196589839190  # noqa: E501
    mock_graphql.execute.return_value = {
        'data': {
            'productByUpc': {
                'status': 'label_processing'
            }
        }
    }

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(validation_rule_id='INVALID_UPC_CHECKSUM', response='Reject', message='Invalid upc; failed checksum: 196589839190')  # noqa:E501

    output = rules.validate_release_upc(models, MagicMock())

    mock_graphql.execute.assert_not_called()

    assert output == expected_output


@patch('rules.graphql_gateway')
def test_validate_release_upc_vendor_mismatch(
    mock_graphql, test_single_release_json
):
    """Test validate_release_upc method."""
    models = {}
    mock_graphql.execute.return_value = {
        'data': {
            'productByUpc': {
                'status': 'label_processing', 'vendorId': 1234
            }
        }
    }

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(validation_rule_id='INVALID_UPC_VENDOR_MISMATCH', response='Reject', message='Invalid upc; vendor id mismatch: 1234')  # noqa:E501

    output = rules.validate_release_upc(models, MagicMock())

    mock_graphql.execute.called_once()

    assert output == expected_output


@pytest.mark.parametrize(
    'upc,is_valid',
    [
        (196589839190, False),
        (196871151023, True),
    ],
)
def test_validate_upc(upc, is_valid):
    """Test _validate_upc method."""
    output = rules._validate_upc(upc)
    assert output == is_valid


@pytest.mark.parametrize(
    'upc,err_code,response,err_message',
    [
        ('broken', 'INVALID_MANUFACTURER_UPC_FORMAT', 'Reject', 'Invalid manufacturer_upc; not int: broken'),  # noqa: E501
        (123123123123123, 'INVALID_MANUFACTURER_UPC_LENGTH', 'Reject', 'Invalid manufacturer_upc length: 15'),  # noqa: E501
    ],
)
def test_validate_manufacturer_upc(
    upc, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_manufacturer_upc method."""
    models = {}
    test_single_release_json['196871151023_____1362655'][0]["Manufacturer's UPC"] = upc  # noqa: E501
    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(validation_rule_id=err_code, response=response, message=err_message)  # noqa:E501
    output = rules.validate_manufacturer_upc(models, MagicMock())

    assert output == expected_output


def test_validate_gaps_track_volume_number(test_multiple_releases_json):
    """Test validate_gaps_track_volume_number method."""
    models = {}
    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    # Remove track
    models['7892920192605_____991420367'].tracks.pop('BX66R2300007_2_3')

    expected_output = rules.RuleResult(
        validation_rule_id='MISSING_TRACK_OR_VOLUME_NUMBER',
        response='Reject',
        message='Missing track number 3 on volume 2'
    )
    output = rules.validate_gaps_track_volume_number(models, MagicMock())

    assert output == expected_output


def test_validate_gaps_track_volume_number_2(test_multiple_releases_json):
    """Test validate_gaps_track_volume_number method."""
    models = {}
    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    # Remove volume
    models['7892920192407_____991412424'].tracks.pop('QZGLS1950753_2_1')
    models['7892920192506_____991413083'].tracks.pop('BRPUT2000010_2_2')
    models['7892920192605_____991420367'].tracks.pop('BX66R2300007_2_3')
    models['7892920192704_____991428527'].tracks.pop('BX66R2300008_2_4')
    models['7892920192803_____991428885'].tracks.pop('BCA6G2300001_2_5')

    expected_output = rules.RuleResult(
        validation_rule_id='MISSING_TRACK_OR_VOLUME_NUMBER',
        response='Reject',
        message='Missing volume number 2'
    )
    output = rules.validate_gaps_track_volume_number(models, MagicMock())

    assert output == expected_output


@pytest.mark.parametrize(
    'genre,subgenre,err_code,result,err_message',
    [
        ('Shmooze', 'Soul', 'INVALID_GENRE', 'Reject', 'Invalid genre: Shmooze'),  # noqa: E501
        ('Blues', 'unmatched', 'INVALID_SUBGENRE', 'Reject', 'Invalid genre and subgenre: Blues:unmatched'),  # noqa: E501
    ],
)
def test_validate_genre_subgenre(
        genre, subgenre, err_code, result, err_message,
        test_single_release_json
):
    """Test validate_genre_subgenre method."""
    models = {}
    test_single_release_json['196871151023_____1362655'][0]['Genre'] = genre  # noqa: E501
    test_single_release_json['196871151023_____1362655'][0]['Sub-genre'] = subgenre  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    expected_output = rules.RuleResult(validation_rule_id=err_code, response=result, message=err_message)  # noqa:E501

    output = rules.validate_genre_subgenre(models, MagicMock())
    assert output == expected_output


@pytest.mark.parametrize(
    'isrc,is_valid',
    [
        ('BXOXJ2100016', True),
        ('NOTISRC', False),
    ],
)
def test_is_valid_isrc(isrc, is_valid):
    """Test _is_valid_isrc."""
    output = rules._is_valid_isrc(isrc)
    assert output == is_valid


def test_validate_isrc(test_multiple_releases_json):
    """Test validate_isrc method."""
    models = {}
    test_multiple_releases_json['7892920192100_____991397102'][0]['ISRC'] = 'Broken'  # noqa: E501

    for k, v in test_multiple_releases_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_isrc(models, MagicMock())

    assert output == rules.RuleResult(
        validation_rule_id='INVALID_ISRC_PATTERN', response='Reject',
        message='Invalid ISRC pattern: Broken'
    )


@pytest.mark.parametrize(
    'explicit_flag,err_code,response,err_message',
    [
        ('broken', 'INVALID_EXPLICIT_FLAG', 'Reject', 'Invalid Explicit flag on track: broken'),  # noqa: E501
    ],
)
def test_validate_explicit_flag(
    explicit_flag, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_explicit_flag method."""
    models = {}

    test_single_release_json['196871151023_____1362655'][0]['Explicit (No/Yes/Clean)'] = explicit_flag  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_explicit_flag(models, MagicMock())
    expected_output = rules.RuleResult(
        err_code, response, err_message)

    assert output == expected_output


@pytest.mark.parametrize(
    'project_code,err_code,response,err_message',
    [
        ('broken$', 'INVALID_PROJECT_CODE', 'Reject', 'Invalid Project Code; not alphanumeric: broken$'),  # noqa: E501
        ('a very long string with far too many characters', 'INVALID_PROJECT_CODE_LENGTH', 'Reject', 'Invalid Project Code; too long: a very long string with far too many characters'),  # noqa: E501
    ],
)
def test_validate_project_code(
    project_code, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_project_code method."""
    models = {}

    test_single_release_json['196871151023_____1362655'][0]['Folder Name / Project Code'] = project_code  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_project_code(models, MagicMock())
    expected_output = rules.RuleResult(
        err_code, response, err_message)

    assert output == expected_output


@pytest.mark.parametrize(
    'file_name,err_code,response,err_message',
    [
        ('a very long string with far too many characters and it doesn''t really look like a filename anyway.wav',  # noqa: E501
            'INVALID_FILE_NAME_LENGTH', 'Reject',
            'Invalid Track File Name length: a very long string with far too many characters and it doesn''t really look like a filename anyway.wav'),   # noqa: E501
        ('path/to/file.mp3', 'INVALID_FILE_NAME_EXT', 'Reject', 'Invalid Track File Name extension: .mp3'),  # noqa: E501
    ],
)
def test_validate_file_name(
    file_name, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_file_name method."""
    models = {}

    test_single_release_json['196871151023_____1362655'][0]['File Name'] = file_name  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_file_name(models, MagicMock())
    expected_output = rules.RuleResult(
        err_code, response, err_message)

    assert output == expected_output


@pytest.mark.parametrize(
    'p_type,err_code,response,err_message',
    [
        ('Muse', 'INVALID_PERFORMER_TYPE', 'Reject',
            'Invalid Performer Type: Muse'),
    ],
)
def test_validate_performer_type(
    p_type, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_performer_type method."""
    models = {}

    test_single_release_json['196871151023_____1362655'][0]['Performer 1 Type'] = p_type  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_performer_type(models, MagicMock())
    expected_output = rules.RuleResult(
        err_code, response, err_message)

    assert output == expected_output


@pytest.mark.parametrize(
    'p_role,err_code,response,err_message',
    [
        ('broken', 'INVALID_PERFORMER_ROLE', 'Reject',
            'Invalid Performer Role: broken'),
    ],
)
def test_validate_performer_role(
    p_role, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_performer_role method."""
    models = {}

    test_single_release_json['196871151023_____1362655'][0]['Performer 1 Main Role'] = p_role  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_performer_role(models, MagicMock())
    expected_output = rules.RuleResult(
        err_code, response, err_message)

    assert output == expected_output


@pytest.mark.parametrize(
    'country_of_recording,err_code,response,err_message',
    [
        ('broken', 'INVALID_COUNTRY_OF_RECORDING', 'Reject',
            'Invalid country of recording: broken'),
    ],
)
def test_validate_country_of_recording(
    country_of_recording, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_country_of_recording method."""
    models = {}

    test_single_release_json['196871151023_____1362655'][0]['Country of Recording'] = country_of_recording  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_country_of_recording(models, MagicMock())
    expected_output = rules.RuleResult(
        err_code, response, err_message)

    assert output == expected_output


@pytest.mark.parametrize(
    'copyright_country,err_code,response,err_message',
    [
        ('broken', 'INVALID_COPYRIGHT_OWNER_COUNTRY', 'Reject',
            'Invalid copyright owner country: broken'),
    ],
)
def test_validate_nationality_of_original_copyright_owner(
    copyright_country, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_nationality_of_original_copyright_owner method."""
    models = {}

    test_single_release_json['196871151023_____1362655'][0]['Nationality of Original Copyright Owner'] = copyright_country  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_nationality_of_original_copyright_owner(
        models, MagicMock())
    expected_output = rules.RuleResult(
        err_code, response, err_message)

    assert output == expected_output


@pytest.mark.parametrize(
    'ownership_type,err_code,response,err_message',
    [
        ('I am the master', 'INVALID_OWNERSHIP_TYPE', 'Reject',
            'Invalid track ownership rights: I am the master'),
    ],
)
def test_validate_ownership_type(
    ownership_type, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_ownership_type method."""
    models = {}

    test_single_release_json['196871151023_____1362655'][0]['Ownership For This Sound Recording'] = ownership_type  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_ownership_type(models, MagicMock())
    expected_output = rules.RuleResult(
        err_code, response, err_message)

    assert output == expected_output


@pytest.mark.parametrize(
    'third_party,publishers,err_code,response,err_message',
    [
        ('Yes', None, 'INVALID_PUBLISHERS', 'Reject',
            'Invalid publishers data: None'),
    ],
)
def test_validate_publisher(
    third_party, publishers, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_publisher method."""
    models = {}

    test_single_release_json['196871151023_____1362655'][0]['3rd Party Publisher? (Yes/No)'] = third_party  # noqa: E501
    test_single_release_json['196871151023_____1362655'][0]['Publisher(s)'] = publishers  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_publisher(models, MagicMock())
    expected_output = rules.RuleResult(
        err_code, response, err_message)

    assert output == expected_output


@pytest.mark.parametrize(
    'track_language,err_code,response,err_message',
    [
        ('Frenglish', 'INVALID_TRACK_LANGUAGE', 'Reject',
            'Invalid track language data: Frenglish'),
    ],
)
def test_validate_track_language(
    track_language, err_code, response, err_message,
    test_single_release_json
):
    """Test validate_track_language method."""
    models = {}

    test_single_release_json['196871151023_____1362655'][0]['Track Audio Language'] = track_language  # noqa: E501

    for k, v in test_single_release_json.items():
        models[k] = BulkRelease(json_release_rows=v)

    output = rules.validate_track_language(models, MagicMock())
    expected_output = rules.RuleResult(
        err_code, response, err_message)

    assert output == expected_output