Enumerations and Constants

class Urgency(Enum):
    Critical = "critical"
    """
    Critical urgency level for important system alerts.
    
    - May bypass do-not-disturb settings
    - Often displayed with prominent visual styling (red, flashing)
    - Typically remains visible until explicitly dismissed
    - Used for: System errors, security alerts, urgent messages
    """
    
    Normal = "normal" 
    """
    Normal urgency level for standard notifications.
    
    - Default urgency level if not specified
    - Standard system notification appearance and behavior
    - Respects user's do-not-disturb and notification settings
    - Auto-dismisses after system timeout period
    - Used for: Regular app notifications, informational messages
    """
    
    Low = "low"
    """
    Low urgency level for informational notifications.
    
    - Less prominent visual styling
    - May be suppressed during focused work modes
    - Shorter display timeout on some platforms
    - Used for: Background task completion, non-critical updates
    """

class Capability(Enum):
    APP_NAME = auto()
    """Support for custom application name in notifications"""
    
    TITLE = auto()
    """Support for notification title text"""
    
    MESSAGE = auto()
    """Support for notification message body text"""
    
    URGENCY = auto()
    """Support for urgency level specification (Critical, Normal, Low)"""
    
    ICON = auto()
    """Support for custom notification icons"""
    
    ICON_FILE = auto()
    """Support for file-based notification icons (path/URI)"""
    
    ICON_NAME = auto()
    """Support for system-named notification icons"""
    
    BUTTONS = auto()
    """Support for interactive notification buttons"""
    
    REPLY_FIELD = auto()
    """Support for text input fields in notifications"""
    
    ATTACHMENT = auto()
    """Support for file attachments with preview"""
    
    ON_DISPATCHED = auto()
    """Support for dispatch event callbacks"""
    
    ON_CLICKED = auto()
    """Support for notification click callbacks"""
    
    ON_DISMISSED = auto()
    """Support for notification dismissal callbacks"""
    
    SOUND = auto()
    """Support for custom notification sounds"""
    
    SOUND_FILE = auto()
    """Support for file-based notification sounds"""
    
    SOUND_NAME = auto()
    """Support for system-named notification sounds"""
    
    THREAD = auto()
    """Support for notification grouping/threading"""
    
    TIMEOUT = auto()
    """Support for custom notification timeout durations"""

DEFAULT_ICON: Icon
"""
Default Python icon included with the desktop-notifier package.

This icon is used when no custom icon is specified for the DesktopNotifier
instance or individual notifications. Points to a bundled Python logo icon
suitable for cross-platform use.
"""

DEFAULT_SOUND: Sound
"""
Default system notification sound appropriate for the current platform.

Resolves to:
- macOS: System default notification sound
- Windows: Default Windows notification sound  
- Linux: Default freedesktop notification sound
- Other platforms: System default or silent fallback
"""

from desktop_notifier import DesktopNotifier, Capability
import asyncio

async def check_platform_capabilities():
    notifier = DesktopNotifier(app_name="Capability Test")
    
    # Get all supported capabilities for current platform
    capabilities = await notifier.get_capabilities()
    
    print("Supported features on this platform:")
    for capability in capabilities:
        print(f"  - {capability.name}")
    
    # Check for specific features
    if Capability.BUTTONS in capabilities:
        print("✓ Interactive buttons are supported")
    else:
        print("✗ Interactive buttons not supported")
    
    if Capability.REPLY_FIELD in capabilities:
        print("✓ Reply fields are supported")
    else:
        print("✗ Reply fields not supported")
    
    if Capability.ATTACHMENT in capabilities:
        print("✓ File attachments are supported")
    else:
        print("✗ File attachments not supported")

asyncio.run(check_platform_capabilities())

from desktop_notifier import DesktopNotifier, Capability, Urgency, Button
import asyncio

async def send_adaptive_notification():
    notifier = DesktopNotifier(app_name="Adaptive App")
    capabilities = await notifier.get_capabilities()
    
    # Base notification
    title = "Task Complete"
    message = "Your data processing job has finished successfully"
    urgency = Urgency.Normal
    
    # Add buttons only if supported
    buttons = []
    if Capability.BUTTONS in capabilities:
        buttons = [
            Button(title="View Results", on_pressed=lambda: print("Opening results")),
            Button(title="Dismiss", on_pressed=lambda: print("Dismissed"))
        ]
    
    # Add sound only if supported
    sound = None
    if Capability.SOUND in capabilities:
        from desktop_notifier import DEFAULT_SOUND
        sound = DEFAULT_SOUND
    
    # Send notification with platform-appropriate features
    await notifier.send(
        title=title,
        message=message,
        urgency=urgency,
        buttons=buttons,
        sound=sound,
        on_clicked=lambda: print("Notification clicked") if Capability.ON_CLICKED in capabilities else None
    )

asyncio.run(send_adaptive_notification())

from desktop_notifier import DesktopNotifier, Urgency
import asyncio

async def demonstrate_urgency_levels():
    notifier = DesktopNotifier(app_name="Urgency Demo")
    
    # Low priority notification (background task)
    await notifier.send(
        title="Backup Complete",
        message="Scheduled backup finished at 2:30 AM",
        urgency=Urgency.Low
    )
    
    # Normal priority notification (default)
    await notifier.send(
        title="Email Received", 
        message="New message from your colleague",
        urgency=Urgency.Normal  # Can be omitted as it's default
    )
    
    # Critical priority notification (urgent action needed)
    await notifier.send(
        title="Security Alert",
        message="Unusual login attempt detected from new location",
        urgency=Urgency.Critical,
        timeout=0,  # Make it sticky
        buttons=[
            Button(title="Review", on_pressed=lambda: print("Opening security review")),
            Button(title="Block", on_pressed=lambda: print("Blocking suspicious activity"))
        ]
    )

asyncio.run(demonstrate_urgency_levels())

from desktop_notifier import DesktopNotifier, DEFAULT_ICON, DEFAULT_SOUND
from desktop_notifier import Icon, Sound
from pathlib import Path

# Using package defaults
notifier_with_defaults = DesktopNotifier(
    app_name="Default Resources App",
    app_icon=DEFAULT_ICON  # Uses bundled Python icon
)

# Custom notifier with fallback to defaults
custom_icon_path = Path("./app-icon.png")
app_icon = Icon(path=custom_icon_path) if custom_icon_path.exists() else DEFAULT_ICON

notifier_with_fallback = DesktopNotifier(
    app_name="Fallback App",
    app_icon=app_icon
)

# Send notification with default sound
async def send_with_defaults():
    await notifier_with_defaults.send(
        title="Using Defaults",
        message="This notification uses the default Python icon and system sound",
        sound=DEFAULT_SOUND
    )

import asyncio
asyncio.run(send_with_defaults())

import platform
from desktop_notifier import DesktopNotifier, Capability
import asyncio

async def show_platform_differences():
    notifier = DesktopNotifier(app_name="Platform Info")
    capabilities = await notifier.get_capabilities()
    
    system = platform.system()
    print(f"\nNotification capabilities on {system}:")
    
    # Common capabilities across platforms
    always_supported = {
        Capability.APP_NAME, Capability.TITLE, Capability.MESSAGE,
        Capability.URGENCY, Capability.ON_DISPATCHED
    }
    
    # Platform-specific feature availability
    platform_features = {
        "Darwin": {  # macOS
            "Strong support": [Capability.BUTTONS, Capability.REPLY_FIELD, 
                              Capability.ATTACHMENT, Capability.SOUND_NAME],
            "Limited support": [Capability.TIMEOUT],
            "No support": []
        },
        "Windows": {  # Windows 10+
            "Strong support": [Capability.BUTTONS, Capability.ATTACHMENT, 
                              Capability.SOUND_NAME, Capability.THREAD],
            "Limited support": [Capability.REPLY_FIELD],
            "No support": [Capability.TIMEOUT]
        },
        "Linux": {  # freedesktop.org compliant
            "Strong support": [Capability.ICON_NAME, Capability.TIMEOUT, 
                              Capability.URGENCY],
            "Limited support": [Capability.BUTTONS, Capability.SOUND_NAME],
            "No support": [Capability.REPLY_FIELD, Capability.ATTACHMENT]
        }
    }
    
    if system in platform_features:
        for support_level, features in platform_features[system].items():
            print(f"\n{support_level}:")
            for feature in features:
                status = "✓" if feature in capabilities else "✗"
                print(f"  {status} {feature.name}")

asyncio.run(show_platform_differences())