"""Test helpers."""

import base64
import json

import pytest

from typing import Any
from typing import Dict


sample_messages = [
    {
        'sound_recording_id': 'sample-id-1',
        'previous_version_id': 'sample-prev-id-1',
        'version_id': 'sample-version-id-1',
        'updated': True,
        'last_modified': '2023-05-31T23:34:36+00:00',
        'tracks_isrcs': [
            'MOCK-ISRC-2'
        ]
    },
    {
        'sound_recording_id': 'sample-id-2',
        'previous_version_id': None,
        'version_id': 'sample-version-id-2',
        'updated': True,
        'last_modified': '2023-12-11T17:54:02+00:00',
        'tracks_isrcs': [
            'MOCK-ISRC-1'
        ]
    }
]


def msk_event(kafka_messages):
    """Create records in MSK-Lambda connector format."""
    records = []
    for message in kafka_messages:
        record: Dict[str, Any] = {
            'headers': [],
            'key': message['sound_recording_id'] if 'sound_recording_id' in message else 'key-123',
            'offset': 1,
            'partition': 0,
            'timestamp': 1634921120616,
            'timestampType': 'CREATE_TIME',
            'topic': 'event.sr.newVersion',
            'value': base64.b64encode(json.dumps(message).encode('utf-8')).decode('utf-8')
        }
        records.append(record)
    result = {
        'bootstrapServers': 'kafka-servers',
        'eventSource': 'aws:kafka',
        'eventSourceArn': 'arn:aws:kafka:us-east-1:437795906767:cluster/cdc/uuid',  # noqa:E501
        'records': {
            'event.sr.newVersion-0': records
        }
    }
    return result


def _mock_asset():
    """Create a mock asset with default values."""
    return {
        'uuid': 'b3955ca9-bfb0-4d09-8f18-9eb4fd8737ff',
        'filename': '90e575bd-94a5-4a3e-9f1f-dade36feb8c3',
        'extension': 'flac'
    }


def _mock_incorrect_extension_asset():
    """Create a mock asset with incorrect extension."""
    return {
        'uuid': 'b3955ca9-bfb0-4d09-8f18-9eb4fd8737ff',
        'filename': '90e575bd-94a5-4a3e-9f1f-dade36feb8c3',
        'extension': 'exe'
    }


def _mock_track_audio_attribute(attr_id):
    return {
        'id': f'track-audio-attr-{attr_id}',
        'attribute': {
            'id': attr_id,
            'description': f'Mock audio attribute {attr_id}'
        }
    }


def _mock_track_rights_attribute(attr_id):
    return {
        'id': f'track-rights-attr-{attr_id}',
        'attribute': {
            'id': attr_id,
            'description': f'Mock rights attribute {attr_id}'
        }
    }


def _rule(service, territory, policy, user_id='user 1', last_modified_date='2025-04-24T14:14:26.738Z'):
    rule = {
        'service': service,
        'territory': territory,
        'policy': policy,
        'created_by': {
            'id': user_id,
            'type': 'ORCHADMIN'
        },
        'last_modified_by': {
            'id': user_id,
            'type': 'ORCHADMIN'
        },
        'active': True,
        'created_date': '2025-04-24T14:14:26.738Z',
        'last_modified_date': last_modified_date
    }
    if policy == 'monetize':
        rule['start_date'] = '2013-03-14T00:03:00.000Z'
    return rule


def _track_with_vendor_rules(track_rules=[], vendor_rules=[]):
    return {
        'rules': track_rules,
        'product': {
            'id': '4634679',
            'display_upc': '0726449910280',
            'status': 'in_content',
            'release_date': '2023-08-31',
            'label': {
                'name': 'MockVendor',
                'type': 'Vendor',
                'uuid': 'vendor-123-456-789',
                'id': {
                    'vendor': 21069,
                    'subaccount': 0
                },
                'rules': vendor_rules
            },
            'subgenre': {
                'id': 997,
                'name': 'Electronic',
                'genre': {
                    'name': 'Electronic',
                    'id': 2
                }
            }
        },
        'primary': True,
        'explicit': 'N',
        'isrc': 'ABC123456789',
        'participations': [],
        'name': 'Mock Track',
        'territories': [],
        'tuid': '123'
    }


def _track_with_subaccount_rules(track_rules=[], subacc_rules=[], vendor_rules=[]):
    return {
        'rules': track_rules,
        'product': {
            'id': '4634679',
            'display_upc': '0726449910280',
            'status': 'in_content',
            'release_date': '2023-08-31',
            'label': {
                'name': 'MockSub',
                'type': 'Subaccount',
                'uuid': 'sub-123-456-789',
                'id': {
                    'vendor': 21069,
                    'subaccount': 34103
                },
                'rules': subacc_rules,
                'vendor': {
                    'rules': vendor_rules
                }
            },
            'subgenre': {
                'id': 997,
                'name': 'Electronic',
                'genre': {
                    'name': 'Electronic',
                    'id': 2
                }
            }
        },
        'primary': True,
        'explicit': 'N',
        'isrc': 'ABC123456789',
        'participations': [],
        'name': 'Mock Track',
        'territories': [],
        'tuid': '123'
    }


@pytest.fixture
def sound_recording_metadata_no_rules():  # noqa: D103
    return {
        'track_connection': {
            'tracks': [
                _track_with_vendor_rules(),
                _track_with_subaccount_rules()
            ]
        },
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def sound_recording_metadata():  # noqa: D103
    return {
        'track_connection': {
            'tracks': [
                _track_with_vendor_rules(
                    track_rules=[_rule('tiktok', 'US', 'monetize')],
                    vendor_rules=[_rule('tiktok', 'US', 'monetize')]
                ),
                _track_with_subaccount_rules(
                    track_rules=[
                        _rule('other_service', 'US', 'monetize'),
                        _rule('tiktok', 'US', 'monetize')
                    ],
                    subacc_rules=[_rule('tiktok', 'US', 'monetize')],
                    vendor_rules=[_rule('tiktok', 'US', 'monetize')]
                )
            ]
        },
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def sound_recording_metadata_monetize_rule_missing_start_date():  # noqa: D103
    rule_missing_start_date = _rule('tiktok', 'US', 'monetize')
    del rule_missing_start_date['start_date']
    return {
        'track_connection': {
            'tracks': [
                _track_with_vendor_rules(track_rules=[rule_missing_start_date])
            ]
        },
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def sound_recording_metadata_block_access_rule_missing_start_date():  # noqa: D103
    rule_missing_start_date = _rule('tiktok', 'US', 'block_access')
    rule_missing_start_date.pop('start_date', None)
    return {
        'track_connection': {
            'tracks': [
                _track_with_vendor_rules(track_rules=[rule_missing_start_date])
            ]
        },
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def previous_sound_recording_metadata():  # noqa: D103
    return {
        'track_connection': {
            'tracks': [
                _track_with_vendor_rules(
                    track_rules=[_rule('tiktok', 'US', 'monetize', 'user 2', '2025-05-01T10:00:00.000Z')],
                    vendor_rules=[_rule('tiktok', 'US', 'monetize', 'user 2', '2025-05-01T10:00:00.000Z')]
                ),
                _track_with_subaccount_rules(
                    track_rules=[
                        _rule('other_service', 'US', 'monetize', 'user 2', '2025-05-01T10:00:00.000Z'),
                        _rule('tiktok', 'US', 'monetize', 'user 2', '2025-05-01T10:00:00.000Z')],
                    subacc_rules=[_rule('tiktok', 'US', 'monetize', 'user 2', '2025-05-01T10:00:00.000Z')],
                    vendor_rules=[_rule('tiktok', 'US', 'monetize', 'user 2', '2025-05-01T10:00:00.000Z')]
                )
            ]
        },
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def new_osr_event_input():
    """Create new OSR event input for testing."""
    return [
        {
            'sound_recording_id': 'mock-sr-id-1',
            'previous_version_id': None,
            'version_id': 'mock-version-id-1',
            'updated': True,
            'last_modified': '2023-12-11T17:54:02+00:00',
            'tracks_isrcs': ['MOCK-ISRC-1']
        }
    ]


@pytest.fixture
def new_osr_no_isrcs_event_input():
    """Create new OSR event input for testing."""
    return [
        {
            'sound_recording_id': 'mock-sr-id-1',
            'previous_version_id': None,
            'version_id': 'mock-version-id-1',
            'updated': True,
            'last_modified': '2023-12-11T17:54:02+00:00',
            'tracks_isrcs': []
        }
    ]


@pytest.fixture
def updated_osr_event_input():
    """Create updated OSR event input for testing."""
    return [
        {
            'sound_recording_id': 'mock-sr-id-1',
            'previous_version_id': 'mock-prev-version-id-1',
            'version_id': 'mock-version-id-1',
            'updated': True,
            'last_modified': '2023-12-11T17:54:02+00:00',
            'tracks_isrcs': ['MOCK-ISRC-1']
        }
    ]


@pytest.fixture
def sound_recording_metadata_track_level_carveouts():  # noqa: D103
    return {
        'track_connection': {
            'tracks': [
                _track_with_vendor_rules(
                    track_rules=[_rule('tiktok', 'US', 'carveout')],
                    vendor_rules=[_rule('tiktok', 'US', 'monetize')]
                ),
                _track_with_subaccount_rules(
                    track_rules=[
                        _rule('other_service', 'US', 'carveout'),
                        _rule('tiktok', 'DE', 'carveout'),
                        _rule('tiktok', 'US', 'carveout')
                    ],
                    subacc_rules=[_rule('tiktok', 'US', 'monetize')],
                    vendor_rules=[_rule('tiktok', 'DE', 'monetize')]
                )
            ]
        },
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def sound_recording_metadata_track_level_global_carveouts():  # noqa: D103
    return {
        'track_connection': {
            'tracks': [
                _track_with_vendor_rules(
                    track_rules=[_rule('tiktok', '*', 'carveout')],
                    vendor_rules=[_rule('tiktok', 'US', 'monetize')]
                )
            ]
        },
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def sound_recording_metadata_subaccount_level_carveouts():  # noqa: D103
    return {
        'track_connection': {
            'tracks': [
                _track_with_subaccount_rules(
                    track_rules=[
                        _rule('other_service', 'US', 'monetize'),
                        _rule('tiktok', 'DE', 'monetize')
                    ],
                    subacc_rules=[
                        _rule('tiktok', 'DE', 'carveout')
                    ],
                    vendor_rules=[
                        _rule('tiktok', 'DE', 'monetize')
                    ]
                )
            ]
        },
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def sound_recording_metadata_vendor_level_carveouts():  # noqa: D103
    return {
        'track_connection': {
            'tracks': [
                _track_with_vendor_rules(
                    track_rules=[
                        _rule('other_service', 'US', 'monetize'),
                        _rule('tiktok', 'DE', 'monetize')
                    ],
                    vendor_rules=[
                        _rule('tiktok', 'DE', 'carveout')
                    ]
                )
            ]
        },
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def sound_recording_metadata_incorrect_assets():  # noqa: D103
    return {
        'track_connection': {
            'tracks': [
                _track_with_vendor_rules(),
                _track_with_subaccount_rules(),
            ]
        },
        'assets': [_mock_incorrect_extension_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def sound_recording_metadata_no_assets():  # noqa: D103
    return {
        'track_connection': {
            'tracks': [
                _track_with_vendor_rules(),
                _track_with_subaccount_rules(),
            ]
        },
        'assets': [],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def delivery_history_query_result():
    """Mock response for delivery history query."""
    return {
        'deliveryHistoryByOsrIds': [
            {
                'orchardSoundRecording': {
                    'id': 'osr_id'
                },
                'orchardSoundRecordingVersion': {
                    'versionId': 'version-1'
                },
                'creationDate': '2025-07-29T11:20:11.913Z',
                'type': 'METADATA_UPDATE',
                'stepFunctionName': 'metadata-update-1-False'
            },
            {
                'orchardSoundRecording': {
                    'id': 'osr_id'
                },
                'orchardSoundRecordingVersion': {
                    'versionId': 'version-2'
                },
                'creationDate': '2025-07-30T13:24:03.763Z',
                'type': 'METADATA_UPDATE',
                'stepFunctionName': 'metadata-update-2-False'
            },
            {
                'orchardSoundRecording': {
                    'id': 'osr_id'
                },
                'orchardSoundRecordingVersion': {
                    'versionId': 'version-0'
                },
                'creationDate': '2025-07-23T10:51:28.714Z',
                'type': 'FULL_DELIVERY',
                'stepFunctionName': 'full-delivery-1-True'
            }
        ]
    }


@pytest.fixture
def sound_recording_metadata_empty():
    """Mock response for sound recording with no metadata."""
    return {
        'track_connection': {
            'tracks': []
        },
        'assets': [],
        'isrc': 'MOCK-ISRC-1'
    }


MOCK_PROHIBITED_AUDIO_ATTR_ID = 'mock-prohibited-audio-attr'
MOCK_PROHIBITED_RIGHTS_ATTR_ID = 'mock-prohibited-rights-attr'


@pytest.fixture
def sound_recording_metadata_with_audio_attribute():
    """Sound recording with a track that carries a mock audio attribute."""
    track = _track_with_vendor_rules(
        track_rules=[_rule('tiktok', 'US', 'monetize')],
        vendor_rules=[_rule('tiktok', 'US', 'monetize')]
    )
    track['audio_attributes'] = [_mock_track_audio_attribute(MOCK_PROHIBITED_AUDIO_ATTR_ID)]
    return {
        'track_connection': {'tracks': [track]},
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }


@pytest.fixture
def sound_recording_metadata_with_rights_attribute():
    """Sound recording with a track that carries a mock rights attribute."""
    track = _track_with_vendor_rules(
        track_rules=[_rule('tiktok', 'US', 'monetize')],
        vendor_rules=[_rule('tiktok', 'US', 'monetize')]
    )
    track['rights_attributes'] = [_mock_track_rights_attribute(MOCK_PROHIBITED_RIGHTS_ATTR_ID)]
    return {
        'track_connection': {'tracks': [track]},
        'assets': [_mock_asset()],
        'isrc': 'MOCK-SR-ISRC-1'
    }