"""Lambda test module."""

from unittest.mock import patch

from content_utils.exceptions import InvalidMessageException
import pytest

from src import app
from src import constants


def test_validate_product_logic_when_payload_is_none():
    """Test validate_product_logic raises when payload is None."""
    with pytest.raises(InvalidMessageException) as exc:
        app.validate_product_logic(None)

    assert str(exc.value) == constants.ERROR_MISSING_METADATA


@patch('src.app.validate')
def test_validate_product_logic_calls_validate(mock_validate):
    """Test validate_product_logic calls validate.validate_product."""
    payload = {'special_instructions': 'test'}
    mock_validate.validate_product.return_value = {
        'is_valid': True,
        'failed_validations': {}
    }

    result = app.validate_product_logic(payload)

    mock_validate.validate_product.assert_called_once_with(payload)
    assert result == {'is_valid': True, 'failed_validations': {}}


@patch('src.app.validate')
@patch('src.app.lambda_logger')
def test_handler_success_with_valid_product(mock_logger, mock_validate):
    """Test handler with valid product."""
    product_metadata = {
        'label': {
            'service_tier': {
                'name': 'tier-2'
            }
        },
        'validation': {
            'errors': []
        },
        'release_correction': 'None',
        'review_history': {
            'totalCount': 0
        },
        'special_instructions': 'None',
        'version': 'None'
    }
    event = {
        'data': {
            'review_queue_id': 12345,
            'product_id': 67890,
            'product_metadata': product_metadata
        }
    }
    mock_validate.validate_product.return_value = {
        'is_valid': True,
        'failed_validations': {}
    }

    result = app.handler(event, None)

    assert result == {
        'validations': constants.PASS,
        'failed_validations': {}
    }
    mock_logger.set_data.assert_any_call(queue_id=12345, product_id=67890)
    mock_logger.set_data.assert_any_call(
        status='success',
        result=constants.SUCCESS_VALIDATION_COMPLETE
    )
    mock_logger.end.assert_called_once()


@patch('src.app.validate')
@patch('src.app.lambda_logger')
def test_handler_success_with_invalid_product(mock_logger, mock_validate):
    """Test handler with invalid product."""
    product_metadata = {
        'label': {
            'service_tier': {
                'name': 'tier-1'
            }
        },
        'validation': {
            'errors': [{'level': 'errors', 'code': 'ERROR'}],
            'warnings': [{'level': 'warning', 'code': 'WARNING'}]
        },
        'release_correction': 'pending',
        'review_history': {
            'totalCount': 3
        },
        'special_instructions': 'Some instructions',
        'version': 'Version notes'
    }
    event = {
        'data': {
            'review_queue_id': 12345,
            'product_id': 67890,
            'product_metadata': product_metadata
        }
    }
    failed_validations = {
        'label.service_tier.name': 'Account is Tier 1 or Premium Services.',
        'validation.errors': 'Product has metadata errors.',
        'validation.warnings': 'Product has metadata warnings.',
        'review_history.totalCount': 'Product has been submitted more than once.',
        'special_instructions': 'Product has special instructions.',
        'version': 'Product has version notes.'
    }
    mock_validate.validate_product.return_value = {
        'is_valid': False,
        'failed_validations': failed_validations
    }

    result = app.handler(event, None)

    assert result == {
        'validations': constants.FAIL,
        'failed_validations': failed_validations
    }
    mock_logger.set_data.assert_any_call(
        status='success',
        result=constants.SUCCESS_VALIDATION_COMPLETE
    )
    mock_logger.end.assert_called_once()


@patch('src.app.validate')
@patch('src.app.lambda_logger')
def test_handler_with_none_payload(mock_logger, mock_validate):
    """Test handler raises when payload is None."""
    event = {
        'data': {
            'review_queue_id': 12345,
            'product_id': 67890,
            'product_metadata': None
        }
    }

    with pytest.raises(InvalidMessageException) as exc:
        app.handler(event, None)

    assert str(exc.value) == constants.ERROR_MISSING_METADATA
    mock_logger.end.assert_called_once()


@patch('src.app.s3')
@patch('src.app.validate')
@patch('src.app.lambda_logger')
def test_handler_fetches_from_s3_when_no_product_metadata(mock_logger, mock_validate, mock_s3):
    """Test handler fetches product metadata from S3 when not in event."""
    product_metadata = {
        'label': {'service_tier': {'name': 'tier-2'}},
        'validation': {'errors': []},
        'release_correction': 'None',
        'review_history': {'totalCount': 0},
        'special_instructions': 'None',
        'version': 'None'
    }
    event = {
        'data': {
            'review_queue_id': 12345,
            'product_id': 67890,
            'product_metadata_s3_url': (
                's3://test-bucket/snapshots/product-67890-review-queue-12345.json'
            )
        }
    }
    mock_s3.fetch_product_metadata.return_value = product_metadata
    mock_validate.validate_product.return_value = {
        'is_valid': True,
        'failed_validations': {}
    }

    result = app.handler(event, None)

    mock_s3.fetch_product_metadata.assert_called_once_with(
        's3://test-bucket/snapshots/product-67890-review-queue-12345.json'
    )
    mock_validate.validate_product.assert_called_once_with(product_metadata)
    assert result == {
        'validations': constants.PASS,
        'failed_validations': {}
    }


@patch('src.app.validate')
@patch('src.app.lambda_logger')
def test_handler_with_exception(mock_logger, mock_validate):
    """Test handler exception handling."""
    product_metadata = {
        'special_instructions': 'test'
    }
    event = {
        'data': {
            'review_queue_id': 12345,
            'product_id': 67890,
            'product_metadata': product_metadata
        }
    }
    mock_validate.validate_product.side_effect = Exception('Test error')

    with pytest.raises(Exception) as exc:
        app.handler(event, None)

    assert 'Test error' in str(exc.value)
    mock_logger.end.assert_called_once()