from typing import Optional, Dict, Union
import random
from pydantic import BaseModel, validator

class RandomNumberConfig(BaseModel):
    min_value: int = 1
    max_value: int = 100
    exclude_numbers: list[int] = []

def generate_random_number(config: RandomNumberConfig) -> int:
    """
    Generate a random integer based on provided configuration.
    
    Args:
        config: Configuration settings for random number generation
        
    Returns:
        int: Random number within specified range
    """
    valid_numbers = [n for n in range(config.min_value, config.max_value + 1) 
                    if n not in config.exclude_numbers]
    
    if not valid_numbers:
        raise ValueError("No valid numbers available in specified range")
        
    return random.choice(valid_numbers)

def generate_random_number_sequence(
    count: int,
    config: RandomNumberConfig
) -> list[int]:
    """
    Generate a sequence of unique random numbers.
    
    Args:
        count: Number of random numbers to generate
        config: Configuration settings for random number generation
        
    Returns:
        list[int]: List of random numbers
    """
    valid_numbers = [n for n in range(config.min_value, config.max_value + 1)
                    if n not in config.exclude_numbers]
                    
    if len(valid_numbers) < count:
        raise ValueError(f"Cannot generate {count} unique numbers in specified range")
        
    return random.sample(valid_numbers, count)

def validate_random_number(
    number: int,
    config: RandomNumberConfig
) -> Union[bool, Dict[str, str]]:
    """
    Validate if a number meets the random number criteria.
    
    Args:
        number: Number to validate
        config: Configuration settings to validate against
        
    Returns:
        bool if valid, error dict if invalid
    """
    if number < config.min_value:
        return {"error": f"Number must be >= {config.min_value}"}
        
    if number > config.max_value:
        return {"error": f"Number must be <= {config.max_value}"}
        
    if number in config.exclude_numbers:
        return {"error": "Number is in exclude list"}
        
    return True

def get_random_number_stats(numbers: list[int]) -> Dict[str, Union[int, float]]:
    """
    Calculate statistics for a list of random numbers.
    
    Args:
        numbers: List of numbers to analyze
        
    Returns:
        Dict containing statistical measures
    """
    if not numbers:
        return {
            "count": 0,
            "min": 0,
            "max": 0,
            "mean": 0,
            "median": 0
        }
        
    sorted_nums = sorted(numbers)
    mid = len(sorted_nums) // 2
    
    return {
        "count": len(numbers),
        "min": min(numbers),
        "max": max(numbers),
        "mean": sum(numbers) / len(numbers),
        "median": sorted_nums[mid] if len(numbers) % 2 
                 else (sorted_nums[mid-1] + sorted_nums[mid]) / 2
    }

def is_prime_number(number: int) -> bool:
    """
    Check if a random number is prime.
    
    Args:
        number: Number to check
        
    Returns:
        bool: True if number is prime, False otherwise
    """
    if number < 2:
        return False
    
    for i in range(2, int(number ** 0.5) + 1):
        if number % i == 0:
            return False
            
    return True