"""Lambda validate-product-logic function module."""

SERVICE_TIER_NAMES = {
    'tier-1',
    'premium-services',
}


def get_nested_value(data, path):
    """Get nested value from dict using dot notation path."""
    keys = path.split('.')
    value = data
    for key in keys:
        if isinstance(value, dict):
            value = value.get(key)
        else:
            return None
    return value


def is_none_or_empty(value):
    """Check if value is None, string 'None', or empty."""
    return value is None or value == 'None' or not value


FIELDS_TO_VALIDATE = [
    {
        'path': 'label.service_tier.name',
        'is_valid': lambda v: v not in SERVICE_TIER_NAMES if v else True,
        'fail_message': 'Account is Tier 1 or Premium Services.'
    },
    {
        'path': 'validation.errors',
        'is_valid': is_none_or_empty,
        'fail_message': 'Product has metadata errors.'
    },
    {
        'path': 'validation.warnings',
        'is_valid': is_none_or_empty,
        'fail_message': 'Product has metadata warnings.'
    },
    {
        'path': 'release_correction',
        'is_valid': is_none_or_empty,
        'fail_message': 'Product has error correction.'
    },
    {
        'path': 'review_history.totalCount',
        'is_valid': lambda v: v < 2 if v is not None else True,
        'fail_message': 'Product has been submitted more than once.'
    },
    {
        'path': 'special_instructions',
        'is_valid': is_none_or_empty,
        'fail_message': 'Product has special instructions.'
    },
    {
        'path': 'version',
        'is_valid': is_none_or_empty,
        'fail_message': 'Product has version notes.'
    }
]


def validate_product(data):
    """Validate product data against business rules.

    Args:
        data: Product metadata dictionary

    Returns:
        Dictionary with 'is_valid' boolean and 'failed_validations' dict
    """
    failed = {}

    for rule in FIELDS_TO_VALIDATE:
        path = rule['path']
        value = get_nested_value(data, path)

        # If field exists and validation fails (is_valid returns False), record the failure
        if value is not None and not rule['is_valid'](value):
            failed[path] = rule['fail_message']

    # Check track-level validation
    if tracks := data.get('tracks'):
        for i, track in enumerate(tracks):
            track_validation = track.get('validation', {})

            if track_validation.get('errors'):
                failed[f'tracks[{i}].validation.errors'] = (
                    f'Track {i + 1} has validation errors.'
                )
            if track_validation.get('warnings'):
                failed[f'tracks[{i}].validation.warnings'] = (
                    f'Track {i + 1} has validation warnings.'
                )

    return {
        'is_valid': len(failed) == 0,
        'failed_validations': failed,
    }