"""Test for Kafka Producer."""

import json
from unittest.mock import patch

import pytest

from config import KAFKA_KEY_FIELD_IN_DOC, KAFKA_TARGET_TOPICS
from utils.kafka_producer import write_to_kafka


@pytest.mark.parametrize('domain,expected_call_count', [
    ('releases', 1),
    ('tracks', 1),
    ('dummy', 0),  # invalid value
    ('labels', 0),  # valid but not mapped to any kafka topic.
])
def test_write_to_kafka_diff_domains(
    domain, expected_call_count, kafka_mock, product_cloudsearch_document,
    track_cloudsearch_document
):
    """Test Kafka Producing message for different domains."""
    messages = [product_cloudsearch_document]
    if domain == 'tracks':
        messages = [track_cloudsearch_document]

    write_to_kafka(domain, messages)
    kafka_mock.assert_call_count('produce', expected_call_count)


@patch('utils.kafka_producer.logger')
def test_write_to_kafka_missing_key(logger_mock, kafka_mock, track_cloudsearch_document):
    """Test Kafka Producing message for different domains."""
    del track_cloudsearch_document.get('fields')['track_unique_id']
    messages = [track_cloudsearch_document]

    write_to_kafka('tracks', messages)
    kafka_mock.assert_call_count('produce', 0)
    assert logger_mock.error.call_count == 1


@patch('utils.kafka_producer.logger')
@pytest.mark.parametrize('doc_type,domain,expected_call_count,has_value', [
    ('add', 'releases', 1, True),
    ('delete', 'releases', 1, False),
    ('dummy', 'releases', 0, False),  # invalid doc_type
    ('add', 'tracks', 0, False)  # track domain with product data will fail
])
def test_write_to_kafka_releases(
    logger_mock, doc_type, domain, expected_call_count, has_value,
    kafka_mock,
    product_cloudsearch_document
):
    """Test Kafka Producing message with diff parameters."""
    product_cloudsearch_document['type'] = doc_type
    messages = [product_cloudsearch_document]
    value = json.dumps(product_cloudsearch_document.get('fields')).encode() \
        if has_value else None
    message_key = KAFKA_KEY_FIELD_IN_DOC.get(domain)
    key = str(
        product_cloudsearch_document.get('fields').get(message_key)).encode()

    write_to_kafka(domain, messages)
    kafka_mock.assert_call_count('produce', expected_call_count)
    if expected_call_count > 0:
        kafka_mock.assert_messages([{
            'topic': KAFKA_TARGET_TOPICS.get('releases'),
            'value': value,
            'key': key
        }])
    else:
        assert logger_mock.error.call_count == 1


@patch('utils.kafka_producer.logger')
@pytest.mark.parametrize('doc_type,domain,expected_call_count,has_value', [
    ('add', 'tracks', 1, True),
    ('delete', 'tracks', 1, False),
    ('dummy', 'tracks', 0, False),  # invalid doc_type
    ('add', 'projects', 0, False)  # projects domain with tracks data will fail
])
def test_write_to_kafka_tracks(
    logger_mock, doc_type, domain, expected_call_count, has_value,
    kafka_mock,
    track_cloudsearch_document
):
    """Test Kafka Producing message for tracks with diff parameters."""
    track_cloudsearch_document['type'] = doc_type
    messages = [track_cloudsearch_document]
    value = json.dumps(track_cloudsearch_document.get('fields')).encode() \
        if has_value else None
    message_key = KAFKA_KEY_FIELD_IN_DOC.get(domain)
    key = str(
        track_cloudsearch_document.get('fields').get(message_key)).encode()

    write_to_kafka(domain, messages)
    kafka_mock.assert_call_count('produce', expected_call_count)
    if expected_call_count > 0:
        kafka_mock.assert_messages([{
            'topic': KAFKA_TARGET_TOPICS.get('tracks'),
            'value': value,
            'key': key
        }])
    else:
        assert logger_mock.error.call_count == 1


@patch('utils.kafka_producer.logger')
@pytest.mark.parametrize('doc_type,domain,expected_call_count,has_value', [
    ('add', 'projects', 1, True),
    ('delete', 'projects', 1, False),
    ('dummy', 'projects', 0, False),  # invalid doc_type
    ('add', 'tracks', 0, False)  # tracks domain with projects data will fail
])
def test_write_to_kafka_projects(
    logger_mock, doc_type, domain, expected_call_count, has_value,
    kafka_mock,
    project_cloudsearch_document
):
    """Test Kafka Producing message for projects with diff parameters."""
    project_cloudsearch_document['type'] = doc_type
    messages = [project_cloudsearch_document]
    value = json.dumps(project_cloudsearch_document.get('fields')).encode() \
        if has_value else None
    message_key = KAFKA_KEY_FIELD_IN_DOC.get(domain)
    key = str(
        project_cloudsearch_document.get('fields').get(message_key)).encode()

    write_to_kafka(domain, messages)
    kafka_mock.assert_call_count('produce', expected_call_count)
    if expected_call_count > 0:
        kafka_mock.assert_messages([{
            'topic': KAFKA_TARGET_TOPICS.get('projects'),
            'value': value,
            'key': key
        }])
    else:
        assert logger_mock.error.call_count == 1