"""Tests for track performer handlers."""
from operator import itemgetter

from switchboard_consumer.constants.track_performer_roles import \
    FEATURED_TYPE, PRIMARY_TYPE
from switchboard_consumer.logic.performer.track_performer_handler \
    import TrackPerformerHandler

SORT_KWARGS = {
    'key': itemgetter('name')
}


class TestTrackPerformerHandler:
    """Test TrackPerformerHandler."""

    def test_track_process_performers(self, track_with_performers,
                                      mock_logger):
        """Test that performers being processed."""
        expected_formatted_perfomers = [
            {
                'name': 'Cool Guy',
                'roleId': 27,
                'type': 'primary'
            },
            {
                'name': 'DisplayPerformer 1',
                'roleId': 27,
                'type': 'primary'
            },
            {
                'name': 'NonFeaturingMappableRole',
                'roleId': 79,
                'type': 'non-featured'
            },
            {
                'name': 'NonFeaturingPerformer',
                'roleId': 17,
                'type': 'non-featured'
            },
            {
                'name': 'Performer1',
                'roleId': 27,
                'type': 'primary'
            },
            {
                'name': 'Someone',
                'roleId': 27,
                'type': 'featured'
            }
        ]
        track = track_with_performers['track']
        performer_handler = TrackPerformerHandler(track, mock_logger)
        performers = performer_handler.process()
        assert len(performers) == len(expected_formatted_perfomers)
        assert performers == expected_formatted_perfomers

    def test_filter_participants_by_role(self, track_with_performers, mock_logger):  # noqa
        """Test filtering participants by role."""

        contributor = {
            'sequenceNumber': None,
            'participant': {
                'ids': [
                    {
                        'localId': '401',
                        'system': 'SONY',
                    }
                ],
                'name': 'NonFeaturingMappableRole',
                'members': []
            },
            'role': 'Cool Role'
        }

        track_with_performers['track']['contributors'].append(contributor)
        track = track_with_performers['track']
        performer_handler = TrackPerformerHandler(track, mock_logger)
        output = performer_handler.filter_participants_by_role_mapping(
            track_with_performers['track']['contributors'],
            ['Cool Role']
        )
        assert len(output) == 1
        assert output[0] == contributor

    def test_filter_participants_by_role_with_members(
            self, track_with_performers, mock_logger):
        """Test filtering participants by role with member data."""
        contributor = {
            'sequenceNumber': None,
            'participant': {
                'ids': [
                    {
                        'localId': '5059349',
                        'system': 'SONY',
                    }
                ],
                'name': 'Cool Participant',
                'members': [{
                            'sequenceNumber': None,
                            'participant': {
                                'ids': [
                                    {
                                        'localId': '35835875',
                                        'system': 'SONY',
                                    }
                                ],
                                'name': 'Cool Particpant Memeber',
                                'members': []
                            },
                            'role': 'Awesome Role'
                            }]
            },
            'role': 'Cool Role'
        }

        track_with_performers['track']['contributors'].append(contributor)
        track = track_with_performers['track']
        performer_handler = TrackPerformerHandler(track, mock_logger)
        output = performer_handler.filter_participants_by_role_mapping(
            track_with_performers['track']['contributors'],
            ['Awesome Role']
        )
        assert len(output) == 1
        assert output[0] == contributor['participant']['members'][0]

    def test_filter_participants_by_role_with_filter_to(self, track_with_performers, mock_logger):  # noqa
        """Test filtering participants by role and using a filter_to argument to filter existing roles correctly."""  # noqa
        # Performer already present in another list
        # (this would be primary performers normally)
        filter_list = [
            {
                'sequenceNumber': None,
                'participant': {
                    'ids': [
                        {
                            'localId': '401',
                            'system': 'SONY',
                        }
                    ],
                    'name': 'David Bowie',
                    'members': []
                },
                'role': 'Some Role'
            }
        ]

        contributor = {
            'sequenceNumber': None,
            'participant': {
                'ids': [
                    {
                        'localId': '401',
                        'system': 'SONY',
                    }
                ],
                'name': 'David Bowie',
                'members': []
            },
            'role': 'Cool Role'
        }

        track_with_performers['track']['contributors'].append(contributor)
        track = track_with_performers['track']
        performer_handler = TrackPerformerHandler(track, mock_logger)
        output = performer_handler.filter_participants_by_role_mapping(
            track_with_performers['track']['contributors'],
            ['Cool Role'],
            filter_list
        )
        assert not output  # As the performer existed in our filter to list
        assert len(filter_list) == 2
        assert filter_list[1] == contributor

    def test_filter_participants_by_role_with_filter_to_with_members(self, track_with_performers, mock_logger):  # noqa
        """Test filtering participants by role and using a filter_to argument with members to filter existing roles correctly."""  # noqa
        # Performer already present in another list
        # (this would be primary performers normally)
        filter_list = [
            {
                'sequenceNumber': None,
                'participant': {
                    'ids': [
                        {
                            'localId': '4000',
                            'system': 'SONY',
                        }
                    ],
                    'name': 'David Bowie feat. Whoeever',
                    'members': [
                        {
                            'sequenceNumber': None,
                            'participant': {
                                'ids': [
                                    {
                                        'localId': '35835875',
                                        'system': 'SONY',
                                    }
                                ],
                                'name': 'David Bowie',
                                'members': []
                            },
                            'role': 'Primary'
                        },
                        {
                            'sequenceNumber': None,
                            'participant': {
                                'ids': [
                                    {
                                        'localId': '35835876',
                                        'system': 'SONY',
                                    }
                                ],
                                'name': 'Whoever',
                                'members': []
                            },
                            'role': 'Featuring'
                        },

                    ]
                },
                'role': 'Some Role'
            }
        ]

        contributor = {
            'sequenceNumber': None,
            'participant': {
                'ids': [
                    {
                        'localId': '35835875',
                        'system': 'SONY',
                    }
                ],
                'name': 'David Bowie',
                'members': []
            },
            'role': 'Cool Role'
        }

        track_with_performers['track']['contributors'].append(contributor)
        track = track_with_performers['track']
        performer_handler = TrackPerformerHandler(track, mock_logger)
        output = performer_handler.filter_participants_by_role_mapping(
            track_with_performers['track']['contributors'],
            ['Cool Role'],
            filter_list
        )
        assert not output  # As the performer existed in our filter to list as a member # noqa
        assert len(filter_list) == 2
        assert filter_list[1] == contributor

    def test_filter_participants_with_members_by_role_with_filter_to(self, track_with_performers, mock_logger):  # noqa
        """Test filtering participants members by role and using a filter_to argument to filter existing roles correctly."""  # noqa
        # Performer already present in another list
        # (this would be primary performers normally)
        filter_list = [
            {
                'sequenceNumber': None,
                'participant': {
                    'ids': [
                        {
                            'localId': '4000',
                            'system': 'SONY',
                        }
                    ],
                    'name': 'David Bowie feat. Whoeever',
                    'members': [
                        {
                            'sequenceNumber': None,
                            'participant': {
                                'ids': [
                                    {
                                        'localId': '35835875',
                                        'system': 'SONY',
                                    }
                                ],
                                'name': 'David Bowie',
                                'members': []
                            },
                            'role': 'Primary'
                        },
                        {
                            'sequenceNumber': None,
                            'participant': {
                                'ids': [
                                    {
                                        'localId': '35835876',
                                        'system': 'SONY',
                                    }
                                ],
                                'name': 'Whoever',
                                'members': []
                            },
                            'role': 'Featuring'
                        },
                    ]
                },
                'role': 'Some Role'
            }
        ]

        contributor = {
            'sequenceNumber': None,
            'participant': {
                'ids': [
                    {
                        'localId': '35835875',
                        'system': 'SONY',
                    }
                ],
                'name': 'David Bowie Feat. Whoever & Someone',
                'members': [{
                            'sequenceNumber': None,
                            'participant': {
                                'ids': [
                                    {
                                        'localId': '35835875',
                                        'system': 'SONY',
                                    }
                                ],
                                'name': 'David Bowie',
                                'members': []
                            },
                            'role': 'Primary'
                            },
                            {
                            'sequenceNumber': None,
                            'participant': {
                                'ids': [
                                    {
                                        'localId': '35835876',
                                        'system': 'SONY',
                                    }
                                ],
                                'name': 'Whoever',
                                'members': []
                            },
                            'role': 'Featuring'
                            },
                            {
                            'sequenceNumber': None,
                            'participant': {
                                'ids': [
                                    {
                                        'localId': '35835877',
                                        'system': 'SONY',
                                    }
                                ],
                                'name': 'Someone',
                                'members': []
                            },
                            'role': 'Featuring'
                            },
                            ]
            },
            'role': 'Cool Role'
        }

        track_with_performers['track']['contributors'].append(contributor)
        track = track_with_performers['track']
        performer_handler = TrackPerformerHandler(track, mock_logger)
        output = performer_handler.filter_participants_by_role_mapping(
            track_with_performers['track']['contributors'],
            ['Featuring'],
            filter_list
        )

        assert len(output) == 1
        assert output[0]['participant']['name'] == 'Someone'
        assert len(filter_list) == 2

    def test_filter_participants_by_local_id(
            self, track_with_performers, mock_logger):
        """Test filtering participants by local id."""
        contributor = {
            'sequenceNumber': None,
            'participant': {
                'ids': [
                    {
                        'localId': '5059349',
                        'system': 'SONY',
                    }
                ],
                'name': 'Cool Participant',
                'members': [{
                            'sequenceNumber': None,
                            'participant': {
                                'ids': [
                                    {
                                        'localId': '35835875',
                                        'system': 'SONY',
                                    }
                                ],
                                'name': 'Cool Particpant Memeber',
                                'members': []
                            },
                            'role': 'Awesome Role'
                            }]
            },
            'role': 'Cool Role'
        }

        track_with_performers['track']['contributors'].append(contributor)
        track = track_with_performers['track']
        performer_handler = TrackPerformerHandler(track, mock_logger)
        output = performer_handler.filter_participants_by_local_id(
            track_with_performers['track']['contributors'],
            {'localId': '35835875'}
        )
        assert len(output) == 1
        assert output[0] == contributor['participant']['members'][0]

    def test_participant_without_contribution(self, participant_no_contributor, mock_logger):  # noqa
        """Test a participant without a contribution is a primary performer."""
        performer_handler = TrackPerformerHandler(
            participant_no_contributor,
            mock_logger
        )
        performers = performer_handler.process()
        expected_performers = [
            {
                'name': 'David Bowie',
                'roleId': 27,
                'type': 'primary'
            }
        ]
        assert performers == expected_performers

    def test_no_participant(self, no_participant, mock_logger):
        """Test that a single participant in displayArtists is a performer."""
        performer_handler = TrackPerformerHandler(no_participant, mock_logger)
        performers = performer_handler.process()
        assert performers == []

    def test_participant_with_contribution(self, participant_primary_contribution, mock_logger):  # noqa
        """Test a single participant without a contribution
        is a primary performer."""
        performer_handler = TrackPerformerHandler(
            participant_primary_contribution,
            mock_logger
        )
        performers = performer_handler.process()
        expected_performers = [
            {
                'name': "David 'What You Doin in Space Man' Bowie",
                'roleId': 89,
                'type': PRIMARY_TYPE
            },
            {
                'name': 'David Bowie',
                'roleId': 27,
                'type': PRIMARY_TYPE
            }
        ]
        assert performers == expected_performers

    def test_participant_with_featured_contribution(self, participant_featured_contribution, mock_logger):  # noqa
        """Test a single participant without a contribution
        is a primary performer."""
        performer_handler = TrackPerformerHandler(
            participant_featured_contribution, mock_logger
        )
        performers = performer_handler.process()
        expected_performers = [
            {
                'name': "David 'What You Doin in Space Man' Bowie",
                'roleId': 89,
                'type': FEATURED_TYPE
            },
            {
                'name': 'David Bowie',
                'roleId': 27,
                'type': FEATURED_TYPE
            },
        ]
        assert performers == expected_performers

    def test_track_process_duplicate_performers_with_primary_and_featuring(
            self, participant_with_primary_and_featuring_contribution,
            mock_logger):
        """Test that if duplicate performers are given their 'best' type."""
        performer_handler = TrackPerformerHandler(
            participant_with_primary_and_featuring_contribution,
            mock_logger
        )
        performers = performer_handler.process()
        expected_performers = [
            {
                'name': "David 'What You Doin in Space Man' Bowie",
                'roleId': 89,
                'type': PRIMARY_TYPE
            },
            {
                'name': 'David Bowie',
                'roleId': 27,
                'type': PRIMARY_TYPE
            }
        ]
        assert performers == expected_performers

    def test_track_process_duplicate_performers_with_featuring_and_non_featuring_roles(  # noqa
            self, participant_with_featuring_and_non_featuring_contribution,
            mock_logger):
        """Test that if duplicate performers are given their 'best' type."""
        performer_handler = TrackPerformerHandler(
            participant_with_featuring_and_non_featuring_contribution,
            mock_logger
        )
        performers = performer_handler.process()
        expected_performers = [
            {
                'name': "David 'What You Doin in Space Man' Bowie",
                'roleId': 89,
                'type': FEATURED_TYPE
            },
            {
                'name': 'David Bowie',
                'roleId': 27,
                'type': FEATURED_TYPE
            }
        ]
        assert performers == expected_performers

    def test_performer_defaults_removed(
            self, participant_primary_contribution_with_specific_role,
            mock_logger):
        """Test that defaults are removed if a more specific role is present for the same performer."""  # noqa
        performer_handler = TrackPerformerHandler(
            participant_primary_contribution_with_specific_role,
            mock_logger
        )
        performers = performer_handler.process()
        expected_performers = [
            {
                'name': 'David Bowie',
                'roleId': 89,
                'type': PRIMARY_TYPE
            }
        ]
        assert performers == expected_performers

    def test_performer_duplicates_removed(
            self, participant_primary_contribution_with_duplicates,
            mock_logger):
        """Test that duplicates are removed in performer output."""
        performer_handler = TrackPerformerHandler(
            participant_primary_contribution_with_duplicates,
            mock_logger
        )
        performers = performer_handler.process()
        expected_performers = [
            {
                'name': 'David Bowie',
                'roleId': 27,
                'type': PRIMARY_TYPE
            }
        ]
        assert performers == expected_performers

    def test_performer_band_handling(
            self, compound_performers_with_non_featuring_contributions,
            mock_logger):
        """Test that compound participants with non featuring contributions are set correctly."""  # noqa
        performer_handler = TrackPerformerHandler(
            compound_performers_with_non_featuring_contributions,
            mock_logger
        )
        performers = performer_handler.process()
        expected_performers = [
            {'name': 'C.J. Ramone', 'roleId': 27, 'type': 'non-featured'},
            {'name': 'Joey Ramone', 'roleId': 27, 'type': 'primary'},
            {'name': 'Johnny Ramone', 'roleId': 89, 'type': 'primary'},
            {'name': 'Marky Ramone', 'roleId': 41, 'type': 'non-featured'}
        ]
        assert performers == expected_performers