Web Asset Generator

#!/usr/bin/env python3
"""
Dependency checker for Web Asset Generator.
Verifies that all required and optional dependencies are installed.
"""

import sys

def check_dependencies():
    """Check all dependencies and report status."""
    results = {
        'required': [],
        'optional': [],
        'errors': []
    }

    print("=" * 70)
    print("Web Asset Generator - Dependency Check")
    print("=" * 70)
    print()

    # Check Python version
    print("Python Version:")
    py_version = sys.version_info
    if py_version >= (3, 6):
        print(f"  ✓ Python {py_version.major}.{py_version.minor}.{py_version.micro} (OK)")
        results['required'].append(('Python', True))
    else:
        print(f"  ❌ Python {py_version.major}.{py_version.minor}.{py_version.micro} (Requires 3.6+)")
        results['required'].append(('Python', False))
        results['errors'].append("Python version too old")
    print()

    # Check required dependencies
    print("Required Dependencies:")

    # Pillow
    try:
        from PIL import Image, ImageDraw, ImageFont
        import PIL
        print(f"  ✓ Pillow {PIL.__version__}")
        results['required'].append(('Pillow', True))
    except ImportError as e:
        print(f"  ❌ Pillow (NOT INSTALLED)")
        print(f"     Install with: pip install Pillow")
        results['required'].append(('Pillow', False))
        results['errors'].append("Pillow not installed")
    print()

    # Check optional dependencies
    print("Optional Dependencies (for emoji support):")

    # Pilmoji
    try:
        from pilmoji import Pilmoji
        print(f"  ✓ Pilmoji (OK)")
        results['optional'].append(('Pilmoji', True))
    except ImportError:
        print(f"  ⚠ Pilmoji (NOT INSTALLED)")
        print(f"     Install with: pip install pilmoji")
        results['optional'].append(('Pilmoji', False))
    except AttributeError:
        print(f"  ⚠ Pilmoji (INSTALLED but incompatible)")
        print(f"     Reinstall with: pip install pilmoji")
        results['optional'].append(('Pilmoji', False))

    # Emoji
    try:
        import emoji
        emoji_version = emoji.__version__ if hasattr(emoji, '__version__') else 'unknown'

        # Check version compatibility
        if emoji_version != 'unknown':
            major_version = int(emoji_version.split('.')[0])
            if major_version < 2:
                print(f"  ✓ emoji {emoji_version} (compatible with pilmoji)")
                results['optional'].append(('emoji', True))
            else:
                print(f"  ⚠ emoji {emoji_version} (incompatible with pilmoji)")
                print(f"     Install compatible version: pip install 'emoji<2.0.0'")
                results['optional'].append(('emoji', False))
        else:
            print(f"  ✓ emoji (version unknown)")
            results['optional'].append(('emoji', True))
    except ImportError:
        print(f"  ⚠ emoji (NOT INSTALLED)")
        print(f"     Install with: pip install 'emoji<2.0.0'")
        results['optional'].append(('emoji', False))

    print()

    # Check font availability
    print("Font Availability:")
    import os
    font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
    if os.path.exists(font_path):
        print(f"  ✓ DejaVu Sans Bold found")
    else:
        print(f"  ⚠ DejaVu Sans Bold not found (will use default font)")
        print(f"     On macOS/Windows, this is expected and OK")
    print()

    # Summary
    print("=" * 70)
    print("Summary:")
    print("=" * 70)

    required_ok = all(status for _, status in results['required'])
    optional_ok = all(status for _, status in results['optional'])

    if required_ok:
        print("✓ All required dependencies are installed")
        print("  You can use basic features (image-based generation)")
    else:
        print("❌ Some required dependencies are missing")
        print("  Please install missing dependencies to use the tool")

    print()

    if optional_ok:
        print("✓ All optional dependencies are installed")
        print("  You can use all features including emoji generation")
    else:
        print("⚠ Some optional dependencies are missing")
        print("  Emoji features will not be available")
        print("  Install optional dependencies to enable emoji support")

    print()

    if results['errors']:
        print("Errors to fix:")
        for error in results['errors']:
            print(f"  - {error}")
        print()

    print("=" * 70)

    # Return exit code
    return 0 if required_ok else 1

if __name__ == '__main__':
    exit_code = check_dependencies()
    sys.exit(exit_code)

#!/usr/bin/env python3
"""
Emoji utilities for favicon generation.
Provides emoji suggestions based on project descriptions and emoji rendering.
"""

import re
from typing import List, Dict, Optional, Tuple
from PIL import Image, ImageDraw, ImageFont

try:
    import emoji as emoji_lib
except ImportError:
    emoji_lib = None

try:
    from pilmoji import Pilmoji
    PILMOJI_AVAILABLE = True
except (ImportError, AttributeError):
    # Handle both import errors and compatibility issues with pilmoji/emoji
    PILMOJI_AVAILABLE = False
    Pilmoji = None

# Curated emoji database with keywords for better matching
# Format: emoji -> (name, keywords, category)
EMOJI_DATABASE = {
    # Technology & Development
    "🚀": ("rocket", ["rocket", "launch", "startup", "space", "speed", "growth"], "tech"),
    "💻": ("laptop", ["computer", "laptop", "code", "dev", "developer", "programming"], "tech"),
    "⚡": ("lightning", ["fast", "speed", "energy", "power", "quick", "performance"], "tech"),
    "🔧": ("wrench", ["tool", "tools", "build", "fix", "settings", "maintenance"], "tech"),
    "🛠️": ("tools", ["tool", "tools", "build", "construction", "development"], "tech"),
    "📱": ("phone", ["mobile", "app", "phone", "smartphone", "application"], "tech"),
    "🌐": ("globe", ["web", "website", "global", "internet", "world", "online"], "tech"),
    "💡": ("bulb", ["idea", "innovation", "creative", "light", "bright", "solution"], "tech"),

    # Business & Commerce
    "🏪": ("store", ["shop", "store", "retail", "business", "commerce"], "business"),
    "🛒": ("cart", ["shopping", "cart", "ecommerce", "buy", "purchase"], "business"),
    "💼": ("briefcase", ["business", "work", "professional", "office", "corporate"], "business"),
    "💰": ("money", ["money", "finance", "payment", "cash", "wealth"], "business"),
    "💳": ("card", ["credit", "card", "payment", "transaction", "banking"], "business"),
    "📊": ("chart", ["analytics", "chart", "data", "stats", "graph", "metrics"], "business"),
    "📈": ("trending", ["growth", "trending", "increase", "success", "profit"], "business"),

    # Food & Beverage
    "☕": ("coffee", ["coffee", "cafe", "beverage", "drink", "tea"], "food"),
    "🍕": ("pizza", ["pizza", "food", "restaurant", "italian", "dining"], "food"),
    "🍔": ("burger", ["burger", "food", "restaurant", "fast food", "dining"], "food"),
    "🍰": ("cake", ["cake", "bakery", "dessert", "sweet", "pastry"], "food"),
    "🍺": ("beer", ["beer", "bar", "pub", "drink", "alcohol", "brewery"], "food"),
    "🍽️": ("dining", ["restaurant", "dining", "food", "meal", "eat"], "food"),
    "🥗": ("salad", ["healthy", "salad", "food", "fresh", "organic", "vegetable"], "food"),

    # Health & Fitness
    "💪": ("muscle", ["fitness", "gym", "health", "workout", "strong", "exercise"], "health"),
    "❤️": ("heart", ["health", "love", "care", "wellness", "medical"], "health"),
    "🏃": ("running", ["fitness", "run", "sport", "exercise", "active"], "health"),
    "🧘": ("yoga", ["yoga", "meditation", "wellness", "mindfulness", "zen"], "health"),

    # Education & Learning
    "📚": ("books", ["education", "learning", "books", "study", "knowledge"], "education"),
    "🎓": ("graduation", ["education", "school", "university", "learning", "graduate"], "education"),
    "✏️": ("pencil", ["write", "edit", "draw", "create", "education"], "education"),
    "🧠": ("brain", ["think", "smart", "intelligence", "learning", "knowledge"], "education"),

    # Creative & Design
    "🎨": ("art", ["art", "design", "creative", "paint", "color"], "creative"),
    "📷": ("camera", ["photo", "photography", "picture", "image", "visual"], "creative"),
    "🎬": ("movie", ["video", "film", "movie", "production", "cinema"], "creative"),
    "🎵": ("music", ["music", "audio", "sound", "song", "melody"], "creative"),
    "✨": ("sparkles", ["magic", "special", "shine", "star", "highlight"], "creative"),

    # Communication & Social
    "💬": ("chat", ["chat", "message", "talk", "communication", "conversation"], "social"),
    "📧": ("email", ["email", "mail", "message", "contact", "communication"], "social"),
    "📢": ("announcement", ["announce", "broadcast", "news", "alert", "notification"], "social"),
    "🤝": ("handshake", ["partnership", "deal", "agreement", "collaboration"], "social"),

    # Travel & Places
    "✈️": ("airplane", ["travel", "flight", "airplane", "trip", "vacation"], "travel"),
    "🏨": ("hotel", ["hotel", "accommodation", "stay", "lodging", "hospitality"], "travel"),
    "🗺️": ("map", ["map", "navigation", "location", "direction", "travel"], "travel"),
    "📍": ("pin", ["location", "place", "map", "pin", "address", "local"], "travel"),
    "🌍": ("earth", ["global", "world", "international", "planet", "earth"], "travel"),

    # Entertainment & Gaming
    "🎮": ("game", ["game", "gaming", "play", "video game", "entertainment"], "entertainment"),
    "🎯": ("target", ["goal", "target", "aim", "focus", "precision"], "entertainment"),
    "🎪": ("circus", ["event", "entertainment", "show", "fun", "festival"], "entertainment"),
    "🎉": ("party", ["celebrate", "party", "event", "celebration", "fun"], "entertainment"),

    # Nature & Animals
    "🌱": ("plant", ["growth", "nature", "plant", "green", "eco", "organic"], "nature"),
    "🌳": ("tree", ["nature", "tree", "environment", "green", "eco"], "nature"),
    "🐶": ("dog", ["dog", "pet", "animal", "puppy"], "nature"),
    "🐱": ("cat", ["cat", "pet", "animal", "kitten"], "nature"),

    # Generic/Universal
    "⭐": ("star", ["star", "favorite", "best", "quality", "rating"], "generic"),
    "🌟": ("glowing", ["star", "shine", "special", "featured", "highlight"], "generic"),
    "✅": ("check", ["check", "done", "complete", "verified", "success"], "generic"),
    "🔥": ("fire", ["hot", "trending", "popular", "fire", "exciting"], "generic"),
    "👍": ("thumbs_up", ["like", "good", "approve", "yes", "positive"], "generic"),
    "🏆": ("trophy", ["winner", "award", "achievement", "success", "champion"], "generic"),
}


def extract_keywords(description: str) -> List[str]:
    """
    Extract keywords from project description.

    Args:
        description: Project description text

    Returns:
        List of lowercase keywords
    """
    # Convert to lowercase
    text = description.lower()

    # Remove punctuation and split
    words = re.findall(r'\b\w+\b', text)

    # Filter out common stop words
    stop_words = {'a', 'an', 'the', 'is', 'are', 'was', 'were', 'for', 'to', 'in', 'on', 'at',
                  'with', 'from', 'by', 'about', 'my', 'our', 'your', 'this', 'that'}

    keywords = [w for w in words if w not in stop_words and len(w) > 2]

    return keywords


def score_emoji(emoji_data: tuple, keywords: List[str]) -> int:
    """
    Score an emoji based on keyword matches.

    Args:
        emoji_data: Tuple of (name, keywords, category)
        keywords: List of user keywords

    Returns:
        Match score (higher is better)
    """
    name, emoji_keywords, category = emoji_data
    score = 0

    for keyword in keywords:
        # Exact keyword match
        if keyword in emoji_keywords:
            score += 10
        # Partial match
        elif any(keyword in ek or ek in keyword for ek in emoji_keywords):
            score += 5
        # Name match
        if keyword in name or name in keyword:
            score += 8

    return score


def suggest_emojis(description: str, count: int = 4) -> List[Dict[str, str]]:
    """
    Suggest relevant emojis based on project description.

    Args:
        description: Description of the project/website/app
        count: Number of emoji suggestions to return (default: 4)

    Returns:
        List of dicts with 'emoji', 'name', and 'description' keys
    """
    if not description:
        # Return generic popular emojis if no description
        return [
            {"emoji": "🚀", "name": "Rocket", "description": "Launch, startup, fast growth"},
            {"emoji": "⭐", "name": "Star", "description": "Featured, favorite, quality"},
            {"emoji": "💡", "name": "Light Bulb", "description": "Ideas, innovation, solutions"},
            {"emoji": "🌟", "name": "Glowing Star", "description": "Special, highlighted, shine"},
        ]

    # Extract keywords from description
    keywords = extract_keywords(description)

    # Score all emojis
    scored_emojis = []
    for emoji_char, emoji_data in EMOJI_DATABASE.items():
        score = score_emoji(emoji_data, keywords)
        if score > 0:  # Only include emojis with matches
            name, emoji_keywords, category = emoji_data
            scored_emojis.append({
                "emoji": emoji_char,
                "name": name.replace("_", " ").title(),
                "description": ", ".join(emoji_keywords[:3]),
                "score": score,
                "category": category
            })

    # Sort by score (highest first)
    scored_emojis.sort(key=lambda x: x['score'], reverse=True)

    # Ensure diversity: try to get emojis from different categories
    selected = []
    used_categories = set()

    # First pass: select top scoring emoji from each category
    for emoji in scored_emojis:
        if len(selected) >= count:
            break
        if emoji['category'] not in used_categories:
            selected.append(emoji)
            used_categories.add(emoji['category'])

    # Second pass: fill remaining slots with highest scoring regardless of category
    for emoji in scored_emojis:
        if len(selected) >= count:
            break
        if emoji not in selected:
            selected.append(emoji)

    # If still not enough, add generic fallbacks
    fallbacks = [
        {"emoji": "⭐", "name": "Star", "description": "Featured, favorite, quality"},
        {"emoji": "🌟", "name": "Glowing Star", "description": "Special, highlighted"},
        {"emoji": "✨", "name": "Sparkles", "description": "Magic, special"},
        {"emoji": "💫", "name": "Dizzy", "description": "Exciting, dynamic"},
    ]

    for fallback in fallbacks:
        if len(selected) >= count:
            break
        if fallback not in selected:
            selected.append(fallback)

    # Remove score from output and return only the requested count
    result = []
    for emoji in selected[:count]:
        result.append({
            "emoji": emoji["emoji"],
            "name": emoji["name"],
            "description": emoji["description"]
        })

    return result


def get_emoji_name(emoji_char: str) -> str:
    """
    Get the name of an emoji character.

    Args:
        emoji_char: Emoji character (e.g., "🚀")

    Returns:
        Emoji name or empty string if not found
    """
    if emoji_char in EMOJI_DATABASE:
        return EMOJI_DATABASE[emoji_char][0].replace("_", " ").title()

    # Fallback to emoji library if available
    if emoji_lib:
        try:
            return emoji_lib.demojize(emoji_char).strip(':').replace('_', ' ').title()
        except:
            pass

    return ""


def generate_emoji_icon(emoji_char: str, size: Tuple[int, int], bg_color: Optional[str] = None) -> Image.Image:
    """
    Generate an icon image from an emoji character.

    Args:
        emoji_char: Unicode emoji character (e.g., "🚀")
        size: Tuple of (width, height) in pixels
        bg_color: Optional background color (hex or name). If None, transparent background.

    Returns:
        PIL Image object with the emoji rendered

    Raises:
        ImportError: If pilmoji library is not installed
        ValueError: If emoji_char is empty or invalid
    """
    if not PILMOJI_AVAILABLE:
        raise ImportError(
            "pilmoji library is required for emoji rendering. "
            "Install it with: pip install pilmoji"
        )

    if not emoji_char:
        raise ValueError("emoji_char cannot be empty")

    # Create image with background
    if bg_color:
        # Solid background color
        img = Image.new('RGB', size, bg_color)
    else:
        # Transparent background
        img = Image.new('RGBA', size, (0, 0, 0, 0))

    # Calculate emoji font size
    # Use 75% of the minimum dimension to leave padding
    emoji_size = int(min(size) * 0.75)

    # Use Pilmoji to render the emoji
    with Pilmoji(img) as pilmoji:
        # Get text bounding box to center properly
        # Pilmoji doesn't provide easy centering, so we estimate
        # Emojis are roughly square, so we can center based on size

        # Calculate position (centered)
        x = (size[0] - emoji_size) // 2
        y = (size[1] - emoji_size) // 2

        # Render emoji
        # Note: Pilmoji uses font_size parameter for emoji size
        pilmoji.text((x, y), emoji_char, font=None, fill=(0, 0, 0, 0),
                     emoji_scale_factor=emoji_size/64)  # Pilmoji default emoji size is 64

    return img


def generate_emoji_icon_fallback(emoji_char: str, size: Tuple[int, int], bg_color: Optional[str] = None) -> Image.Image:
    """
    Fallback method to generate emoji icon using system fonts.
    Used when Pilmoji is not available.

    Args:
        emoji_char: Unicode emoji character
        size: Tuple of (width, height)
        bg_color: Optional background color

    Returns:
        PIL Image with emoji (may not render properly on all systems)
    """
    # Create image
    if bg_color:
        img = Image.new('RGB', size, bg_color)
    else:
        img = Image.new('RGBA', size, (0, 0, 0, 0))

    draw = ImageDraw.Draw(img)

    # Try to use a color emoji font
    emoji_size = int(min(size) * 0.75)

    # Try common emoji font paths
    font_paths = [
        "/System/Library/Fonts/Apple Color Emoji.ttc",  # macOS
        "/usr/share/fonts/truetype/noto/NotoColorEmoji.ttf",  # Linux
        "C:\\Windows\\Fonts\\seguiemj.ttf",  # Windows
    ]

    font = None
    for font_path in font_paths:
        try:
            font = ImageFont.truetype(font_path, emoji_size)
            break
        except:
            continue

    if not font:
        # Fallback to default font with text representation
        font = ImageFont.load_default()
        text = f"Emoji: {emoji_char}"
    else:
        text = emoji_char

    # Get text bounding box for centering
    bbox = draw.textbbox((0, 0), text, font=font)
    text_width = bbox[2] - bbox[0]
    text_height = bbox[3] - bbox[1]

    x = (size[0] - text_width) // 2
    y = (size[1] - text_height) // 2

    # Draw the emoji
    draw.text((x, y), text, font=font, embedded_color=True, fill=(0, 0, 0))

    return img


if __name__ == '__main__':
    # Test the suggestion system
    test_cases = [
        "coffee shop website",
        "rocket launch startup",
        "fitness gym app",
        "pizza delivery service",
        "online education platform",
        "travel booking site",
    ]

    print("Emoji Suggestion Tests")
    print("=" * 80)

    for description in test_cases:
        print(f"\nDescription: '{description}'")
        print("-" * 80)
        suggestions = suggest_emojis(description, count=4)
        for i, emoji_data in enumerate(suggestions, 1):
            print(f"{i}. {emoji_data['emoji']}  {emoji_data['name']:<20} - {emoji_data['description']}")

#!/usr/bin/env python3
"""
Generate favicon and app icon files from a source image or emoji.
Supports standard favicon sizes and PWA icon sizes.
"""

import sys
import argparse
import re
from pathlib import Path
from PIL import Image
import io

# Import emoji utilities
try:
    from emoji_utils import generate_emoji_icon, suggest_emojis, get_emoji_name, PILMOJI_AVAILABLE
except ImportError:
    # If running from different directory, try absolute import
    try:
        import os
        sys.path.insert(0, os.path.dirname(__file__))
        from emoji_utils import generate_emoji_icon, suggest_emojis, get_emoji_name, PILMOJI_AVAILABLE
    except ImportError:
        # Emoji support not available
        generate_emoji_icon = None
        suggest_emojis = None
        get_emoji_name = None
        PILMOJI_AVAILABLE = False

# Import validation utilities
try:
    from lib.validators import validate_file_size, validate_dimensions, validate_format, ValidationResult
except ImportError:
    # If running from a different directory, try alternative import
    try:
        sys.path.insert(0, str(Path(__file__).parent))
        from lib.validators import validate_file_size, validate_dimensions, validate_format, ValidationResult
    except ImportError:
        # Validation not available
        validate_file_size = None
        validate_dimensions = None
        validate_format = None
        ValidationResult = None

# Standard favicon sizes
FAVICON_SIZES = {
    'favicon-16x16.png': (16, 16),
    'favicon-32x32.png': (32, 32),
    'favicon-96x96.png': (96, 96),
}

# PWA/App icon sizes
APP_ICON_SIZES = {
    'apple-touch-icon.png': (180, 180),
    'android-chrome-192x192.png': (192, 192),
    'android-chrome-512x512.png': (512, 512),
}

def generate_icons(source_path=None, output_dir=None, icon_types='all', emoji=None, emoji_bg=None, validate=False):
    """
    Generate icon files from a source image or emoji.

    Args:
        source_path: Path to source image (optional if emoji is provided)
        output_dir: Directory to save generated icons
        icon_types: 'favicon', 'app', or 'all'
        emoji: Emoji character to use instead of image (optional)
        emoji_bg: Background color for emoji (hex or color name, optional)
        validate: If True, run validation checks on generated icons (default: False)

    Returns:
        Dictionary with 'files' and optional 'validation_results'
    """
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    # Determine if using emoji or image
    if emoji:
        if not generate_emoji_icon:
            raise ImportError(
                "Emoji support requires emoji_utils.py and pilmoji library. "
                "Install pilmoji with: pip install pilmoji"
            )

        # For app icons, use solid background (iOS doesn't support transparency)
        # For favicons, use transparent background unless specified
        needs_solid_bg = (icon_types in ['app', 'all'])

        if needs_solid_bg and not emoji_bg:
            emoji_bg = 'white'  # Default background for app icons

        # Generate a large emoji image that we'll resize
        # Use 512x512 as base size (largest needed)
        base_img = generate_emoji_icon(emoji, (512, 512), emoji_bg)
        img = base_img

        print(f"Using emoji: {emoji} {get_emoji_name(emoji) if get_emoji_name else ''}")

    else:
        # Load from image file
        if not source_path:
            raise ValueError("Either source_path or emoji must be provided")

        source_path = Path(source_path)
        img = Image.open(source_path)
        print(f"Generating icons from {source_path}...")

    # Convert to RGBA if necessary (unless using solid background with emoji)
    if img.mode != 'RGBA' and not (emoji and emoji_bg):
        img = img.convert('RGBA')

    # Determine which sizes to generate
    sizes_to_generate = {}
    if icon_types in ['favicon', 'all']:
        sizes_to_generate.update(FAVICON_SIZES)
    if icon_types in ['app', 'all']:
        sizes_to_generate.update(APP_ICON_SIZES)

    # Generate each size
    generated_files = []
    for filename, size in sizes_to_generate.items():
        # Resize with high-quality resampling
        resized = img.resize(size, Image.Resampling.LANCZOS)

        # Save
        output_path = output_dir / filename
        resized.save(output_path, 'PNG', optimize=True)
        generated_files.append(str(output_path))
        print(f"✓ Generated {filename} ({size[0]}x{size[1]})")

    # Generate .ico file for browsers (contains 16x16 and 32x32)
    if icon_types in ['favicon', 'all']:
        ico_path = output_dir / 'favicon.ico'
        icon_16 = img.resize((16, 16), Image.Resampling.LANCZOS)
        icon_32 = img.resize((32, 32), Image.Resampling.LANCZOS)
        icon_16.save(ico_path, format='ICO', sizes=[(16, 16), (32, 32)])
        generated_files.append(str(ico_path))
        print(f"✓ Generated favicon.ico (16x16, 32x32)")

    result = {'files': generated_files}

    # Run validation if requested
    if validate and generated_files and validate_file_size:
        print("\n" + "=" * 70)
        print("Running validation checks...")
        print("=" * 70)

        validation_results = []

        # Validate PNG files (skip .ico as it has different requirements)
        png_files = [f for f in generated_files if f.endswith('.png')]

        for file_path in png_files:
            filename = Path(file_path).name
            print(f"\n{filename}:")

            # Get actual file size
            import os
            file_size_kb = os.path.getsize(file_path) / 1024

            # Custom validation for favicons and app icons
            if 'favicon' in filename.lower():
                # File size check
                if file_size_kb > 100:
                    size_result = ValidationResult(
                        True,
                        f"  ⚠ File size {file_size_kb:.1f}KB is large for a favicon (recommended <100KB)",
                        'warning'
                    )
                else:
                    size_result = ValidationResult(
                        True,
                        f"  ✓ File size {file_size_kb:.1f}KB is good for a favicon",
                        'success'
                    )

                # Dimension check - just verify it matches expected size from filename
                expected_sizes = {'16': 16, '32': 32, '96': 96}
                size_match = re.search(r'(\d+)x(\d+)', filename)
                if size_match:
                    w, h = int(size_match.group(1)), int(size_match.group(2))
                    if w == h:
                        dim_result = ValidationResult(
                            True,
                            f"  ✓ Dimensions {w}x{h} are correct for favicon",
                            'success'
                        )
                    else:
                        dim_result = ValidationResult(
                            False,
                            f"  ❌ Favicon must be square, got {w}x{h}",
                            'error'
                        )
                else:
                    dim_result = ValidationResult(True, "  ✓ Dimensions OK", 'success')

                # Format check
                fmt_result = ValidationResult(True, "  ✓ Format PNG is correct", 'success')

            else:  # App icon
                # File size check
                if file_size_kb > 500:
                    size_result = ValidationResult(
                        True,
                        f"  ⚠ File size {file_size_kb:.1f}KB is large for an app icon (recommended <500KB)",
                        'warning'
                    )
                else:
                    size_result = ValidationResult(
                        True,
                        f"  ✓ File size {file_size_kb:.1f}KB is good for an app icon",
                        'success'
                    )

                # Dimension check - verify square and correct size
                size_match = re.search(r'(\d+)x(\d+)', filename)
                if size_match:
                    w, h = int(size_match.group(1)), int(size_match.group(2))
                    if w == h:
                        dim_result = ValidationResult(
                            True,
                            f"  ✓ Dimensions {w}x{h} are correct for app icon",
                            'success'
                        )
                    else:
                        dim_result = ValidationResult(
                            False,
                            f"  ❌ App icon must be square, got {w}x{h}",
                            'error'
                        )
                else:
                    dim_result = ValidationResult(True, "  ✓ Dimensions OK", 'success')

                # Format check
                fmt_result = ValidationResult(True, "  ✓ Format PNG is correct", 'success')

            print(f"{size_result}")
            print(f"{dim_result}")
            print(f"{fmt_result}")

            validation_results.append({
                'file': filename,
                'size': size_result,
                'dimensions': dim_result,
                'format': fmt_result
            })

        result['validation_results'] = validation_results

    return result

def generate_html_tags(icon_types='all'):
    """Generate HTML tags for the icons."""
    tags = []
    
    if icon_types in ['favicon', 'all']:
        tags.extend([
            '<link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">',
            '<link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">',
            '<link rel="icon" type="image/png" sizes="96x96" href="/favicon-96x96.png">',
        ])
    
    if icon_types in ['app', 'all']:
        tags.extend([
            '<link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">',
            '<link rel="icon" type="image/png" sizes="192x192" href="/android-chrome-192x192.png">',
            '<link rel="icon" type="image/png" sizes="512x512" href="/android-chrome-512x512.png">',
        ])
    
    return '\n'.join(tags)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Generate favicon and app icon files from a source image or emoji',
        epilog='Examples:\n'
               '  python generate_favicons.py logo.png output/ all\n'
               '  python generate_favicons.py --emoji "🚀" output/ all\n'
               '  python generate_favicons.py --emoji "☕" --emoji-bg "#F5DEB3" output/ favicon\n'
               '  python generate_favicons.py --suggest "coffee shop" output/ all',
        formatter_class=argparse.RawDescriptionHelpFormatter
    )

    # Positional arguments
    parser.add_argument('source_image', nargs='?', help='Path to source image file (not needed with --emoji or --suggest)')
    parser.add_argument('output_dir', help='Output directory for generated icons')
    parser.add_argument('icon_type', nargs='?', default='all',
                        choices=['favicon', 'app', 'all'],
                        help="Icon type to generate: 'favicon', 'app', or 'all' (default: all)")

    # Source options (mutually exclusive with source_image)
    source_group = parser.add_mutually_exclusive_group()
    source_group.add_argument('--emoji', metavar='EMOJI', help='Emoji character to use (e.g., "🚀")')
    source_group.add_argument('--suggest', metavar='DESCRIPTION',
                              help='Get emoji suggestions based on project description')

    # Optional arguments
    parser.add_argument('--emoji-bg', metavar='COLOR',
                        help='Background color for emoji icons (hex or color name). '
                             'Default: transparent for favicons, white for app icons')
    parser.add_argument('--validate', action='store_true',
                        help='Run validation checks on generated icons (file size, dimensions, format)')

    args = parser.parse_args()

    # Handle emoji suggestions
    if args.suggest:
        if not suggest_emojis:
            print("❌ Error: Emoji suggestion requires emoji_utils.py")
            print("Make sure emoji_utils.py is in the same directory")
            sys.exit(1)

        print(f"🔍 Finding emoji suggestions for: '{args.suggest}'")
        print()

        suggestions = suggest_emojis(args.suggest, count=4)

        print("Here are the top 4 emoji suggestions:")
        print("=" * 70)
        for i, emoji_data in enumerate(suggestions, 1):
            print(f"{i}. {emoji_data['emoji']}  {emoji_data['name']:<25} - {emoji_data['description']}")

        print()
        print("To use one of these emojis, run:")
        print(f"  python generate_favicons.py --emoji \"EMOJI\" {args.output_dir} {args.icon_type}")
        sys.exit(0)

    # Validate input
    if not args.source_image and not args.emoji:
        parser.error("Either source_image or --emoji must be provided")

    # Generate icons
    try:
        result = generate_icons(
            source_path=args.source_image,
            output_dir=args.output_dir,
            icon_types=args.icon_type,
            emoji=args.emoji,
            emoji_bg=args.emoji_bg,
            validate=args.validate
        )

        files = result['files']
        print(f"\n✅ Generated {len(files)} icon files in {args.output_dir}/")

        if not args.validate and validate_file_size:
            print("\n💡 Tip: Use --validate to check file sizes and formats")

        print("\nHTML tags to include in your <head>:")
        print(generate_html_tags(args.icon_type))

    except ImportError as e:
        print(f"❌ Error: {e}")
        sys.exit(1)
    except Exception as e:
        print(f"❌ Error generating icons: {e}")
        sys.exit(1)

#!/usr/bin/env python3
"""
Generate social media meta images (Open Graph images) for Facebook, Twitter, WhatsApp, etc.
Can work with a logo/image or text-based content.
"""

import sys
import argparse
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont
import textwrap

# Import validation utilities
try:
    from lib.validators import validate_all, print_validation_results, hex_to_rgb, validate_contrast
except ImportError:
    # If running from a different directory, try alternative import
    sys.path.insert(0, str(Path(__file__).parent))
    from lib.validators import validate_all, print_validation_results, hex_to_rgb, validate_contrast

# Standard Open Graph image sizes
OG_SIZES = {
    'og-image.png': (1200, 630),  # Facebook, LinkedIn, WhatsApp
    'twitter-image.png': (1200, 675),  # Twitter (16:9 ratio)
    'og-square.png': (1200, 1200),  # Square variant for some platforms
}

def calculate_font_size(text, base_size=120):
    """
    Calculate optimal font size based on text length.

    Args:
        text: The text to be displayed
        base_size: Base font size (default: 120)

    Returns:
        int: Calculated font size
    """
    text_length = len(text)

    if text_length <= 20:
        # Short text: use larger font for impact
        return int(base_size * 1.2)  # 144px
    elif text_length <= 40:
        # Medium text: use base size
        return base_size  # 120px
    elif text_length <= 60:
        # Long text: reduce slightly
        return int(base_size * 0.85)  # 102px
    else:
        # Very long text: reduce more
        return int(base_size * 0.7)  # 84px

def create_text_image(text, size, bg_color='#4F46E5', text_color='white', 
                     font_size=80, logo_path=None):
    """
    Create an image with text and optional logo.
    
    Args:
        text: Main text to display
        size: Tuple of (width, height)
        bg_color: Background color (hex or color name)
        text_color: Text color
        font_size: Font size for text
        logo_path: Optional path to logo image to include
    """
    # Create image
    img = Image.new('RGB', size, bg_color)
    draw = ImageDraw.Draw(img)
    
    # Try to use a nice font, fall back to default
    try:
        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", font_size)
        font_small = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", int(font_size * 0.5))
    except:
        font = ImageFont.load_default()
        font_small = font
    
    # Add logo if provided
    logo_height = 0
    if logo_path and Path(logo_path).exists():
        logo = Image.open(logo_path)
        # Resize logo to fit (max 20% of image height - gives more space for text)
        max_logo_height = int(size[1] * 0.20)
        if logo.height > max_logo_height:
            ratio = max_logo_height / logo.height
            new_size = (int(logo.width * ratio), max_logo_height)
            logo = logo.resize(new_size, Image.Resampling.LANCZOS)
        
        # Convert to RGBA if needed
        if logo.mode != 'RGBA':
            logo = logo.convert('RGBA')
        
        # Center logo at top
        logo_x = (size[0] - logo.width) // 2
        logo_y = int(size[1] * 0.15)
        img.paste(logo, (logo_x, logo_y), logo)
        logo_height = logo.height + int(size[1] * 0.1)
    
    # Wrap text to fit width
    max_width = int(size[0] * 0.85)  # 85% of image width
    wrapped_lines = []
    
    # Split text into words and wrap
    words = text.split()
    current_line = []
    
    for word in words:
        current_line.append(word)
        line_text = ' '.join(current_line)
        bbox = draw.textbbox((0, 0), line_text, font=font)
        line_width = bbox[2] - bbox[0]
        
        if line_width > max_width:
            if len(current_line) > 1:
                current_line.pop()
                wrapped_lines.append(' '.join(current_line))
                current_line = [word]
            else:
                wrapped_lines.append(word)
                current_line = []
    
    if current_line:
        wrapped_lines.append(' '.join(current_line))
    
    # Calculate total text height
    total_text_height = 0
    for line in wrapped_lines:
        bbox = draw.textbbox((0, 0), line, font=font)
        total_text_height += (bbox[3] - bbox[1]) + 10
    
    # Start position for text (centered vertically)
    available_height = size[1] - logo_height
    y = logo_height + (available_height - total_text_height) // 2
    
    # Draw each line centered
    for line in wrapped_lines:
        bbox = draw.textbbox((0, 0), line, font=font)
        line_width = bbox[2] - bbox[0]
        line_height = bbox[3] - bbox[1]
        x = (size[0] - line_width) // 2
        draw.text((x, y), line, fill=text_color, font=font)
        y += line_height + 10
    
    return img

def resize_image_for_og(source_path, size, fit_mode='cover'):
    """
    Resize an existing image for Open Graph specs.
    
    Args:
        source_path: Path to source image
        size: Target size tuple (width, height)
        fit_mode: 'cover' (fill, may crop) or 'contain' (fit, may have borders)
    """
    img = Image.open(source_path)
    
    if fit_mode == 'cover':
        # Calculate aspect ratios
        img_ratio = img.width / img.height
        target_ratio = size[0] / size[1]
        
        if img_ratio > target_ratio:
            # Image is wider, fit to height
            new_height = size[1]
            new_width = int(new_height * img_ratio)
        else:
            # Image is taller, fit to width
            new_width = size[0]
            new_height = int(new_width / img_ratio)
        
        # Resize and crop to center
        img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
        
        # Crop to target size
        left = (new_width - size[0]) // 2
        top = (new_height - size[1]) // 2
        img = img.crop((left, top, left + size[0], top + size[1]))
    else:  # contain
        # Fit image within target size, add borders if needed
        img.thumbnail(size, Image.Resampling.LANCZOS)
        
        # Create new image with target size and paste resized image centered
        new_img = Image.new('RGB', size, 'white')
        x = (size[0] - img.width) // 2
        y = (size[1] - img.height) // 2
        new_img.paste(img, (x, y))
        img = new_img
    
    return img

def generate_og_images(output_dir, text=None, source_image=None, logo_path=None,
                       bg_color='#4F46E5', text_color='white', platforms='all',
                       validate=False):
    """
    Generate Open Graph images for social media.

    Args:
        output_dir: Directory to save images
        text: Text to display (if creating text-based image)
        source_image: Path to existing image to resize
        logo_path: Path to logo to include with text
        bg_color: Background color for text-based images
        text_color: Text color for text-based images
        platforms: 'facebook', 'twitter', 'square', or 'all'
        validate: If True, run validation checks on generated images

    Returns:
        Dictionary with 'files' and optional 'validation_results'
    """
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    # Determine which sizes to generate
    sizes_to_generate = {}
    if platforms == 'all':
        sizes_to_generate = OG_SIZES
    elif platforms == 'facebook':
        sizes_to_generate = {'og-image.png': OG_SIZES['og-image.png']}
    elif platforms == 'twitter':
        sizes_to_generate = {'twitter-image.png': OG_SIZES['twitter-image.png']}
    elif platforms == 'square':
        sizes_to_generate = {'og-square.png': OG_SIZES['og-square.png']}

    generated_files = []

    for filename, size in sizes_to_generate.items():
        if text:
            # Generate text-based image with dynamic font sizing
            # Base size: 120px for 1200px images, 90px for smaller
            base_font_size = 120 if size[0] >= 1200 else 90
            optimal_font_size = calculate_font_size(text, base_font_size)
            img = create_text_image(text, size, bg_color, text_color,
                                   font_size=optimal_font_size,
                                   logo_path=logo_path)
        elif source_image:
            # Resize existing image
            img = resize_image_for_og(source_image, size)
        else:
            raise ValueError("Must provide either text or source_image")

        # Save
        output_path = output_dir / filename
        img.save(output_path, 'PNG', optimize=True)
        generated_files.append(str(output_path))
        print(f"✓ Generated {filename} ({size[0]}x{size[1]})")

    result = {'files': generated_files}

    # Run validation if requested
    if validate and generated_files:
        print("\n" + "=" * 70)
        print("Running validation checks...")
        print("=" * 70)

        validation_results = {}

        # Validate each generated file
        for file_path in generated_files:
            filename = Path(file_path).name

            # Determine platform(s) for this file
            if 'twitter' in filename:
                platforms_to_check = ['twitter']
            elif 'square' in filename:
                platforms_to_check = ['facebook', 'twitter']  # Square works for both
            else:
                platforms_to_check = ['facebook', 'linkedin', 'whatsapp']

            file_results = validate_all(file_path, platforms_to_check)
            validation_results[filename] = file_results

            # Print results for this file
            print(f"\n{filename}:")
            print_validation_results(file_results, verbose=True)

        # If text-based, also validate contrast ratio
        if text:
            print("\n" + "=" * 70)
            print("Accessibility Checks:")
            print("=" * 70)

            try:
                # Convert colors to RGB tuples
                if bg_color.startswith('#'):
                    bg_rgb = hex_to_rgb(bg_color)
                else:
                    # For named colors, we'd need a mapping - for now just skip
                    bg_rgb = None

                if text_color.startswith('#'):
                    text_rgb = hex_to_rgb(text_color)
                elif text_color.lower() == 'white':
                    text_rgb = (255, 255, 255)
                elif text_color.lower() == 'black':
                    text_rgb = (0, 0, 0)
                else:
                    text_rgb = None

                if bg_rgb and text_rgb:
                    # Calculate font size in pixels (use the optimal font size calculated earlier)
                    base_font_size = 120 if list(sizes_to_generate.values())[0][0] >= 1200 else 90
                    optimal_font_size = calculate_font_size(text, base_font_size)

                    contrast_result = validate_contrast(
                        text_rgb,
                        bg_rgb,
                        font_size=optimal_font_size,
                        is_bold=True  # Social images typically use bold text
                    )
                    print(f"  {contrast_result}")
                    validation_results['contrast'] = contrast_result
            except Exception as e:
                print(f"  ⚠ Could not validate contrast: {e}")

        result['validation_results'] = validation_results

    return result

def generate_og_html_tags():
    """Generate HTML meta tags for Open Graph images."""
    return """<!-- Open Graph / Facebook -->
<meta property="og:image" content="/og-image.png">
<meta property="og:image:width" content="1200">
<meta property="og:image:height" content="630">
<meta property="og:image:alt" content="Your description here">

<!-- Twitter -->
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:image" content="/twitter-image.png">
<meta name="twitter:image:alt" content="Your description here">"""

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Generate social media meta images (Open Graph images)',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Text-based image
  python generate_og_images.py output/ --text "Welcome to my site"

  # Text with logo
  python generate_og_images.py output/ --text "My App" --logo logo.png

  # Text with custom colors
  python generate_og_images.py output/ --text "Hello" --bg-color "#FF5733" --text-color "#FFFFFF"

  # Resize existing image
  python generate_og_images.py output/ --image photo.jpg

  # Generate with validation
  python generate_og_images.py output/ --text "My Site" --validate
        """
    )

    parser.add_argument('output_dir', help='Directory to save generated images')

    # Source options (mutually exclusive)
    source_group = parser.add_mutually_exclusive_group(required=True)
    source_group.add_argument('--text', help='Text to display in the image')
    source_group.add_argument('--image', dest='source_image', help='Path to existing image to resize')

    # Optional arguments
    parser.add_argument('--logo', dest='logo_path', help='Path to logo image to include with text')
    parser.add_argument('--bg-color', dest='bg_color', default='#4F46E5',
                       help='Background color (hex or name, default: #4F46E5)')
    parser.add_argument('--text-color', dest='text_color', default='white',
                       help='Text color (hex or name, default: white)')
    parser.add_argument('--platforms', choices=['all', 'facebook', 'twitter', 'square'],
                       default='all', help='Which platforms to generate for (default: all)')
    parser.add_argument('--validate', action='store_true',
                       help='Run validation checks on generated images (file size, dimensions, contrast)')

    args = parser.parse_args()

    print("Generating Open Graph images...")
    result = generate_og_images(
        args.output_dir,
        text=args.text,
        source_image=args.source_image,
        logo_path=args.logo_path,
        bg_color=args.bg_color,
        text_color=args.text_color,
        platforms=args.platforms,
        validate=args.validate
    )

    files = result['files']
    print(f"\n✅ Generated {len(files)} Open Graph images in {args.output_dir}/")

    if not args.validate:
        print("\n💡 Tip: Use --validate to check file sizes, dimensions, and accessibility")

    print("\nHTML meta tags to include in your <head>:")
    print(generate_og_html_tags())

"""
Web Asset Generator - Library Modules

This package contains reusable modules for the web asset generator.
"""

__version__ = "1.0.0"

#!/usr/bin/env python3
"""
Validation utilities for web assets.
Validates file sizes, dimensions, formats, and accessibility requirements.
"""

import os
from pathlib import Path
from typing import List, Dict, Tuple, Optional
from PIL import Image
import colorsys


# Platform-specific requirements
PLATFORM_REQUIREMENTS = {
    'facebook': {
        'max_file_size': 8 * 1024 * 1024,  # 8MB
        'recommended_size': (1200, 630),
        'min_size': (600, 315),
        'aspect_ratio': 1.91,
        'formats': ['png', 'jpg', 'jpeg'],
    },
    'twitter': {
        'max_file_size': 5 * 1024 * 1024,  # 5MB
        'recommended_size': (1200, 675),
        'min_size': (300, 157),
        'aspect_ratio': 16/9,
        'formats': ['png', 'jpg', 'jpeg', 'webp'],
    },
    'linkedin': {
        'max_file_size': 5 * 1024 * 1024,  # 5MB
        'recommended_size': (1200, 627),
        'min_size': (1200, 628),
        'aspect_ratio': 1.91,
        'formats': ['png', 'jpg', 'jpeg'],
    },
    'whatsapp': {
        'max_file_size': 8 * 1024 * 1024,  # 8MB (same as Facebook)
        'recommended_size': (1200, 630),
        'min_size': (600, 315),
        'aspect_ratio': 1.91,
        'formats': ['png', 'jpg', 'jpeg'],
    },
}

# WCAG contrast ratio requirements
WCAG_AA_NORMAL = 4.5
WCAG_AA_LARGE = 3.0
WCAG_AAA_NORMAL = 7.0
WCAG_AAA_LARGE = 4.5


class ValidationResult:
    """Represents the result of a validation check."""

    def __init__(self, passed: bool, message: str, level: str = 'info'):
        """
        Initialize validation result.

        Args:
            passed: Whether the validation passed
            message: Description of the result
            level: 'success', 'warning', 'error', 'info'
        """
        self.passed = passed
        self.message = message
        self.level = level

    def __str__(self):
        icon = {
            'success': '✓',
            'warning': '⚠',
            'error': '❌',
            'info': 'ℹ',
        }.get(self.level, '•')

        return f"{icon} {self.message}"

    def __repr__(self):
        return f"ValidationResult(passed={self.passed}, level='{self.level}', message='{self.message}')"


def validate_file_size(file_path: str, platform: str = 'facebook') -> ValidationResult:
    """
    Validate file size against platform requirements.

    Args:
        file_path: Path to the image file
        platform: Platform name (facebook, twitter, linkedin, whatsapp)

    Returns:
        ValidationResult with pass/fail and message
    """
    if platform not in PLATFORM_REQUIREMENTS:
        return ValidationResult(
            False,
            f"Unknown platform: {platform}",
            'error'
        )

    file_path = Path(file_path)
    if not file_path.exists():
        return ValidationResult(
            False,
            f"File not found: {file_path}",
            'error'
        )

    file_size = os.path.getsize(file_path)
    max_size = PLATFORM_REQUIREMENTS[platform]['max_file_size']

    # Convert to MB for display
    file_size_mb = file_size / (1024 * 1024)
    max_size_mb = max_size / (1024 * 1024)

    if file_size > max_size:
        return ValidationResult(
            False,
            f"File size {file_size_mb:.1f}MB exceeds {platform.title()} limit of {max_size_mb:.0f}MB",
            'error'
        )
    elif file_size > max_size * 0.8:  # Warn if within 80% of limit
        return ValidationResult(
            True,
            f"File size {file_size_mb:.1f}MB is close to {platform.title()} limit ({max_size_mb:.0f}MB)",
            'warning'
        )
    else:
        return ValidationResult(
            True,
            f"File size {file_size_mb:.1f}MB is within {platform.title()} limits",
            'success'
        )


def validate_dimensions(file_path: str, platform: str = 'facebook') -> ValidationResult:
    """
    Validate image dimensions against platform requirements.

    Args:
        file_path: Path to the image file
        platform: Platform name

    Returns:
        ValidationResult with pass/fail and message
    """
    if platform not in PLATFORM_REQUIREMENTS:
        return ValidationResult(
            False,
            f"Unknown platform: {platform}",
            'error'
        )

    file_path = Path(file_path)
    if not file_path.exists():
        return ValidationResult(
            False,
            f"File not found: {file_path}",
            'error'
        )

    try:
        with Image.open(file_path) as img:
            width, height = img.size
    except Exception as e:
        return ValidationResult(
            False,
            f"Could not read image dimensions: {e}",
            'error'
        )

    requirements = PLATFORM_REQUIREMENTS[platform]
    rec_width, rec_height = requirements['recommended_size']
    min_width, min_height = requirements['min_size']

    # Check if dimensions match recommended size
    if (width, height) == (rec_width, rec_height):
        return ValidationResult(
            True,
            f"Dimensions {width}x{height} match {platform.title()} recommended size",
            'success'
        )

    # Check if dimensions meet minimum requirements
    if width < min_width or height < min_height:
        return ValidationResult(
            False,
            f"Dimensions {width}x{height} below {platform.title()} minimum ({min_width}x{min_height})",
            'error'
        )

    # Check aspect ratio
    actual_ratio = width / height
    expected_ratio = requirements['aspect_ratio']
    ratio_diff = abs(actual_ratio - expected_ratio)

    if ratio_diff > 0.1:  # Allow 10% variance
        return ValidationResult(
            True,
            f"Dimensions {width}x{height} have non-standard aspect ratio (expected {expected_ratio:.2f}:1, got {actual_ratio:.2f}:1)",
            'warning'
        )

    return ValidationResult(
        True,
        f"Dimensions {width}x{height} meet {platform.title()} requirements",
        'success'
    )


def validate_format(file_path: str, platform: str = 'facebook') -> ValidationResult:
    """
    Validate image format against platform requirements.

    Args:
        file_path: Path to the image file
        platform: Platform name

    Returns:
        ValidationResult with pass/fail and message
    """
    if platform not in PLATFORM_REQUIREMENTS:
        return ValidationResult(
            False,
            f"Unknown platform: {platform}",
            'error'
        )

    file_path = Path(file_path)
    if not file_path.exists():
        return ValidationResult(
            False,
            f"File not found: {file_path}",
            'error'
        )

    try:
        with Image.open(file_path) as img:
            format_name = img.format.lower() if img.format else None
    except Exception as e:
        return ValidationResult(
            False,
            f"Could not read image format: {e}",
            'error'
        )

    allowed_formats = PLATFORM_REQUIREMENTS[platform]['formats']

    if format_name in allowed_formats:
        return ValidationResult(
            True,
            f"Format {format_name.upper()} is supported by {platform.title()}",
            'success'
        )
    else:
        return ValidationResult(
            False,
            f"Format {format_name.upper()} not supported by {platform.title()} (use {', '.join(allowed_formats).upper()})",
            'error'
        )


def calculate_contrast_ratio(color1: Tuple[int, int, int], color2: Tuple[int, int, int]) -> float:
    """
    Calculate contrast ratio between two RGB colors.
    Based on WCAG 2.0 formula.

    Args:
        color1: RGB tuple (r, g, b) 0-255
        color2: RGB tuple (r, g, b) 0-255

    Returns:
        Contrast ratio (1.0 to 21.0)
    """
    def relative_luminance(rgb):
        """Calculate relative luminance of an RGB color."""
        r, g, b = [c / 255.0 for c in rgb]

        # Apply gamma correction
        r = r / 12.92 if r <= 0.03928 else ((r + 0.055) / 1.055) ** 2.4
        g = g / 12.92 if g <= 0.03928 else ((g + 0.055) / 1.055) ** 2.4
        b = b / 12.92 if b <= 0.03928 else ((b + 0.055) / 1.055) ** 2.4

        return 0.2126 * r + 0.7152 * g + 0.0722 * b

    lum1 = relative_luminance(color1)
    lum2 = relative_luminance(color2)

    # Ensure lighter color is in numerator
    lighter = max(lum1, lum2)
    darker = min(lum1, lum2)

    return (lighter + 0.05) / (darker + 0.05)


def validate_contrast(
    text_color: Tuple[int, int, int],
    bg_color: Tuple[int, int, int],
    font_size: int = 16,
    is_bold: bool = False
) -> ValidationResult:
    """
    Validate contrast ratio meets WCAG requirements.

    Args:
        text_color: RGB tuple for text
        bg_color: RGB tuple for background
        font_size: Font size in pixels
        is_bold: Whether text is bold

    Returns:
        ValidationResult with WCAG compliance level
    """
    ratio = calculate_contrast_ratio(text_color, bg_color)

    # Determine if text is "large" (18pt+ or 14pt+ bold)
    # Assuming 16px = 12pt, so 1px = 0.75pt
    pt_size = font_size * 0.75
    is_large = pt_size >= 18 or (pt_size >= 14 and is_bold)

    # Check WCAG levels
    if is_large:
        min_aa = WCAG_AA_LARGE
        min_aaa = WCAG_AAA_LARGE
    else:
        min_aa = WCAG_AA_NORMAL
        min_aaa = WCAG_AAA_NORMAL

    if ratio >= min_aaa:
        return ValidationResult(
            True,
            f"Contrast ratio {ratio:.1f}:1 meets WCAG AAA standards ({min_aaa:.1f}:1 required)",
            'success'
        )
    elif ratio >= min_aa:
        return ValidationResult(
            True,
            f"Contrast ratio {ratio:.1f}:1 meets WCAG AA standards ({min_aa:.1f}:1 required)",
            'success'
        )
    else:
        return ValidationResult(
            False,
            f"Contrast ratio {ratio:.1f}:1 fails WCAG AA standards ({min_aa:.1f}:1 required)",
            'error'
        )


def hex_to_rgb(hex_color: str) -> Tuple[int, int, int]:
    """
    Convert hex color to RGB tuple.

    Args:
        hex_color: Hex color string (e.g., "#4F46E5" or "4F46E5")

    Returns:
        RGB tuple (r, g, b)
    """
    hex_color = hex_color.lstrip('#')
    return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))


def validate_all(file_path: str, platforms: List[str] = None) -> Dict[str, List[ValidationResult]]:
    """
    Run all validations on an image file for specified platforms.

    Args:
        file_path: Path to the image file
        platforms: List of platforms to validate against (default: ['facebook', 'twitter'])

    Returns:
        Dictionary of platform -> list of ValidationResults
    """
    if platforms is None:
        platforms = ['facebook', 'twitter']

    results = {}

    for platform in platforms:
        if platform not in PLATFORM_REQUIREMENTS:
            results[platform] = [
                ValidationResult(False, f"Unknown platform: {platform}", 'error')
            ]
            continue

        platform_results = [
            validate_file_size(file_path, platform),
            validate_dimensions(file_path, platform),
            validate_format(file_path, platform),
        ]

        results[platform] = platform_results

    return results


def print_validation_results(results: Dict[str, List[ValidationResult]], verbose: bool = True):
    """
    Print validation results in a formatted way.

    Args:
        results: Dictionary of platform -> list of ValidationResults
        verbose: If True, show all results; if False, only show warnings/errors
    """
    for platform, checks in results.items():
        print(f"\n{platform.title()} Validation:")
        print("=" * 70)

        for result in checks:
            if verbose or result.level in ['warning', 'error']:
                print(f"  {result}")

    # Summary
    total_checks = sum(len(checks) for checks in results.values())
    passed_checks = sum(1 for checks in results.values() for r in checks if r.passed)
    failed_checks = total_checks - passed_checks

    print(f"\n{'=' * 70}")
    print(f"Summary: {passed_checks}/{total_checks} checks passed")

    if failed_checks > 0:
        print(f"⚠ {failed_checks} issue(s) need attention")
    else:
        print("✓ All validations passed!")


if __name__ == '__main__':
    # Test the validators
    import sys

    if len(sys.argv) < 2:
        print("Usage: python validators.py <image_file>")
        sys.exit(1)

    file_path = sys.argv[1]

    print(f"Validating: {file_path}")
    results = validate_all(file_path, platforms=['facebook', 'twitter', 'linkedin'])
    print_validation_results(results)

    # Test contrast validation
    print(f"\n{'=' * 70}")
    print("Contrast Ratio Tests:")
    print("=" * 70)

    # Test cases
    test_cases = [
        ("White on Black", (255, 255, 255), (0, 0, 0), 16, False),
        ("Black on White", (0, 0, 0), (255, 255, 255), 16, False),
        ("Gray on White", (128, 128, 128), (255, 255, 255), 16, False),
        ("Purple on White", hex_to_rgb("#4F46E5"), (255, 255, 255), 16, False),
        ("White on Purple", (255, 255, 255), hex_to_rgb("#4F46E5"), 80, True),
    ]

    for name, text_color, bg_color, size, bold in test_cases:
        result = validate_contrast(text_color, bg_color, size, bold)
        print(f"  {name} ({size}px{'bold' if bold else ''}): {result}")