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

from ddex_ingester_common.constants.catalog_ingestion import FAILURE, SKIP
from index import handler, write_catalog_ingestion


@patch('index.logger')
@patch('index.write_catalog_ingestion')
@patch('index.StateMachineSchema')
@patch('index.update_ddex_ingest_status')
def test_handler(
        mock_update_ddex_ingest_status,
        mock_state_machine_schema,
        mock_write_catalog_ingestion,
        mock_current_logger,
        context,
        deserialized_context
):
    """Test the main handler."""
    mock_state_machine_schema.return_value.load = (
        lambda _: deserialized_context)
    expected_status = context['status']
    output = handler(context, None)

    mock_write_catalog_ingestion.assert_called_once_with(
        deserialized_context,
        expected_status,
        None,
    )
    assert output


@patch('index.logger')
@patch('index.write_catalog_ingestion')
@patch('index.StateMachineSchema')
@patch('index.update_ddex_ingest_status')
def test_handler_failure(
        mock_update_ddex_ingest_status,
        mock_state_machine_schema,
        mock_write_catalog_ingestion,
        mock_current_logger,
        context,
        deserialized_context
):
    """Test the main handler with a failure status."""
    mock_state_machine_schema.return_value.load = (
        lambda _: deserialized_context)
    context['status'] = FAILURE
    expected_status = context['status']
    error_message = str(context['context']['errors'])

    output = handler(context, None)

    mock_write_catalog_ingestion.assert_called_once_with(
        deserialized_context,
        expected_status,
        error_message
    )
    assert output


@patch('index.logger')
@patch('index.write_catalog_ingestion')
@patch('index.StateMachineSchema')
@patch('index.update_ddex_ingest_status')
def test_handler_skip(
        mock_update_ddex_ingest_status,
        mock_state_machine_schema,
        mock_write_catalog_ingestion,
        mock_current_logger,
        context,
        deserialized_context
):
    """Test the main handler with a skipped status."""
    mock_state_machine_schema.return_value.load = (
        lambda _: deserialized_context)
    context['status'] = SKIP

    output = handler(context, None)

    mock_update_ddex_ingest_status.assert_called_once_with(
        777,
        'skipped'
    )
    assert output


@patch('index.config')
@patch('index.CatalogIngestion')
def test_write_catalog_ingestion(mock_catalog_ingestion,
                                 mock_config, deserialized_context):
    """Test write catalog ingestion pulls data from context and saves."""
    mock_config.catalog_ingestion_session = MagicMock()
    status = 'Success'
    error_message = str(deserialized_context.errors)

    write_catalog_ingestion(deserialized_context, status, error_message)

    mock_catalog_ingestion.assert_called_once_with(
        state_machine_name=deserialized_context.state_machine_name,
        state_machine_execution_name=deserialized_context.execution_name,
        catalog_ingestion_source_id=1,
        s3_bucket_name=deserialized_context.bucket,
        s3_key_name=deserialized_context.key,
        ingest_format='ddex',
        timestamp=deserialized_context.execution_start_time,
        vendor_id=deserialized_context.product.vendor_id,
        subaccount_id=deserialized_context.product.subaccount_id,
        status=status,
        error_message=error_message,
    )
    mock_config.catalog_ingestion_session.add.assert_called_once()
    mock_config.catalog_ingestion_session.save.assert_called_once()


@patch('index.logger')
@patch('index.write_catalog_ingestion')
@patch('index.StateMachineSchema')
@patch('index.update_ddex_ingest_status')
def test_handler_soft_deleted(
        mock_update_ddex_ingest_status,
        mock_state_machine_schema,
        mock_write_catalog_ingestion,
        mock_current_logger,
        purged_release_context,
        deserialized_purged_context
):
    """Test the main handler with a soft_deleted status."""
    mock_state_machine_schema.return_value.load = (
        lambda _: deserialized_purged_context)

    output = handler(purged_release_context, None)

    mock_update_ddex_ingest_status.assert_called_once_with(
        9997,
        'soft_deleted'
    )
    assert output


@patch('index.logger')
@patch('index.write_catalog_ingestion')
@patch('index.StateMachineSchema')
@patch('index.update_ddex_ingest_status')
def test_handler_soft_delete_failed(
        mock_update_ddex_ingest_status,
        mock_state_machine_schema,
        mock_write_catalog_ingestion,
        mock_current_logger,
        purged_release_context,
        deserialized_purged_context
):
    """Test the main handler with a soft_delete_failed status."""
    mock_state_machine_schema.return_value.load = (
        lambda _: deserialized_purged_context)

    purged_release_context['status'] = FAILURE

    output = handler(purged_release_context, None)

    mock_update_ddex_ingest_status.assert_called_once_with(
        9997,
        'soft_delete_failed'
    )
    assert output