Complete API Reference

$options = [
    'category' => 'Technology',      // Feed category (string or array)
    'interval' => 300,               // Polling interval in seconds
    'keep_history' => true,          // Keep history of feed states
    'max_items' => 0,                // Maximum items to keep (0 = unlimited)
];

// Register a feed with custom options
$manager->registerFeed('hacker_news', 'https://news.ycombinator.com/rss', [
    'category' => 'Technology',
    'interval' => 300,
    'keep_history' => true,
    'max_items' => 100
]);

// Register with multiple categories
$manager->registerFeed('tech_news', 'https://example.com/feed.xml', [
    'category' => ['Technology', 'News'],
    'interval' => 600
]);

// Register multiple feeds
$feeds = [
    'techcrunch' => [
        'url' => 'https://techcrunch.com/feed/',
        'category' => 'Technology',
        'interval' => 600
    ],
    'bbc_news' => [
        'url' => 'https://bbc.com/news/world/rss.xml',
        'category' => 'News',
        'interval' => 900,
        'keep_history' => true
    ],
    'hacker_news' => 'https://news.ycombinator.com/rss' // Simple format
];

$manager->registerFeeds($feeds);

[
    'feed_id_1' => [
        'feed' => Feed,              // Updated feed object
        'new_items' => Feed,         // Feed containing only new items
        'new_items_count' => int,    // Number of new items
        'is_updated' => bool         // Whether feed was updated
    ],
    // ...
]

// Check for updates
$updates = $manager->checkUpdates();

// Process results
foreach ($updates as $feedId => $data) {
    if ($data['is_updated']) {
        echo "Feed '{$feedId}' has {$data['new_items_count']} new items\n";
        
        foreach ($data['new_items']->items() as $item) {
            echo "- {$item->title}\n";
        }
    }
}

// Export all feeds as JSON (for APIs)
$json = $manager->export('json');
header('Content-Type: application/json');
echo $json;

// Export specific feed as RSS
$rss = $manager->export('rss', 'hacker_news');
header('Content-Type: application/rss+xml');
echo $rss;

// Export as CSV for Excel
$csv = $manager->export('csv');
header('Content-Type: text/csv');
header('Content-Disposition: attachment; filename="feeds.csv"');
echo $csv;

// Export as HTML for web display
$html = $manager->export('html');
echo $html;

// Get all items from all feeds
$allItems = $manager->getAllItems();

echo "Total items: " . count($allItems) . "\n";

// Display latest items
foreach ($allItems as $item) {
    echo "{$item->publishedAt->format('Y-m-d H:i')} - {$item->title}\n";
    echo "  Source: {$item->category}\n";
    echo "  Link: {$item->link}\n\n";
}

// Register event handlers
$manager->on('feed:registered', function($data) {
    echo "Feed registered: {$data['feedId']}\n";
    echo "URL: {$data['url']}\n";
});

$manager->on('item:new', function($data) {
    $item = $data['item'];
    $feedId = $data['feedId'];
    
    // Send notification
    sendNotification("New item in {$feedId}: {$item->title}");
    
    // Save to database
    saveItemToDatabase($item);
});

$manager->on('feed:updated', function($data) {
    echo "Feed {$data['feedId']} updated with {$data['new_items_count']} new items\n";
});

// In your callback endpoint (e.g., websub-callback.php)
$body = file_get_contents('php://input');
$headers = getallheaders();

$result = $webSubManager->handleWebSubNotification(
    $body,
    $headers,
    function($items) {
        // Process new items
        foreach ($items as $item) {
            echo "New item: {$item['title']}\n";
            saveToDatabase($item);
            sendNotification($item);
        }
    }
);

if ($result['success']) {
    // Success - return 204 No Content
    http_response_code(204);
} else {
    // Error - return appropriate status
    http_response_code(400);
    echo $result['error'];
}

[
    'total_feeds' => int,
    'websub_enabled_feeds' => int,
    'verified_subscriptions' => int,
    'subscriptions' => array,
    'auto_subscribe' => bool,
    'fallback_polling' => bool
]

// Get subscription status
$status = $webSubManager->getSubscriptionStatus();

echo "Total feeds: {$status['total_feeds']}\n";
echo "WebSub enabled: {$status['websub_enabled_feeds']}\n";
echo "Verified subscriptions: {$status['verified_subscriptions']}\n";

foreach ($status['subscriptions'] as $subscription) {
    echo "Feed: {$subscription['feed_url']}\n";
    echo "Hub: {$subscription['hub_url']}\n";
    echo "Status: " . ($subscription['verified'] ? 'Verified' : 'Pending') . "\n";
    echo "Subscribed at: {$subscription['subscribed_at']}\n\n";
}

// Create HTTP handler for your endpoint
$handler = $webSubManager->getHandler();

// Set up notification callback
$handler->onNotification(function($notification) {
    // Process incoming notifications
    foreach ($notification['items'] as $item) {
        processNewItem($item);
    }
});

// In your endpoint file
$method = $_SERVER['REQUEST_METHOD'];
$query = $_GET;
$body = file_get_contents('php://input');
$headers = getallheaders();

$result = $handler->processRequest($method, $query, $body, $headers);

http_response_code($result['status']);
echo $result['body'];

// Get all items
$items = $feed->items();

echo "Total items: " . count($items) . "\n";

foreach ($items as $item) {
    echo "- {$item->title} ({$item->publishedAt->format('Y-m-d')})\n";
}

// Get items sorted by date (newest first)
$sortedItems = $feed->getItemsSorted(true);

// Get items sorted by date (oldest first)
$sortedItems = $feed->getItemsSorted(false);

// Display sorted items
foreach ($sortedItems as $item) {
    echo "{$item->publishedAt->format('Y-m-d H:i')} - {$item->title}\n";
}

// Find items by category
$techItems = $feed->findByCategory('Technology');
$newsItems = $feed->findByCategory('News');

echo "Technology items: " . count($techItems) . "\n";
echo "News items: " . count($newsItems) . "\n";

foreach ($techItems as $item) {
    echo "- {$item->title}\n";
}

// Search items by title
$results = $feed->searchByTitle('PHP');

echo "Found " . count($results) . " items containing 'PHP':\n";

foreach ($results as $item) {
    echo "- {$item->title}\n";
}

// Search with partial matches
$results = $feed->searchByTitle('tutorial'); // Matches 'Tutorial', 'tutorial', etc.

// Get latest 10 items
$latestItems = $feed->getLatest(10);

// Get latest 5 items
$latestItems = $feed->getLatest(5);

echo "Latest items:\n";
foreach ($latestItems as $item) {
    echo "{$item->publishedAt->format('H:i')} - {$item->title}\n";
}

// Get first page (items 1-10)
$page1 = $feed->paginate(1, 10);

// Get second page (items 11-20)
$page2 = $feed->paginate(2, 10);

// Get page 3 with 20 items per page
$page3 = $feed->paginate(3, 20);

echo "Page 1 items:\n";
foreach ($page1 as $item) {
    echo "- {$item->title}\n";
}

// Find items after January 1, 2024
$date = new DateTimeImmutable('2024-01-01');
$recentItems = $feed->findAfterDate($date);

// Find items after 24 hours ago
$yesterday = new DateTimeImmutable('-24 hours');
$recentItems = $feed->findAfterDate($yesterday);

echo "Items published in the last 24 hours:\n";
foreach ($recentItems as $item) {
    echo "- {$item->title}\n";
}

// Find items before January 1, 2024
$date = new DateTimeImmutable('2024-01-01');
$oldItems = $feed->findBeforeDate($date);

// Find items older than 30 days
$cutoff = new DateTimeImmutable('-30 days');
$oldItems = $feed->findBeforeDate($cutoff);

echo "Items older than 30 days:\n";
foreach ($oldItems as $item) {
    echo "- {$item->title} ({$item->publishedAt->format('Y-m-d')})\n";
}

// Store original feed content
$xmlContent = file_get_contents('https://example.com/feed.xml');
$feed->setOriginalContent($xmlContent);

// Later retrieve it
$original = $feed->getOriginalContent();

// Detect WebSub hub
$hubUrl = WebSubSubscriber::detectHubFromFeed($original);
if ($hubUrl) {
    echo "WebSub hub found: {$hubUrl}\n";
}

// Convert feed to array
$feedArray = $feed->toArray();

echo "Feed URL: {$feedArray['url']}\n";
echo "Feed title: {$feedArray['title']}\n";
echo "Total items: {$feedArray['items_count']}\n";

// Convert to JSON
$json = json_encode($feed->toArray(), JSON_PRETTY_PRINT);
file_put_contents('feed.json', $json);

[
    'url' => string,
    'title' => string,
    'total_items' => int,
    'first_item_date' => string|null,
    'latest_item_date' => string|null,
    'categories' => array,
    'items_with_enclosures' => int,
    'duplicate_stats' => array
]

// Get feed metadata
$metadata = $feed->getMetadata();

echo "Feed: {$metadata['title']}\n";
echo "URL: {$metadata['url']}\n";
echo "Total items: {$metadata['total_items']}\n";
echo "First item: {$metadata['first_item_date']}\n";
echo "Latest item: {$metadata['latest_item_date']}\n";
echo "Categories: " . implode(', ', $metadata['categories']) . "\n";
echo "Items with enclosures: {$metadata['items_with_enclosures']}\n";

// Get duplicate statistics
$stats = $feed->getDuplicateStats();

echo "Total fingerprints: {$stats['total_fingerprints']}\n";
echo "Unique items: {$stats['unique_items']}\n";
echo "Duplicate map size: {$stats['duplicate_map_size']}\n";

// Calculate duplicates prevented
$duplicatesPrevented = $stats['duplicate_map_size'] - $stats['unique_items'];
echo "Duplicates prevented: {$duplicatesPrevented}\n";

// Get nested extra field
$authorName = $item->getExtra('author.name');
$thumbnail = $item->getExtra('media.thumbnail.0.url');

// With default value
$rating = $item->getExtra('rating', 0);
$comments = $item->getExtra('comments.count', 0);

// Check if field exists
if ($item->hasExtra('custom.field')) {
    $value = $item->getExtra('custom.field');
    echo "Custom field value: {$value}\n";
}

// Get all extra fields
$allExtra = $item->getExtraFields();
print_r($allExtra);

// Compare two items
if ($item1->equals($item2)) {
    echo "Items are identical\n";
} else {
    echo "Items are different\n";
}

// Check if items are similar (content-based)
if ($item1->isSimilar($item2)) {
    echo "Items are similar (may be same article from different sources)\n";
}

// Compare with specific strategy
$fingerprint1 = $item1->fingerprint('content');
$fingerprint2 = $item2->fingerprint('content');
if ($fingerprint1 === $fingerprint2) {
    echo "Items have identical content\n";
}

// Create item with one category
$item = new FeedItem(...);

// Create new item with different category
$categorizedItem = $item->withCategory('Technology');

echo "Original category: {$item->category}\n";
echo "New category: {$categorizedItem->category}\n";

// The original item is unchanged
assert($item->category !== $categorizedItem->category);

// Convert item to array
$itemArray = $item->toArray();

echo "Item ID: {$itemArray['id']}\n";
echo "Title: {$itemArray['title']}\n";
echo "Published: {$itemArray['publishedAt']}\n";
echo "Fingerprint: {$itemArray['fingerprint']}\n";

// Convert to JSON
$json = json_encode($item->toArray(), JSON_PRETTY_PRINT);
echo $json;

[
    'id' => string,
    'title' => string,
    'link' => string,
    'content' => string|null,
    'enclosure' => string|null,
    'publishedAt' => string, // ISO 8601 format
    'category' => string|null,
    'extra' => array,
    'fingerprint' => string
]

[
    'id' => string,
    'title' => string,
    'url' => string,
    'category' => string|null,
    'published_date' => string, // ISO 8601 format
    'has_content' => bool,
    'has_enclosure' => bool,
    'extra_fields_count' => int,
    'fingerprint_default' => string,
    'fingerprint_content' => string,
    'fingerprint_fuzzy' => string
]

// Check if item is valid
if ($item->isValid()) {
    echo "Item is valid\n";
} else {
    echo "Item is missing required fields\n";
}

// Invalid item example
$invalidItem = new FeedItem(
    id: '', // Empty ID
    title: 'Test',
    link: '', // Empty link
    content: null,
    enclosure: null,
    publishedAt: new DateTimeImmutable(),
    category: null
);

if (!$invalidItem->isValid()) {
    echo "Invalid item: missing ID or link\n";
}

// Get all items from all feeds
$allItems = $collection->getAllItems();

echo "Total items in collection: " . count($allItems) . "\n";

// Items are automatically categorized with feed's category
foreach ($allItems as $item) {
    echo "{$item->title} [{$item->category}]\n";
}

// Get items by exact category match
$techItems = $collection->getItemsByCategory('Technology');

// Get items by partial match (e.g., "سمنان" matches "اخبار استان ها > سمنان")
$semnanItems = $collection->getItemsByCategory('سمنان');

// Display results
echo "Technology items: " . count($techItems) . "\n";
foreach ($techItems as $item) {
    echo "- {$item->title}\n";
}

// Partial matching example
$category = 'اخبار استان ها > سمنان';
$collection->addFeed('semnan_news', $feed, $category);

// Both searches will match
$items1 = $collection->getItemsByCategory('سمنان'); // Partial match
$items2 = $collection->getItemsByCategory('اخبار استان ها > سمنان'); // Exact match

// Search across all feeds
$results = $collection->searchItems('آتش');

echo "Found " . count($results) . " items matching 'آتش':\n";

foreach ($results as $item) {
    $source = "Unknown";
    foreach ($collection->getAllFeeds() as $feedId => $feed) {
        if (in_array($item, $feed->items(), true)) {
            $source = $feedId;
            break;
        }
    }
    echo "- {$item->title} [{$source}]\n";
}

// Case-insensitive search
$results = $collection->searchItems('php'); // Matches 'PHP', 'php', 'Php'

// Search in multiple languages
$results = $collection->searchItems('ایران'); // Persian search
$results = $collection->searchItems('Iran'); // English search

// Get latest 10 items
$latest = $collection->getLatestItems(10);

// Get latest 5 items
$latest = $collection->getLatestItems(5);

echo "Latest items:\n";
foreach ($latest as $item) {
    $timeAgo = time_ago($item->publishedAt);
    echo "- {$item->title} ({$timeAgo})\n";
    echo "  Category: {$item->category}\n";
    echo "  Source: " . getFeedSource($item) . "\n\n";
}

// Get latest items by category
$latestTech = $collection->getLatestItemsByCategory('Technology', 5);
$latestNews = $collection->getLatestItemsByCategory('News', 5);

[
    'total_feeds' => int,
    'total_categories' => int,
    'total_items' => int,
    'categories' => [
        'category_name' => [
            'feeds_count' => int,
            'items_count' => int
        ],
        // ...
    ],
    'categories_list' => array,
    'feeds_list' => array
]

// Get collection statistics
$stats = $collection->getStats();

echo "Collection Statistics:\n";
echo "Total feeds: {$stats['total_feeds']}\n";
echo "Total categories: {$stats['total_categories']}\n";
echo "Total items: {$stats['total_items']}\n\n";

echo "Categories:\n";
foreach ($stats['categories'] as $category => $catStats) {
    echo "- {$category}: {$catStats['feeds_count']} feeds, {$catStats['items_count']} items\n";
}

echo "\nAll categories: " . implode(', ', $stats['categories_list']) . "\n";
echo "All feeds: " . implode(', ', $stats['feeds_list']) . "\n";

// Get collection metadata
$metadata = $collection->getMetadata();

echo "Metadata:\n";
echo "Earliest item: {$metadata['earliest_item']}\n";
echo "Latest item: {$metadata['latest_item']}\n";
echo "Feeds with enclosures: {$metadata['feeds_with_enclosures']}\n\n";

// Access stats through metadata
echo "Stats from metadata:\n";
print_r($metadata['stats']);

// Export collection to array
$array = $collection->toArray();

// Export to JSON
$json = $collection->toJSON(true); // Pretty print
file_put_contents('collection.json', $json);

// Export to JSON without pretty print (for APIs)
$json = $collection->toJSON(false);
header('Content-Type: application/json');
echo $json;

// Fetch multiple feeds
$urls = [
    'hacker_news' => 'https://news.ycombinator.com/rss',
    'techcrunch' => [
        'url' => 'https://techcrunch.com/feed/',
        'category' => 'Technology'
    ],
    'bbc_news' => 'https://bbc.com/news/world/rss.xml'
];

$feeds = $fetcher->fetchMultiple($urls);

echo "Fetched " . count($feeds) . " feeds:\n";
foreach ($feeds as $feedId => $feed) {
    echo "- {$feedId}: {$feed->title} ({$feed->itemsCount()} items)\n";
}

// Handle failures gracefully
$feeds = $fetcher->fetchMultiple($urls);
$successCount = count($feeds);
$totalCount = count($urls);

if ($successCount < $totalCount) {
    $failedCount = $totalCount - $successCount;
    echo "Warning: {$failedCount} feeds failed to fetch\n";
}

// Check for new items
$oldFeed = $fetcher->fetch('https://example.com/feed.xml');
sleep(60); // Wait for possible updates
$newFeed = $fetcher->fetch('https://example.com/feed.xml');

if ($fetcher->hasNewItems($oldFeed, $newFeed)) {
    echo "Feed has new items!\n";
    
    // Get only new items
    $newItemsFeed = $fetcher->getNewItems($oldFeed, $newFeed);
    
    echo "New items count: {$newItemsFeed->itemsCount()}\n";
    foreach ($newItemsFeed->items() as $item) {
        echo "- {$item->title}\n";
    }
} else {
    echo "No new items\n";
}

// Get new items between two feed versions
$newItemsFeed = $fetcher->getNewItems($oldFeed, $newFeed);

// The returned Feed contains only new items
echo "New items found: {$newItemsFeed->itemsCount()}\n";

// Process new items
foreach ($newItemsFeed->items() as $item) {
    processNewItem($item);
    sendNotification($item);
    saveToDatabase($item);
}

// You can also use this with FeedManager events
$manager->on('item:new', function($data) {
    $item = $data['item'];
    // Process each new item
});

// For development (self-signed certificates)
$fetcher->setVerifySSL(false);

// For production (always verify)
$fetcher->setVerifySSL(true);

// Set custom CA bundle path
$fetcher->setCaBundlePath('/path/to/cacert.pem');

// Set timeout to 30 seconds (default)
$fetcher->setTimeout(30);

// Set shorter timeout for fast-failing
$fetcher->setTimeout(10);

// Set longer timeout for slow feeds
$fetcher->setTimeout(60);

// Combine with other settings
$fetcher
    ->setTimeout(30)
    ->setMaxRedirects(5)
    ->setUserAgent('MyApp/1.0')
    ->addHeader('Accept', 'application/xml, application/json');

[
    'feed_id' => [
        'feed' => Feed,              // Updated feed object
        'new_items' => Feed,         // Feed containing only new items
        'is_updated' => bool         // Whether feed was updated
    ],
    // ...
]

// Check for updates (usually called periodically)
$updates = $scheduler->checkUpdates();

foreach ($updates as $feedId => $data) {
    if ($data['is_updated']) {
        $newItemsCount = $data['new_items']->itemsCount();
        echo "Feed '{$feedId}' updated with {$newItemsCount} new items\n";
        
        // Process new items
        foreach ($data['new_items']->items() as $item) {
            processNewItem($item);
        }
        
        // Update statistics
        updateFeedStatistics($feedId, $newItemsCount);
    }
}

// This is typically used in a cron job or background task
// Example cron job: * * * * * php /path/to/check-updates.php

// Force update a specific feed
if ($scheduler->forceUpdate('tech_news')) {
    echo "Feed force-updated successfully\n";
    
    // Get the updated feed
    $feed = $scheduler->getFeed('tech_news');
    echo "Latest items: {$feed->itemsCount()}\n";
} else {
    echo "Feed not found or update failed\n";
}

// Force update all feeds
$forceUpdated = $manager->forceUpdateAll();
echo "Force updated " . count($forceUpdated) . " feeds\n";

[
    'feed_id' => string,
    'url' => string,
    'last_update' => string,     // ISO 8601 format
    'next_update' => string,     // ISO 8601 format
    'interval' => int,
    'seconds_since_update' => int,
    'items_count' => int
]

// Get feed status
$status = $scheduler->getStatus('tech_news');

if ($status) {
    echo "Feed: {$status['feed_id']}\n";
    echo "URL: {$status['url']}\n";
    echo "Last update: {$status['last_update']}\n";
    echo "Next update: {$status['next_update']}\n";
    echo "Interval: {$status['interval']} seconds\n";
    echo "Seconds since update: {$status['seconds_since_update']}\n";
    echo "Items count: {$status['items_count']}\n";
    
    // Check if update is due
    if ($status['seconds_since_update'] >= $status['interval']) {
        echo "Update is due!\n";
    }
}

// Get status for all feeds
$allStatus = $scheduler->getAllStatus();
foreach ($allStatus as $feedId => $status) {
    // Process each feed's status
}

// Get feed history
$history = $scheduler->getHistory('tech_news');

if ($history) {
    echo "Feed history (last " . count($history) . " versions):\n";
    
    foreach ($history as $index => $feed) {
        $date = $feed->items()[0]->publishedAt ?? new DateTimeImmutable();
        echo "Version {$index}: {$feed->itemsCount()} items ({$date->format('Y-m-d H:i')})\n";
    }
    
    // Compare current with previous version
    if (count($history) >= 2) {
        $current = $history[count($history) - 1];
        $previous = $history[count($history) - 2];
        
        $newItems = $fetcher->getNewItems($previous, $current);
        echo "New items in last update: {$newItems->itemsCount()}\n";
    }
}

// Parse feed content
$parser = new AtomParser();
$content = file_get_contents('https://example.com/atom.xml');

try {
    $feed = $parser->parse($content, 'https://example.com/atom.xml');
    
    echo "Feed title: {$feed->title}\n";
    echo "Items parsed: {$feed->itemsCount()}\n";
    
    // Store original content for WebSub detection
    $feed->setOriginalContent($content);
} catch (Exception $e) {
    echo "Parse error: " . $e->getMessage() . "\n";
}

// Parse any feed format automatically
$parser = AutoDetectParser::createDefault();

// Feed content (could be RSS, Atom, JSON Feed, etc.)
$content = file_get_contents('https://example.com/feed');

try {
    $feed = $parser->parse($content, 'https://example.com/feed');
    
    echo "Feed format detected automatically\n";
    echo "Title: {$feed->title}\n";
    echo "Items: {$feed->itemsCount()}\n";
    
    // The parser automatically used the correct parser:
    // - Rss20Parser for RSS 2.0
    // - AtomParser for Atom
    // - JsonFeedParser for JSON Feed
    // - RdfParser for RDF/RSS 1.0
    // - GeoRssParser for GeoRSS
    
} catch (RuntimeException $e) {
    echo "Unsupported feed format: " . $e->getMessage() . "\n";
    echo "Supported formats: GeoRSS, RSS 2.0, Atom, JSON Feed, RDF/RSS 1.0\n";
}

// In your callback endpoint (websub-callback.php)
$params = $_GET;

$result = $subscriber->verifyChallenge($params);

if ($result['success']) {
    // Return the challenge to complete verification
    echo $result['challenge'];
} else {
    http_response_code(403);
    echo "Verification failed: {$result['error']}";
}

// In your callback endpoint for POST requests
$body = file_get_contents('php://input');
$headers = getallheaders();

$result = $subscriber->handleNotification($body, $headers);

if ($result['success']) {
    // Process the new items
    echo "Received {$result['items_count']} new items\n";
    
    foreach ($result['items'] as $item) {
        echo "- {$item['title']}\n";
        echo "  Link: {$item['link']}\n";
        echo "  Published: {$item['pubDate']}\n";
        
        // Save to database, send notifications, etc.
        saveItemToDatabase($item);
    }
    
    // Return 204 No Content to acknowledge receipt
    http_response_code(204);
} else {
    http_response_code(400);
    echo "Invalid notification: {$result['error']}";
}

// Fetch feed and detect hub
$feedContent = file_get_contents('https://example.com/feed.xml');
$hubUrl = WebSubSubscriber::detectHubFromFeed($feedContent);

if ($hubUrl) {
    echo "WebSub hub detected: {$hubUrl}\n";
    
    // Subscribe to the hub
    $subscriber->subscribe('https://example.com/feed.xml', $hubUrl);
} else {
    echo "No WebSub hub found in feed\n";
}

// Get status for specific feed
$status = $subscriber->getSubscriptionStatus('https://example.com/feed.xml');

// Get status for all subscriptions
$allStatus = $subscriber->getSubscriptionStatus();

echo "Total subscriptions: {$allStatus['total_subscriptions']}\n";

foreach ($allStatus['subscriptions'] as $subscription) {
    echo "Feed: {$subscription['feed_url']}\n";
    echo "Hub: {$subscription['hub_url']}\n";
    echo "Verified: " . ($subscription['verified'] ? 'Yes' : 'No') . "\n";
    echo "Subscribed at: {$subscription['subscribed_at']}\n";
    echo "Lease seconds: {$subscription['lease_seconds']}\n\n";
}

// Complete WebSub callback endpoint example
// Save as websub-callback.php

require_once 'vendor/autoload.php';

use Hosseinhunta\Huntfeed\WebSub\WebSubSubscriber;
use Hosseinhunta\Huntfeed\WebSub\WebSubHandler;
use Hosseinhunta\Huntfeed\Transport\FeedFetcher;

// Get request data
$method = $_SERVER['REQUEST_METHOD'];
$query = $_GET;
$body = file_get_contents('php://input');

// Get headers
$headers = [];
foreach ($_SERVER as $key => $value) {
    if (strpos($key, 'HTTP_') === 0) {
        $headerName = str_replace('HTTP_', '', $key);
        $headerName = str_replace('_', '-', $headerName);
        $headers[$headerName] = $value;
    }
}

// Create components
$fetcher = new FeedFetcher();
$subscriber = new WebSubSubscriber(
    $fetcher,
    'https://your-domain.com/websub-callback.php'
);

$handler = new WebSubHandler($subscriber);

// Set up notification processing
$handler->onNotification(function($notification) {
    // Process incoming feed items
    $pdo = new PDO('mysql:host=localhost;dbname=feeds', 'username', 'password');
    
    foreach ($notification['items'] as $item) {
        $stmt = $pdo->prepare('INSERT INTO feed_items (title, link, content, published_at) VALUES (?, ?, ?, ?)');
        $stmt->execute([
            $item['title'],
            $item['link'],
            $item['description'] ?? '',
            $item['pubDate'] ?? date('Y-m-d H:i:s')
        ]);
        
        // Send notification via email, Slack, etc.
        sendSlackMessage("New item: {$item['title']}");
    }
});

// Process the request
$result = $handler->processRequest($method, $query, $body, $headers);

// Send response
http_response_code($result['status'] ?? 200);
if (isset($result['body'])) {
    echo $result['body'];
}

// Optional: Log the request
file_put_contents('websub.log', date('Y-m-d H:i:s') . " - {$method} - " . json_encode($result) . "\n", FILE_APPEND);

<?php
// Add this to your public HTTP endpoint (e.g., /websub-callback.php)

// Get request data
$method = $_SERVER['REQUEST_METHOD'];
$query = $_GET;
$body = file_get_contents('php://input');

// Get headers
$headers = [];
foreach ($_SERVER as $key => $value) {
    if (strpos($key, 'HTTP_') === 0) {
        $headerName = str_replace('HTTP_', '', $key);
        $headerName = str_replace('_', '-', $headerName);
        $headers[$headerName] = $value;
    }
}

// Create handler and process
$subscriber = new WebSubSubscriber($fetcher, 'http://your-domain.com/websub-callback.php');

$handler = new WebSubHandler($subscriber);
$handler->onNotification(function($notification) {
    // Process incoming notification
    // $notification contains 'items_count' and 'items'
    
    // Add items to your database or feed manager
    foreach ($notification['items'] as $item) {
        // Save to database or process
    }
});

$result = $handler->processRequest($method, $query, $body, $headers);

// Send response
http_response_code($result['status'] ?? 200);
echo $result['body'] ?? '';

// Export to RSS
$rss = FeedExporter::toRSS($feed);

// For RSS feed endpoint
header('Content-Type: application/rss+xml');
echo $rss;

// Save to file
file_put_contents('export.rss', $rss);

// RSS output includes:
// - Channel information
// - All items with title, link, description, pubDate, guid
// - Categories and enclosures if present
// - Atom namespace for compatibility

// Export to CSV
$csv = FeedExporter::toCSV($feed, true); // With header row

// For download
header('Content-Type: text/csv');
header('Content-Disposition: attachment; filename="feed-export.csv"');
echo $csv;

// CSV format:
// ID,Title,Link,Category,Published Date,Has Content,Has Enclosure
// "item-123","Example Article","https://example.com/article","Technology","2024-01-15 10:30:00","Yes","No"
// ...

// Export to HTML
$html = FeedExporter::toHTML($feed);

// Output directly
echo $html;

// Or save to file
file_put_contents('feed-export.html', $html);

// HTML includes:
// - Full HTML document with CSS styles
// - Feed header with title and URL
// - All items in styled divs
// - Responsive design
// - Clean, readable presentation

// Export to plain text
$text = FeedExporter::toText($feed);

// For email or plain text display
echo $text;

// Text format:
// Feed: Example Feed
// URL: https://example.com/feed.xml
// Items: 10
// ================================================
// 
// Title: Example Article
// Link: https://example.com/article
// Published: 2024-01-15 10:30:00
// Category: Technology
// Content: Article content excerpt...
// -------------------------------------------------