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

import pytest
from ddex_ingester_common.release_correction.release_correction_constants import \
    RELEASE_CORRECTION_PRODUCT_ARTIST_FIELDS as RC_ARTIST_FIELDS  # noqa
from ddex_ingester_common.schemas.s3_schema import S3Schema
from ddex_ingester_common.schemas.state_machine_schema import \
    StateMachineSchema

import index
from constants import queries


@patch('index.logger')
@patch('index.graphql_gateway.execute')
@patch('index.load_ddex_json')
@patch('index.create_release_correction',
       wraps=index.create_release_correction)
@patch('index.load_rc_json')
@patch('index.write_rc_json')
@patch('index.create_release_correction_details')
def test_handler_create_release_correction(
        mock_create_detail,
        mock_write_rc_json,
        mock_load_rc_json,
        mock_create_release_correction,
        mock_load_ddex_json,
        mock_graphql_execute,
        mock_current_logger,
        s3_ddex,
        context):
    """Test the main handler when creating an error correction."""
    mock_logger = MagicMock(name='info')
    mock_current_logger.return_value = mock_logger

    product_id = 234324
    release_correction_id = 287202

    mock_load_ddex_json.return_value = s3_ddex

    mock_graphql_execute.side_effect = [
        {
            'data': {
                'productByUpc': {
                    'status': 'in_content',
                    'displayStatus': 'completed',
                    'saleStartDate': '2021-02-19',
                    'vendorId': 123,
                    'subaccountId': 999,
                    'productId': product_id,
                    'product_name': 'Test Artist',
                    'tracks': [{
                        'tuid': '32279606',
                        'isrc': 'QZCDB2000002'
                    }],
                    'label': {
                        'name': 'TVT Records'
                    },
                    'notForDistribution': 'N',
                    'releaseCorrection': None,
                    'releaseDate': '2016-01-01',
                },
            }
        },
        {
            'data': {
                'createProductCorrection': {
                    'releaseCorrectionId': release_correction_id
                },
            }
        }
    ]

    expected_error_correction = {
        'release_id': product_id,
        'release_correction_id': release_correction_id,
        'items': []
    }

    context['product']['display_status'] = 'in_content'
    response = index.handler(context, None)

    mock_create_release_correction.assert_called_once()
    assert response.get('error_correction') == expected_error_correction


@patch('index.logger')
@patch('index.graphql_gateway.execute')
@patch('index.load_ddex_json')
@patch('index.create_release_correction',
       wraps=index.create_release_correction)
@patch('index.unsubmit_product', wraps=index.unsubmit_product)
@patch('index.load_rc_json')
@patch('index.write_rc_json')
@patch('index.create_release_correction_details')
def test_handler_encountering_active_release_correction(
        mock_create_detail,
        mock_write_rc_json,
        mock_load_rc_json,
        mock_unsubmit_product,
        mock_create_release_correction,
        mock_load_ddex_json,
        mock_graphql_execute,
        mock_current_logger,
        s3_ddex,
        context):
    """Test the main handler encountering active release correction."""
    mock_logger = MagicMock(name='info')
    mock_current_logger.return_value = mock_logger

    product_id = 234324
    release_correction_id = 287202

    mock_load_ddex_json.return_value = s3_ddex

    mock_graphql_execute.return_value = {
        'data': {
            'productByUpc': {
                'status': 'in_content',
                'displayStatus': 'error_correction',
                'saleStartDate': '2021-02-19',
                'vendorId': 123,
                'subaccountId': 999,
                'productId': product_id,
                'product_name': 'Test Artist',
                'tracks': [{
                    'tuid': '32279606',
                    'isrc': 'QZCDB2000002'
                }],
                'label': {
                    'name': 'TVT Records'
                },
                'notForDistribution': 'N',
                'releaseCorrection': {
                    'releaseId': product_id,
                    'releaseCorrectionId': release_correction_id
                },
                'releaseDate': '2016-01-01',
            }
        }
    }

    expected_error_correction = {
        'release_id': product_id,
        'release_correction_id': release_correction_id,
        'items': []
    }

    context['product']['display_status'] = 'error_correction'
    response = index.handler(context, None)

    mock_create_release_correction.assert_not_called()
    mock_unsubmit_product.assert_not_called()
    assert response.get('error_correction') == expected_error_correction


@patch('index.logger')
@patch('index.graphql_gateway.execute')
@patch('index.load_ddex_json')
@patch('index.create_release_correction',
       wraps=index.create_release_correction)
@patch('index.unsubmit_product')
@patch('index.load_rc_json')
@patch('index.write_rc_json')
@patch('index.create_release_correction_details')
def test_handler_encountering_submitted_release_correction(
        mock_create_detail,
        mock_write_rc_json,
        mock_load_rc_json,
        mock_unsubmit_product,
        mock_create_release_correction,
        mock_load_ddex_json,
        mock_graphql_execute,
        mock_current_logger,
        s3_ddex,
        context):
    """Test the main handler encountering submitted release correction."""
    mock_logger = MagicMock(name='info')
    mock_current_logger.return_value = mock_logger

    product_id = 234324
    release_correction_id = 287202

    mock_load_ddex_json.return_value = s3_ddex

    mock_graphql_execute.return_value = {
        'data': {
            'productByUpc': {
                'status': 'in_content',
                'displayStatus': 'error_correction',
                'saleStartDate': '2021-02-19',
                'vendorId': 123,
                'subaccountId': 999,
                'productId': product_id,
                'product_name': 'Test Artist',
                'tracks': [{
                    'tuid': '32279606',
                    'isrc': 'QZCDB2000002'
                }],
                'label': {
                    'name': 'TVT Records'
                },
                'notForDistribution': 'N',
                'releaseCorrection': {
                    'releaseId': product_id,
                    'releaseCorrectionId': release_correction_id
                },
                'releaseDate': '2016-01-01',
            }
        }
    }

    expected_error_correction = {
        'release_id': product_id,
        'release_correction_id': release_correction_id,
        'items': []
    }

    context['product']['display_status'] = 'submitted'
    response = index.handler(context, None)

    mock_create_release_correction.assert_not_called()
    mock_unsubmit_product.assert_called_once()
    assert response.get('error_correction') == expected_error_correction
    assert response['product'].get('display_status') == 'error_correction'


@patch('index.logger')
@patch('index.graphql_gateway.execute')
@patch('index.load_ddex_json')
@patch('index.create_release_correction',
       wraps=index.create_release_correction)
@patch('index.load_rc_json')
@patch('index.write_rc_json')
@patch('index.create_release_correction_details')
@patch('index.should_create_release_correction', return_value=True)
def test_handler_create_release_correction_for_swb_dummy_asset_update(
        mock_should_create_release_correction,
        mock_create_detail,
        mock_write_rc_json,
        mock_load_rc_json,
        mock_create_release_correction,
        mock_load_ddex_json,
        mock_graphql_execute,
        mock_current_logger,
        s3_ddex,
        context,
        get_product_by_upc_response):
    """Test the main handler for SWBDUMMY products that contain assets."""
    mock_logger = MagicMock(name='info')
    mock_current_logger.return_value = mock_logger
    mock_load_ddex_json.return_value = s3_ddex
    release_correction_id = 287202

    mock_graphql_execute.side_effect = [
        get_product_by_upc_response,
        {
            'data': {
                'createProductCorrection': {
                    'releaseCorrectionId': release_correction_id
                },
            }
        }
    ]

    context['product']['not_for_distribution'] = 'SwitchboardDummy'
    index.handler(context, None)

    mock_create_release_correction.assert_called_once()
    mock_create_detail.assert_not_called()


@pytest.mark.parametrize('rc_details, expected', [
    ([['one', 'two', 'three', 'four', 'five', True, False],
     ['one', 'two', 'three', 'four', 'five', True, False]], 2),
    ([], 0)])
def test_remove_processed_details(rc_details, expected):
    """Test remove_processed_details method."""
    rc = index.remove_processed_details(rc_details)

    assert len(rc) == expected


@patch('index.graphql_gateway.execute')
@patch('index.write_rc_json')
def test_create_release_correction_details(
        mock_write_json,
        mock_graphql_execute,
        context,
        s3_ddex,
        multiple_rc_details):
    """Test create_release_correction_details method."""
    mock_rc = {'release_correction_id': 123, 'release_id': 999, 'items': []}
    context['error_correction'] = mock_rc
    context = StateMachineSchema().load(context)
    s3_data = S3Schema().load(s3_ddex)

    write_to_s3 = {
        'changes': []
    }

    event_details = {
        'bucket': 'ddex-bucket',
        'key': 'key'
    }

    rc_payload = {
        'productId': 234324,
        'releaseCorrectionId': 123,
        'corrections': [
            {
                'tableName': 'releases',
                'fieldName': 'c_line',
                'keyValue': '"c_line"'
            },
            {
                'tableName': 'releases',
                'fieldName': 'genre_id',
                'keyValue': '2'
            },
            {
                'tableName': 'releases',
                'fieldName': 'release_subgenre',
                'keyValue': '[327]'
            },
            {
                'tableName': 'releases',
                'fieldName': 'performer',
                'keyValue': '[{"role": "performer", "artist_name": "perf1"}, {"role": "performer", "artist_name": "perf2"}]'  # noqa
            },
            {
                'tableName': 'releases',
                'fieldName': 'featuring',
                'keyValue': '[{"role": "featuring", "artist_name": "feat"}]'
            },
            {
                'tableName': 'releases',
                'fieldName': 'producer',
                'keyValue': '[{"role": "producer", "artist_name": "prod"}]'
            },
        ]
    }

    index.create_release_correction_details(
        context, s3_data, multiple_rc_details)

    mock_write_json.assert_called_with(event_details, write_to_s3)
    mock_graphql_execute.assert_called_with(
        queries.CREATE_PRODUCT_CORRECTION_DETAIL, rc_payload)


@patch('index.graphql_gateway.execute')
@patch('index.write_rc_json')
def test_create_release_correction_details_no_details(
        mock_write_json,
        mock_graphql_execute,
        context,
        s3_ddex):
    """Test create_release_correction_details method with no RC Details."""
    context = StateMachineSchema().load(context)
    s3_data = S3Schema().load(s3_ddex)

    no_rc_details = {
        'changes': []
    }

    index.create_release_correction_details(
        context, s3_data, no_rc_details)

    mock_write_json.assert_not_called()
    mock_graphql_execute.assert_not_called()


@pytest.mark.parametrize('status, expected', [
    ('in_content', True),
    ('in_progress', False)])
def test_should_create_release_correction_by_status(
        context, s3_ddex, status, expected):
    """Test should_create_release_correction method."""
    context = StateMachineSchema().load(context)
    s3_data = S3Schema().load(s3_ddex)
    context.product.status = status
    response = index.should_create_release_correction(context, s3_data)
    assert response is expected


@pytest.mark.parametrize('nfd, expected', [
    ('N', True),
    ('SwitchboardDummy', False)])
def test_should_create_release_correction_by_nfd(
        context, s3_ddex, nfd, expected):
    """Test should_create_release_correction method."""
    context = StateMachineSchema().load(context)
    s3_data = S3Schema().load(s3_ddex)
    context.product.not_for_distribution = nfd
    response = index.should_create_release_correction(context, s3_data)
    assert response is expected


@pytest.mark.parametrize('asset, expected', [
    ('artwork', True),
    ('track', True)])
def test_should_create_release_correction_by_asset(
        context, s3_ddex, asset, expected):
    """Test should_create_release_correction method."""
    context = StateMachineSchema().load(context)
    s3_data = S3Schema().load(s3_ddex)

    s3_data.tracks[0].asset = {'testData': False}

    s3_data.tracks[0].asset = asset
    s3_data.product.artwork = not asset

    context.product.not_for_distribution = asset
    response = index.should_create_release_correction(context, s3_data)
    assert response is expected


def test_get_product_metadata():
    """Test get_product_metadata method."""
    assert True


def test_check_genre_required_fields(s3_ddex):
    """Test check_genre_required_fields."""
    s3_data = S3Schema().load(s3_ddex)
    fields = {**RC_ARTIST_FIELDS}

    index.check_genre_required_fields(fields, s3_data.product.genres)

    assert fields != RC_ARTIST_FIELDS


def test_check_genre_required_fields_classical(s3_ddex):
    """Test check_genre_required_fields."""
    s3_ddex['product']['genres'] = [{
        'subgenre': None,
        'genre': 'CLASSICAL-00'
    }]
    s3_data = S3Schema().load(s3_ddex)
    fields = {**RC_ARTIST_FIELDS}

    index.check_genre_required_fields(fields, s3_data.product.genres)

    assert fields == RC_ARTIST_FIELDS