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

from ddex_ingester_common.constants.catalog_ingestion import (
    REJECT,
    SUCCESS,
    WARNING,
)
from ddex_ingester_common.helpers.catalog_ingestion import (
    CatalogIngestionValidationResult
)
from index import (
    handler,
    save_validation_result,
    validate,
    ValidationRuleException
)
import pytest
from rules import RuleResult


@patch('index.get_all_release_models')
@patch('index.validate')
@patch('index.save_validation_result')
def test_handler(
        mock_save_validation_result,
        mock_validate,
        mock_get_all_release_models,
        test_multiple_releases_json,
        test_event):
    """Test the main handler."""
    test_event['pre_validate'] = True

    mock_get_all_release_models.return_value = test_multiple_releases_json

    mock_save_validation_result.return_value = [
        CatalogIngestionValidationResult(
            state_machine_name='name',
            state_machine_execution_name='execution_name',
            response=SUCCESS
        )]
    handler(test_event, None)
    mock_validate.assert_called_once()
    mock_save_validation_result.assert_called_once()


@patch('index.get_all_release_models')
@patch('index.validate')
@patch('index.save_validation_result')
def test_handler_warning(
        mock_save_validation_result,
        mock_validate,
        mock_get_all_release_models,
        test_multiple_releases_json,
        test_event):
    """Test the main handler handling a warning."""
    test_event['pre_validate'] = True

    mock_get_all_release_models.return_value = test_multiple_releases_json

    mock_save_validation_result.return_value = [
        CatalogIngestionValidationResult(
            state_machine_name='name',
            state_machine_execution_name='execution_name',
            response=WARNING,
            validation_rule_id=41,
            message='Some helpful validation rule message'
        )]
    # A warning should not make the handler throw an exception.
    handler(test_event, None)
    mock_validate.assert_called_once()
    mock_save_validation_result.assert_called_once()


@patch('index.get_all_release_models')
@patch('index.validate')
@patch('index.save_validation_result')
def test_handler_reject_rule(
        mock_save_validation_result,
        mock_validate,
        mock_get_all_release_models,
        test_event):
    """Test the main handler dealing with exception."""
    test_event['pre_validate'] = True

    mock_save_validation_result.return_value = [
        CatalogIngestionValidationResult(
            state_machine_name='name',
            state_machine_execution_name='execution_name',
            response=REJECT,
            validation_rule_id=41,
            message='Some helpful validation rule message'
        )]

    with pytest.raises(ValidationRuleException):
        handler(test_event, None)
        mock_validate.assert_called_once()
        mock_save_validation_result.assert_called_once()


def test_validate(test_event):
    """Test the validate function against a 'successful' rule."""
    rule = [(lambda input, logger: RuleResult(122, SUCCESS, None))]
    output = validate(test_event, rule, 123)
    assert output[0] == rule[0](test_event, MagicMock())


def test_validate_with_rejected_rule(test_event):
    """Test the validate function against a 'rejected' rule."""
    rule = [
        (lambda input, logger: RuleResult(123, REJECT, 'Something is not correct'))  # noqa: E501
    ]
    output = validate(test_event, rule, 123)
    assert output[0] == rule[0](test_event, MagicMock())


def test_validate_with_multiple_rejected_rule(test_event):
    """Test the validate function against multiple 'failed' rules."""
    rule = [
        (lambda input, logger: RuleResult(122, SUCCESS, None)),
        (lambda input, logger: RuleResult(123, REJECT, 'Something is not correct')),  # noqa: E501
        (
            lambda input, logger: RuleResult(
                124, REJECT, 'Something ELSE is not correct')
        )
    ]

    output = validate(test_event, rule, 123)
    assert len(output) == 3
    assert output[0] == rule[0](test_event, MagicMock())
    assert output[1] == rule[1](test_event, MagicMock())
    assert output[2] == rule[2](test_event, MagicMock())


@patch('index.config')
def test_save_validation_result(
        mock_config):
    """Test save validation result."""
    mock_config.catalog_ingestion_session = MagicMock()

    state_machine_name = 'state-machine'
    execution_name = 'state-machine-execution-123'

    validation_results = [
        RuleResult(123, REJECT, 'Something is not correct'),
        RuleResult(124, REJECT, 'Something ELSE is not correct')
    ]
    expected_output = [
        CatalogIngestionValidationResult(
            state_machine_name=state_machine_name,
            state_machine_execution_name=execution_name,
            validation_rule_id=validation_results[0].validation_rule_id,
            response=validation_results[0].response,
            message=validation_results[0].message
        ),
        CatalogIngestionValidationResult(
            state_machine_name=state_machine_name,
            state_machine_execution_name=execution_name,
            validation_rule_id=validation_results[1].validation_rule_id,
            response=validation_results[1].response,
            message=validation_results[1].message
        ),
    ]
    output = save_validation_result(
        validation_results,
        state_machine_name,
        execution_name
    )
    assert output == expected_output
    mock_config.catalog_ingestion_session.add.assert_called_once_with(
        expected_output
    )
    mock_config.catalog_ingestion_session.save.assert_called_once()


@patch('index.config')
def test_save_validation_result_mixed_warnings(
        mock_config):
    """Test save validation result."""
    mock_config.catalog_ingestion_session = MagicMock()

    state_machine_name = 'state-machine'
    execution_name = 'state-machine-execution-123'

    validation_results = [
        RuleResult(122, WARNING, 'A warning to be aware of'),
        RuleResult(123, REJECT, 'Something is not correct'),
        RuleResult(124, REJECT, 'Something ELSE is not correct')
    ]

    expected_output = [
        CatalogIngestionValidationResult(
            state_machine_name=state_machine_name,
            state_machine_execution_name=execution_name,
            validation_rule_id=validation_results[0].validation_rule_id,
            response=validation_results[0].response,
            message=validation_results[0].message
        ),
        CatalogIngestionValidationResult(
            state_machine_name=state_machine_name,
            state_machine_execution_name=execution_name,
            validation_rule_id=validation_results[1].validation_rule_id,
            response=validation_results[1].response,
            message=validation_results[1].message
        ),
        CatalogIngestionValidationResult(
            state_machine_name=state_machine_name,
            state_machine_execution_name=execution_name,
            validation_rule_id=validation_results[2].validation_rule_id,
            response=validation_results[2].response,
            message=validation_results[2].message
        ),
    ]
    output = save_validation_result(
        validation_results,
        state_machine_name,
        execution_name
    )
    assert output == expected_output
    mock_config.catalog_ingestion_session.add.assert_called_once_with(
        expected_output
    )
    mock_config.catalog_ingestion_session.save.assert_called_once()


@patch('index.config')
def test_save_validation_result_on_success(
        mock_config):
    """Test save validation result."""
    mock_config.catalog_ingestion_session = MagicMock()

    state_machine_name = 'state-machine'
    execution_name = 'state-machine-execution-123'

    validation_results = [
        RuleResult(1, SUCCESS, None)
    ]

    expected_output = [CatalogIngestionValidationResult(
        state_machine_name=state_machine_name,
        state_machine_execution_name=execution_name,
        validation_rule_id=1,
        response=SUCCESS,
        message=None
    )]
    output = save_validation_result(
        validation_results,
        state_machine_name,
        execution_name
    )
    assert output == expected_output
    mock_config.catalog_ingestion_session.add.assert_called_once_with(
        expected_output
    )
    mock_config.catalog_ingestion_session.save.assert_called_once()