"""Lambda test module."""

from unittest.mock import MagicMock
from unittest.mock import NonCallableMagicMock
from unittest.mock import patch

from content_utils.exceptions import IneligibleEventError
from content_utils.exceptions import InvalidProductException
from content_utils.exceptions import NoProductDataException
from content_utils.exceptions import NoReviewQueueItemDataException
from openmock import openmock
from opensearchpy.exceptions import NotFoundError as OpenSearchNotFoundError
import pytest

app_content_lambda_logger = NonCallableMagicMock(set_data=MagicMock())


@openmock
@patch('src.app.index_product')
def test_handler(mock_update, mock_event):
    """Test handler function."""
    from src import app
    result = app.handler(mock_event, None)
    assert result == {'status': 'success'}


@openmock
@pytest.mark.parametrize(
    ('test_description', 'exception_to_skip', 'mock_error_msg'), [
        ('skip ineligible event', IneligibleEventError('msg 1'), 'msg 1'),
        ('skip invalid product', InvalidProductException('msg 2'), 'msg 2'),
        ('skip no product data', NoProductDataException('msg 3'), 'msg 3'),
        ('skip no review queue item data', NoReviewQueueItemDataException('msg 4'), 'msg 4')
    ]
)
@patch('src.app.index_product')
def test_handler_skip(
    mock_update, test_description, exception_to_skip, mock_error_msg, mock_event, mocker
):
    """Test handler function error."""
    from src import app
    mocker.patch.object(
        app,
        'lambda_logger',
        new=app_content_lambda_logger,
    )
    mock_update.side_effect = exception_to_skip
    app.handler(mock_event, None)
    app.lambda_logger.set_data.assert_called_with(status='skip', result=mock_error_msg)


@openmock
@patch('src.app.index_product')
def test_handler_error(mock_update, mock_event):
    """Test handler function error."""
    from src import app
    mock_update.side_effect = Exception('foo')
    with pytest.raises(Exception) as e:
        app.handler(mock_event, None)
    assert e.value.args[0] == 'foo'


@patch('src.logic.indexing.graphql_connector.get_indexable_product')
def test_indexing_product(mock_getter, mock_row_data, mock_index_document):
    """Test indexing a product."""
    mock_getter.return_value = mock_index_document
    from src.logic.indexing import add_to_index
    add_to_index(mock_row_data)
    from src.logic.indexing import os_connector
    with pytest.raises(IneligibleEventError):
        os_connector.check_product_existing_status(mock_row_data, 'not found')


@openmock
@patch('src.logic.indexing.os_connector.os')
@patch('src.logic.indexing.graphql_connector.get_indexable_product')
def test_indexing_product_success(mock_get_product, mock_os,
                                  mock_index_document, mock_row_data):
    """Test indexing a product."""
    from src.logic.indexing import add_to_index
    mock_get_product.return_value = mock_index_document
    mock_os.get.side_effect = MagicMock(side_effect=OpenSearchNotFoundError)

    mock_os.index.return_value = {
        'result': 'created',
        'created': mock_index_document
    }

    add_to_index(mock_row_data)
    mock_os.get.assert_called_once()
    mock_get_product.assert_called_once_with({
        'product_id': mock_row_data.get('product_id'),
        'added_at': mock_row_data.get('created_datetime'),
        'review_queue_id': mock_row_data.get('id')
    })
    mock_os.index.asssert_called_once_with(mock_index_document)


@openmock
@patch('src.logic.indexing.os_connector.os')
@patch('src.logic.indexing.graphql_connector.get_indexable_product')
def test_indexing_product_failure(
        mock_get_product, mock_os, mock_index_document, mock_row_data):
    """Test indexing a product when it already exists in the queue."""
    from src.logic.indexing import add_to_index
    mock_get_product.return_value = mock_index_document
    mock_os.get.return_value = {
        'found': True,
        '_source': mock_index_document
    }
    mock_os.index.return_value = {
        'result': 'created',
        'created': mock_index_document
    }

    with pytest.raises(IneligibleEventError) as err:
        add_to_index(mock_row_data)
    assert 'Product already in queue: queue id: 1 product id: 1' in str(err)

    mock_os.get.assert_called_once()
    mock_get_product.assert_not_called()
    mock_os.index.assert_not_called()