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

import pytest
from ddex_ingester_common.lambda_exceptions import \
    SubmitProductGraphQLException
from lambdacommon.graphql import graphql

import index


@patch('index.submit_product')
def test_submit_product_called_with_args(mock_submit_product,
                                         context_label_procesing):
    """Test submit product is called for label_processing DDEX."""
    index.handler(context_label_procesing, None)

    product_id = 90210

    index.submit_product.assert_called_once()
    assert index.submit_product.mock_calls[0][1][1] == product_id


def test_submit_product_validation_fail(context_label_procesing,
                                        error_response):
    """Test submit product correctly raises an error for validation errors."""
    index.handle_validation_results_error = MagicMock()

    expected_side_effect = graphql.GraphQLError(error_response.get('errors'))

    index.submit_product = MagicMock(
        return_value=error_response,
        side_effect=expected_side_effect)

    index.handler(context_label_procesing, None)
    index.handle_validation_results_error.assert_called_once()


@patch('index.skip_content_submit')
def test_bypass_submit_for_in_content_ddex(mock_skip_submit,
                                           context_in_content):
    """Test that the handler skips submit when processing in_content DDEX."""
    context = index.StateMachineSchema().load(context_in_content)
    expected_return = index.StateMachineSchema().dump(context)

    mock_skip_submit.return_value = expected_return

    result = index.handler(context_in_content, None)
    assert result == expected_return
    mock_skip_submit.assert_called_once()


@patch('index.skip_content_submit')
@patch('index.submit_product')
@patch('index.delete_error_correction')
@patch('index.graphql_gateway')
def test_submit_in_content_with_error_correction(
        mock_graphql_gateway, mock_delete_error_correction,
        mock_submit_product, mock_skip_submit, context_in_content_with_ec):
    """Test that the handler submits when processing in_content with EC."""
    context = index.StateMachineSchema().load(context_in_content_with_ec)
    expected_return = index.StateMachineSchema().dump(context)
    mock_graphql_gateway.execute.return_value = {
        'data': {
            'product': {
                'releaseCorrection': {
                    'items': [
                        {
                            'releaseCorrectionDetailId': 4601218,
                            'tableName': 'releases',
                            'fieldName': 'release_name',
                            'keyId': 3446753,
                            'keyValue': '"Edited title"'
                        }
                    ]
                }
            }
        }
    }
    mock_skip_submit.return_value = expected_return

    result = index.handler(context_in_content_with_ec, None)
    assert result == expected_return
    mock_skip_submit.assert_not_called()
    mock_delete_error_correction.assert_not_called()
    mock_submit_product.assert_called_once()


@patch('index.skip_content_submit')
@patch('index.submit_product')
def test_bypass_submit_for_submitted_error_corrections(
        mock_submit_product, mock_skip_submit,
        context_in_content_submitted_ec):
    """Test that the handler skips submit for submitted error corrections."""
    context = index.StateMachineSchema().load(context_in_content_submitted_ec)
    expected_return = index.StateMachineSchema().dump(context)

    mock_skip_submit.return_value = expected_return

    result = index.handler(context_in_content_submitted_ec, None)
    assert result == expected_return
    mock_skip_submit.assert_called_once()


@patch('index.skip_content_submit')
@patch('index.submit_product')
@patch('index.graphql_gateway')
@patch('index.delete_error_correction')
def test_bypass_submit_for_error_correction_with_no_items(
        mock_delete_error_correction, mock_graphql_gateway,
        mock_submit_product, mock_skip_submit, context_in_content_with_ec):
    """Test that submit is bypassed for error corrections with no items."""
    context = index.StateMachineSchema().load(context_in_content_with_ec)
    expected_return = index.StateMachineSchema().dump(context)
    mock_graphql_gateway.execute.return_value = {
        'data': {
            'product': {
                'releaseCorrection': {
                    'items': []
                }
            }
        }
    }
    mock_skip_submit.return_value = expected_return

    result = index.handler(context_in_content_with_ec, None)

    assert result == expected_return
    mock_skip_submit.assert_called_once()
    mock_delete_error_correction.assert_called_once()
    mock_submit_product.assert_not_called()


@patch('index.skip_content_submit')
@patch('index.valid_product', return_value=False)
def test_invalid_video_product_raises_exception(
        mock_valid_product,
        mock_skip_submit,
        context_video_product):
    """Test that an invalid video raises exception."""
    context = index.StateMachineSchema().load(context_video_product)
    expected_return = index.StateMachineSchema().dump(context)

    mock_skip_submit.return_value = expected_return
    with pytest.raises(
            index.SubmitVideoProductValidationException) as e:
        index.handler(context_video_product, None)
    assert str(e.value) == 'Video Product invalid'


@patch('index.valid_product', return_value=True)
def test_valid_video_product_does_not_throw_exception(
        mock_valid_product,
        context_video_product):
    """Test that an valid video product does not throw an exception."""
    index.handler(context_video_product, None)
    mock_valid_product.assert_called_once()


@patch('index.valid_product', return_value=True)
def test_valid_product_not_called_for_non_video_products(
        mock_valid_product,
        context_in_content):
    """Test valid product function not called for non video products."""
    index.handler(context_in_content, None)
    mock_valid_product.assert_not_called()


def test_submit_product_graphql_fail(
        context_label_procesing,
        error_response):
    """Test submit product correctly raises an error for validation errors."""
    index.handle_validation_results_error = MagicMock()

    error_response['errors'][0]['extensions']['response']['status'] = 500
    expected_side_effect = graphql.GraphQLError(error_response['errors'])

    index.submit_product = MagicMock(
        return_value=error_response,
        side_effect=expected_side_effect)

    with pytest.raises(SubmitProductGraphQLException):
        index.handler(context_label_procesing, None)


def test_should_submit_in_content_video(context_video_product):
    """Test that should_submit skips submit for in content video."""
    context_video_product['product']['status'] = 'in_content'
    context = index.StateMachineSchema().load(context_video_product)
    assert not index.should_submit(context)


def test_should_submit_ttc_video(context_video_product):
    """Test that should_submit skips submit for in content video."""
    context_video_product['product']['status'] = 'transfer_to_content'
    context = index.StateMachineSchema().load(context_video_product)
    assert not index.should_submit(context)