from typing import List, Optional, Dict, Union
from sqlalchemy.orm import Session
import random
from pydantic import BaseModel, validator
from models.programming_language import ProgrammingLanguage

def validate_language_name(name: str) -> bool:
    """
    Validate programming language name format.
    
    Args:
        name: Programming language name to validate
        
    Returns:
        bool: True if name format is valid, False otherwise
    """
    # Language name should be at least 1 character and contain only letters, numbers, and common symbols
    return bool(name and len(name.strip()) > 0 and all(c.isalnum() or c in '+-#.' for c in name))

def get_random_language(db: Session) -> Optional[ProgrammingLanguage]:
    """
    Get a random programming language from the database.
    
    Args:
        db: Database session
        
    Returns:
        Random ProgrammingLanguage object if any exist, None otherwise
    """
    languages = db.query(ProgrammingLanguage).all()
    return random.choice(languages) if languages else None

def get_language_by_name(db: Session, name: str) -> Optional[ProgrammingLanguage]:
    """
    Get a programming language by its name.
    
    Args:
        db: Database session
        name: Language name to search for
        
    Returns:
        ProgrammingLanguage object if found, None otherwise
    """
    return db.query(ProgrammingLanguage).filter(ProgrammingLanguage.name == name).first()

def create_language_safely(
    db: Session, 
    name: str, 
    description: Optional[str] = None
) -> Union[ProgrammingLanguage, Dict[str, str]]:
    """
    Create a new programming language with validation and error handling.
    
    Args:
        db: Database session
        name: Language name
        description: Optional language description
        
    Returns:
        ProgrammingLanguage object if created successfully, error dict otherwise
    """
    if not validate_language_name(name):
        return {"error": "Invalid language name format"}
    
    existing_language = get_language_by_name(db, name)
    if existing_language:
        return {"error": "Language already exists"}
        
    db_language = ProgrammingLanguage(
        name=name,
        description=description
    )
    
    db.add(db_language)
    db.commit()
    db.refresh(db_language)
    
    return db_language

def filter_languages_by_pattern(db: Session, pattern: str) -> List[ProgrammingLanguage]:
    """
    Filter programming languages by name pattern.
    
    Args:
        db: Database session
        pattern: Search pattern to filter languages
        
    Returns:
        List of ProgrammingLanguage objects matching the pattern
    """
    search = f"%{pattern}%"
    return db.query(ProgrammingLanguage).filter(
        ProgrammingLanguage.name.ilike(search)
    ).all()