// Package cmd provides CLI commands for the feed-mcp server.
package cmd

import (
        "context"
        "time"

        "github.com/richardwooding/feed-mcp/mcpserver"
        "github.com/richardwooding/feed-mcp/model"
        "github.com/richardwooding/feed-mcp/store"
)

// RunCmd holds the command line arguments and flags for the run command
type RunCmd struct {
        Transport       string        `name:"transport" default:"stdio" enum:"stdio,http-with-sse" help:"Transport to use for the MCP server."`
        Feeds           []string      `arg:"" name:"feeds" optional:"" help:"Feeds to list (cannot be used with --opml)."`
        OPML            string        `name:"opml" help:"OPML file path or URL to load feed URLs from (cannot be used with feeds)."`
        ExpireAfter     time.Duration `name:"expire-after" default:"1h" help:"Expire feeds after this duration."`
        Timeout         time.Duration `name:"timeout" default:"30s" help:"Timeout for fetching feed."`
        ShutdownTimeout time.Duration `name:"shutdown-timeout" default:"30s" help:"Timeout for graceful shutdown."`
        // HTTP connection pooling settings
        MaxIdleConns        int           `name:"max-idle-conns" default:"100" help:"Maximum number of idle HTTP connections across all hosts."`
        MaxConnsPerHost     int           `name:"max-conns-per-host" default:"10" help:"Maximum number of connections per host."`
        MaxIdleConnsPerHost int           `name:"max-idle-conns-per-host" default:"5" help:"Maximum number of idle connections per host."`
        IdleConnTimeout     time.Duration `name:"idle-conn-timeout" default:"90s" help:"How long an idle connection remains idle before closing."`
        // Retry mechanism settings
        RetryMaxAttempts int           `name:"retry-max-attempts" default:"3" help:"Maximum number of retry attempts for failed feed fetches."`
        RetryBaseDelay   time.Duration `name:"retry-base-delay" default:"1s" help:"Base delay for exponential backoff between retry attempts."`
        RetryMaxDelay    time.Duration `name:"retry-max-delay" default:"30s" help:"Maximum delay between retry attempts."`
        RetryJitter      bool          `name:"retry-jitter" default:"true" help:"Enable jitter in retry delays to avoid thundering herd."`
        // Security settings
        AllowPrivateIPs bool `name:"allow-private-ips" default:"false" help:"Allow feed URLs that resolve to private IP ranges or localhost (disabled by default for security)."`
        // Runtime feed management settings
        AllowRuntimeFeeds bool `name:"allow-runtime-feeds" default:"false" help:"Enable runtime feed management tools (add_feed, remove_feed, list_managed_feeds)."`
}

// Run executes the feed MCP server with the given configuration
func (c *RunCmd) Run(globals *model.Globals, ctx context.Context) error {
        transport, err := model.ParseTransport(c.Transport)
        if err != nil {
                return err
        }

        // Determine the feed URLs to use
        var feedURLs []string

        // Check for mutually exclusive options
        if c.OPML != "" && len(c.Feeds) > 0 {
                return model.NewFeedError(model.ErrorTypeConfiguration, "cannot specify both --opml and feed URLs").
                        WithOperation("run_command").
                        WithComponent("cli")
        }

        if c.OPML != "" {
                // Load feed URLs from OPML
                feedURLs, err = model.LoadFeedURLsFromOPML(c.OPML)
                if err != nil {
                        return err
                }
        } else if len(c.Feeds) > 0 {
                // Use directly specified feeds
                feedURLs = c.Feeds
        } else if !c.AllowRuntimeFeeds {
                // Only require feeds if runtime feed management is disabled
                return model.NewFeedError(model.ErrorTypeConfiguration, "no feeds specified - use either feed URLs or --opml").
                        WithOperation("run_command").
                        WithComponent("cli")
        } else {
                // Allow starting with no feeds when runtime feed management is enabled
                feedURLs = []string{}
        }

        // Validate feed URLs for security (skip validation if no URLs and runtime feeds are allowed)
        if len(feedURLs) > 0 {
                if err := model.SanitizeFeedURLs(feedURLs, c.AllowPrivateIPs); err != nil {
                        return err
                }
        }

        storeConfig := store.Config{
                Feeds:               feedURLs,
                OPML:                c.OPML, // Pass OPML path for metadata source detection
                Timeout:             c.Timeout,
                ExpireAfter:         c.ExpireAfter,
                MaxIdleConns:        c.MaxIdleConns,
                MaxConnsPerHost:     c.MaxConnsPerHost,
                MaxIdleConnsPerHost: c.MaxIdleConnsPerHost,
                IdleConnTimeout:     c.IdleConnTimeout,
                RetryMaxAttempts:    c.RetryMaxAttempts,
                RetryBaseDelay:      c.RetryBaseDelay,
                RetryMaxDelay:       c.RetryMaxDelay,
                RetryJitter:         c.RetryJitter,
                AllowPrivateIPs:     c.AllowPrivateIPs,
        }

        serverConfig := mcpserver.Config{
                Transport: transport,
        }

        if c.AllowRuntimeFeeds {
                // Use DynamicStore for runtime feed management
                dynamicStore, err := store.NewDynamicStore(&storeConfig, true)
                if err != nil {
                        return err
                }
                serverConfig.AllFeedsGetter = dynamicStore
                serverConfig.FeedAndItemsGetter = dynamicStore
                serverConfig.DynamicFeedManager = dynamicStore
        } else {
                // Use regular Store
                feedStore, err := store.NewStore(&storeConfig)
                if err != nil {
                        return err
                }
                serverConfig.AllFeedsGetter = feedStore
                serverConfig.FeedAndItemsGetter = feedStore
        }

        server, err := mcpserver.NewServer(serverConfig)
        if err != nil {
                return err
        }
        return server.Run(ctx)
}

// Package examples demonstrates MCP Resources usage patterns for feed-mcp.
// This file provides comprehensive examples of how to integrate with and use
// the MCP Resources API for various feed management scenarios.
package examples

import (
        "context"
        "encoding/json"
        "fmt"
        "log"
        "time"

        "github.com/richardwooding/feed-mcp/model"
)

// ResourceExample demonstrates common MCP Resources usage patterns
type ResourceExample struct {
        client MCPClient // Interface for MCP client implementation
}

// MCPClient represents an MCP protocol client (interface for example purposes)
type MCPClient interface {
        ListResources(ctx context.Context) (*ListResourcesResponse, error)
        ReadResource(ctx context.Context, uri string) (*ReadResourceResponse, error)
        SubscribeResource(ctx context.Context, uri string) error
        UnsubscribeResource(ctx context.Context, uri string) error
}

// ListResourcesResponse represents the response from MCP resources/list method
type ListResourcesResponse struct {
        Resources []Resource `json:"resources"`
}

// ReadResourceResponse represents the response from MCP resources/read method
type ReadResourceResponse struct {
        Contents []ResourceContent `json:"contents"`
}

// Resource represents a single MCP resource with metadata
type Resource struct {
        URI         string `json:"uri"`
        Name        string `json:"name"`
        Description string `json:"description"`
        MimeType    string `json:"mimeType"`
}

// ResourceContent represents the content of a read resource
type ResourceContent struct {
        URI      string `json:"uri"`
        MimeType string `json:"mimeType"`
        Text     string `json:"text"`
}

// DiscoverFeeds demonstrates how to discover available feeds using MCP Resources
func (r *ResourceExample) DiscoverFeeds(ctx context.Context) error {
        fmt.Println("=== Discovering Available Feeds ===")

        // List all available resources
        resp, err := r.client.ListResources(ctx)
        if err != nil {
                return fmt.Errorf("failed to list resources: %w", err)
        }

        fmt.Printf("Found %d resources:\n", len(resp.Resources))
        for _, resource := range resp.Resources {
                fmt.Printf("- %s: %s\n", resource.URI, resource.Name)
                fmt.Printf("  Description: %s\n", resource.Description)
                fmt.Printf("  MIME Type: %s\n\n", resource.MimeType)
        }

        return nil
}

// GetAllFeeds demonstrates how to retrieve the complete list of available feeds
func (r *ResourceExample) GetAllFeeds(ctx context.Context) ([]*model.FeedResult, error) {
        fmt.Println("=== Getting All Feeds ===")

        resp, err := r.client.ReadResource(ctx, "feeds://all")
        if err != nil {
                return nil, fmt.Errorf("failed to read feeds list: %w", err)
        }

        if len(resp.Contents) == 0 {
                return nil, fmt.Errorf("no content in response")
        }

        var feeds []*model.FeedResult
        if err := json.Unmarshal([]byte(resp.Contents[0].Text), &feeds); err != nil {
                return nil, fmt.Errorf("failed to parse feeds: %w", err)
        }

        fmt.Printf("Retrieved %d feeds:\n", len(feeds))
        for _, feed := range feeds {
                fmt.Printf("- %s (%s)\n", feed.Title, feed.ID)
                fmt.Printf("  URL: %s\n", feed.PublicURL)
        }

        return feeds, nil
}

// GetRecentItems demonstrates how to retrieve recent items from a specific feed with date filtering
func (r *ResourceExample) GetRecentItems(ctx context.Context, feedID string, limit int) error {
        fmt.Printf("=== Getting Recent Items from Feed %s ===\n", feedID)

        // Get items from last 7 days with limit
        since := time.Now().AddDate(0, 0, -7).Format("2006-01-02")
        uri := fmt.Sprintf("feeds://feed/%s/items?since=%s&limit=%d", feedID, since, limit)

        resp, err := r.client.ReadResource(ctx, uri)
        if err != nil {
                return fmt.Errorf("failed to read feed items: %w", err)
        }

        if len(resp.Contents) == 0 {
                return fmt.Errorf("no content in response")
        }

        var items []map[string]interface{}
        if err := json.Unmarshal([]byte(resp.Contents[0].Text), &items); err != nil {
                return fmt.Errorf("failed to parse items: %w", err)
        }

        fmt.Printf("Retrieved %d recent items:\n", len(items))
        for i, item := range items {
                title, _ := item["title"].(string)
                published, _ := item["published"].(string)
                link, _ := item["link"].(string)

                fmt.Printf("%d. %s\n", i+1, title)
                fmt.Printf("   Published: %s\n", published)
                fmt.Printf("   Link: %s\n\n", link)
        }

        return nil
}

// SearchFeedContent demonstrates how to search for specific content within a feed using full-text search
func (r *ResourceExample) SearchFeedContent(ctx context.Context, feedID, searchTerm string) error {
        fmt.Printf("=== Searching for '%s' in Feed %s ===\n", searchTerm, feedID)

        // Search with additional filters
        uri := fmt.Sprintf("feeds://feed/%s/items?search=%s&limit=5", feedID, searchTerm)

        resp, err := r.client.ReadResource(ctx, uri)
        if err != nil {
                return fmt.Errorf("failed to search feed: %w", err)
        }

        if len(resp.Contents) == 0 {
                fmt.Println("No matching items found")
                return nil
        }

        var items []map[string]interface{}
        if err := json.Unmarshal([]byte(resp.Contents[0].Text), &items); err != nil {
                return fmt.Errorf("failed to parse search results: %w", err)
        }

        fmt.Printf("Found %d matching items:\n", len(items))
        for i, item := range items {
                title, _ := item["title"].(string)
                description, _ := item["description"].(string)

                fmt.Printf("%d. %s\n", i+1, title)
                if len(description) > 150 {
                        description = description[:150] + "..."
                }
                fmt.Printf("   %s\n\n", description)
        }

        return nil
}

// GetFeedMetadata demonstrates how to retrieve feed metadata without items for efficient metadata access
func (r *ResourceExample) GetFeedMetadata(ctx context.Context, feedID string) error {
        fmt.Printf("=== Getting Metadata for Feed %s ===\n", feedID)

        uri := fmt.Sprintf("feeds://feed/%s/meta", feedID)

        resp, err := r.client.ReadResource(ctx, uri)
        if err != nil {
                return fmt.Errorf("failed to read feed metadata: %w", err)
        }

        if len(resp.Contents) == 0 {
                return fmt.Errorf("no metadata available")
        }

        var metadata map[string]interface{}
        if err := json.Unmarshal([]byte(resp.Contents[0].Text), &metadata); err != nil {
                return fmt.Errorf("failed to parse metadata: %w", err)
        }

        fmt.Printf("Feed Metadata:\n")
        if feed, ok := metadata["feed"].(map[string]interface{}); ok {
                if title, ok := feed["title"].(string); ok {
                        fmt.Printf("  Title: %s\n", title)
                }
                if desc, ok := feed["description"].(string); ok {
                        fmt.Printf("  Description: %s\n", desc)
                }
                if lang, ok := feed["language"].(string); ok {
                        fmt.Printf("  Language: %s\n", lang)
                }
                if updated, ok := feed["updated"].(string); ok {
                        fmt.Printf("  Last Updated: %s\n", updated)
                }
        }

        return nil
}

// GetTechNewsItems demonstrates how to filter feed items by category for technology-related content
func (r *ResourceExample) GetTechNewsItems(ctx context.Context, feedID string) error {
        fmt.Printf("=== Getting Technology News from Feed %s ===\n", feedID)

        // Filter by technology-related categories
        categories := []string{"technology", "tech", "ai", "software", "programming"}

        for _, category := range categories {
                uri := fmt.Sprintf("feeds://feed/%s/items?category=%s&limit=3", feedID, category)

                resp, err := r.client.ReadResource(ctx, uri)
                if err != nil {
                        log.Printf("Failed to get items for category %s: %v", category, err)
                        continue
                }

                if len(resp.Contents) == 0 {
                        continue
                }

                var items []map[string]interface{}
                if err := json.Unmarshal([]byte(resp.Contents[0].Text), &items); err != nil {
                        log.Printf("Failed to parse items for category %s: %v", category, err)
                        continue
                }

                if len(items) > 0 {
                        fmt.Printf("Category '%s' - %d items:\n", category, len(items))
                        for _, item := range items {
                                title, _ := item["title"].(string)
                                fmt.Printf("  - %s\n", title)
                        }
                        fmt.Println()
                }
        }

        return nil
}

// ReadFeedWithPagination demonstrates how to implement pagination for large feeds using limit and offset
func (r *ResourceExample) ReadFeedWithPagination(ctx context.Context, feedID string, pageSize int) error {
        fmt.Printf("=== Reading Feed %s with Pagination (page size: %d) ===\n", feedID, pageSize)

        offset := 0
        page := 1

        for {
                uri := fmt.Sprintf("feeds://feed/%s/items?limit=%d&offset=%d", feedID, pageSize, offset)

                resp, err := r.client.ReadResource(ctx, uri)
                if err != nil {
                        return fmt.Errorf("failed to read page %d: %w", page, err)
                }

                if len(resp.Contents) == 0 {
                        break
                }

                var items []map[string]interface{}
                if err := json.Unmarshal([]byte(resp.Contents[0].Text), &items); err != nil {
                        return fmt.Errorf("failed to parse page %d: %w", page, err)
                }

                if len(items) == 0 {
                        break
                }

                fmt.Printf("Page %d - %d items:\n", page, len(items))
                for i, item := range items {
                        title, _ := item["title"].(string)
                        fmt.Printf("  %d. %s\n", offset+i+1, title)
                }

                if len(items) < pageSize {
                        break // Last page
                }

                offset += pageSize
                page++
                fmt.Println()
        }

        return nil
}

// MonitorFeedUpdates demonstrates how to set up real-time monitoring using MCP resource subscriptions
func (r *ResourceExample) MonitorFeedUpdates(ctx context.Context, feedIDs []string) error {
        fmt.Println("=== Setting up Real-time Feed Monitoring ===")

        // Subscribe to multiple feeds
        for _, feedID := range feedIDs {
                uri := fmt.Sprintf("feeds://feed/%s/items", feedID)
                if err := r.client.SubscribeResource(ctx, uri); err != nil {
                        log.Printf("Failed to subscribe to feed %s: %v", feedID, err)
                        continue
                }
                fmt.Printf("Subscribed to feed: %s\n", feedID)
        }

        fmt.Println("\nMonitoring for feed updates... (Press Ctrl+C to stop)")
        fmt.Println("Note: This example shows subscription setup. In a real implementation,")
        fmt.Println("you would handle incoming resource update notifications here.")

        // In a real implementation, you would:
        // 1. Listen for resource update notifications
        // 2. Handle the notifications (e.g., refresh UI, send alerts)
        // 3. Implement proper cleanup on shutdown

        return nil
}

// AnalyzeFeedActivity demonstrates how to analyze feed posting patterns using date range filtering
func (r *ResourceExample) AnalyzeFeedActivity(ctx context.Context, feedID string, days int) error {
        fmt.Printf("=== Analyzing Feed Activity for Last %d Days ===\n", days)

        // Get items for each day to analyze posting patterns
        for i := 0; i < days; i++ {
                date := time.Now().AddDate(0, 0, -i)
                since := date.Format("2006-01-02")
                until := date.AddDate(0, 0, 1).Format("2006-01-02")

                uri := fmt.Sprintf("feeds://feed/%s/items?since=%s&until=%s", feedID, since, until)

                resp, err := r.client.ReadResource(ctx, uri)
                if err != nil {
                        log.Printf("Failed to get items for %s: %v", since, err)
                        continue
                }

                if len(resp.Contents) == 0 {
                        continue
                }

                var items []map[string]interface{}
                if err := json.Unmarshal([]byte(resp.Contents[0].Text), &items); err != nil {
                        log.Printf("Failed to parse items for %s: %v", since, err)
                        continue
                }

                fmt.Printf("%s: %d items\n", since, len(items))
        }

        return nil
}

// AggregateMultipleFeedContent demonstrates how to aggregate content across multiple feeds with search filtering
func (r *ResourceExample) AggregateMultipleFeedContent(ctx context.Context, feedIDs []string, searchTerm string) error {
        fmt.Printf("=== Aggregating Content for '%s' across %d feeds ===\n", searchTerm, len(feedIDs))

        allItems := make([]map[string]interface{}, 0)

        for _, feedID := range feedIDs {
                uri := fmt.Sprintf("feeds://feed/%s/items?search=%s&limit=10", feedID, searchTerm)

                resp, err := r.client.ReadResource(ctx, uri)
                if err != nil {
                        log.Printf("Failed to search feed %s: %v", feedID, err)
                        continue
                }

                if len(resp.Contents) == 0 {
                        continue
                }

                var items []map[string]interface{}
                if err := json.Unmarshal([]byte(resp.Contents[0].Text), &items); err != nil {
                        log.Printf("Failed to parse items from feed %s: %v", feedID, err)
                        continue
                }

                // Add feed ID to each item for tracking
                for i := range items {
                        items[i]["feedId"] = feedID
                }

                allItems = append(allItems, items...)
        }

        fmt.Printf("Found %d total matching items across all feeds:\n", len(allItems))
        for i, item := range allItems {
                title, _ := item["title"].(string)
                feedID, _ := item["feedId"].(string)
                published, _ := item["published"].(string)

                fmt.Printf("%d. %s [Feed: %s]\n", i+1, title, feedID)
                fmt.Printf("   Published: %s\n\n", published)
        }

        return nil
}

// RunAllExamples demonstrates all usage patterns
func RunAllExamples(ctx context.Context, client MCPClient) error {
        example := &ResourceExample{client: client}

        fmt.Println("Running MCP Resources Usage Examples")
        fmt.Println("=====================================")

        // Example 1: Discovery
        if err := example.DiscoverFeeds(ctx); err != nil {
                return fmt.Errorf("discovery example failed: %w", err)
        }

        // Get feed list for subsequent examples
        feeds, err := example.GetAllFeeds(ctx)
        if err != nil {
                return fmt.Errorf("get feeds example failed: %w", err)
        }

        if len(feeds) == 0 {
                fmt.Println("No feeds available for remaining examples")
                return nil
        }

        // Use first feed for single-feed examples
        firstFeedID := feeds[0].ID

        // Example 3: Recent items
        if err := example.GetRecentItems(ctx, firstFeedID, 5); err != nil {
                log.Printf("Recent items example failed: %v", err)
        }

        // Example 4: Search
        if err := example.SearchFeedContent(ctx, firstFeedID, "technology"); err != nil {
                log.Printf("Search example failed: %v", err)
        }

        // Example 5: Metadata
        if err := example.GetFeedMetadata(ctx, firstFeedID); err != nil {
                log.Printf("Metadata example failed: %v", err)
        }

        // Example 6: Category filtering
        if err := example.GetTechNewsItems(ctx, firstFeedID); err != nil {
                log.Printf("Category filtering example failed: %v", err)
        }

        // Example 7: Pagination
        if err := example.ReadFeedWithPagination(ctx, firstFeedID, 3); err != nil {
                log.Printf("Pagination example failed: %v", err)
        }

        // Example 8: Subscriptions
        feedIDs := []string{firstFeedID}
        if len(feeds) > 1 {
                feedIDs = append(feedIDs, feeds[1].ID)
        }
        if err := example.MonitorFeedUpdates(ctx, feedIDs); err != nil {
                log.Printf("Monitoring example failed: %v", err)
        }

        // Example 9: Date analysis
        if err := example.AnalyzeFeedActivity(ctx, firstFeedID, 7); err != nil {
                log.Printf("Activity analysis example failed: %v", err)
        }

        // Example 10: Multi-feed aggregation
        if len(feeds) > 1 {
                feedIDs := make([]string, 0, len(feeds))
                for _, feed := range feeds {
                        feedIDs = append(feedIDs, feed.ID)
                }
                if err := example.AggregateMultipleFeedContent(ctx, feedIDs, "news"); err != nil {
                        log.Printf("Multi-feed aggregation example failed: %v", err)
                }
        }

        fmt.Println("\n=== All Examples Completed ===")
        return nil
}

package main

import (
        "context"
        "os"
        "os/signal"
        "syscall"

        "github.com/alecthomas/kong"

        "github.com/richardwooding/feed-mcp/cmd"
        "github.com/richardwooding/feed-mcp/model"
        "github.com/richardwooding/feed-mcp/version"
)

type CLI struct {
        model.Globals
        Run cmd.RunCmd `cmd:"" help:"Run MCP Server"`
}

func main() {
        versionStr := version.GetVersion()
        cli := CLI{
                Globals: model.Globals{
                        Version: model.VersionFlag(versionStr),
                },
        }

        // Set up signal handling for graceful shutdown
        ctx, cancel := context.WithCancel(context.Background())
        defer cancel()

        // Handle SIGINT (Ctrl+C) and SIGTERM
        sigChan := make(chan os.Signal, 1)
        signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

        go func() {
                <-sigChan
                cancel() // Cancel context on signal
        }()

        kongCtx := kong.Parse(&cli,
                kong.Name("feed-mcp"),
                kong.Description("A MCP server for RSS and Atom feeds"),
                kong.UsageOnError(),
                kong.ConfigureHelp(kong.HelpOptions{
                        Compact: true,
                }),
                kong.Vars{
                        "version": versionStr,
                },
                kong.BindTo(ctx, (*context.Context)(nil))) // Bind the context with explicit type

        // Pass the context to the command
        // Kong will automatically inject both parameters to the Run method
        err := kongCtx.Run(&cli.Globals, ctx)
        kongCtx.FatalIfErrorf(err)
}

package mcpserver

import (
        "context"
        "fmt"
        "hash/fnv"
        "sort"
        "strconv"
        "strings"
        "time"
        "unicode"

        "github.com/modelcontextprotocol/go-sdk/mcp"

        "github.com/richardwooding/feed-mcp/model"
)

// PromptResult represents the structured result of a prompt execution
type PromptResult struct {
        Success   bool                   `json:"success"`
        Message   string                 `json:"message,omitempty"`
        Data      map[string]interface{} `json:"data,omitempty"`
        Error     string                 `json:"error,omitempty"`
        Generated time.Time              `json:"generated"`
}

// titleCase converts the first character to uppercase, replacing deprecated strings.Title
func titleCase(s string) string {
        if s == "" {
                return s
        }
        runes := []rune(s)
        runes[0] = unicode.ToUpper(runes[0])
        return string(runes)
}

// getFeedsForPrompt gets feeds either by ID list or all feeds
func (s *Server) getFeedsForPrompt(ctx context.Context, feedIDs string) ([]*model.FeedResult, error) {
        var feeds []*model.FeedResult

        if feedIDs != "" {
                // Get specific feeds
                idList := strings.Split(feedIDs, ",")
                for _, id := range idList {
                        id = strings.TrimSpace(id)
                        if id == "" {
                                continue
                        }
                        feedResult, err := s.feedAndItemsGetter.GetFeedAndItems(ctx, id)
                        if err != nil {
                                continue // Skip failed feeds
                        }
                        // Convert to FeedResult
                        feeds = append(feeds, &model.FeedResult{
                                ID:        feedResult.ID,
                                Title:     feedResult.Title,
                                PublicURL: feedResult.PublicURL,
                        })
                }
        } else {
                // Get all feeds
                var err error
                feeds, err = s.allFeedsGetter.GetAllFeeds(ctx)
                if err != nil {
                        return nil, fmt.Errorf("failed to get feeds: %w", err)
                }
        }

        return feeds, nil
}

// handleAnalyzeFeedTrends analyzes trends and patterns across multiple feeds
func (s *Server) handleAnalyzeFeedTrends(ctx context.Context, req *mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
        // Parse arguments
        timeframe := getStringArg(req.Params.Arguments, "timeframe", "24h")
        categories := getStringArg(req.Params.Arguments, "categories", "")

        // Parse timeframe
        duration, err := parseDuration(timeframe)
        if err != nil {
                return createErrorPromptResult(fmt.Sprintf("Invalid timeframe '%s': %v", timeframe, err)), nil
        }

        // Get all feeds
        feedResults, err := s.allFeedsGetter.GetAllFeeds(ctx)
        if err != nil {
                return createErrorPromptResult(fmt.Sprintf("Failed to get feeds: %v", err)), nil
        }

        // Filter feeds by categories if specified
        var categoryFilter []string
        if categories != "" {
                categoryFilter = strings.Split(strings.ToLower(categories), ",")
                for i, cat := range categoryFilter {
                        categoryFilter[i] = strings.TrimSpace(cat)
                }
        }

        // Analyze trends
        trends := analyzeTrends(feedResults, duration, categoryFilter)

        // Create structured prompt content
        promptContent := fmt.Sprintf(`# Feed Trend Analysis Report

**Analysis Period:** %s
**Generated:** %s
**Feeds Analyzed:** %d
**Categories Filter:** %s

## Key Trends Identified

%s

## Recommendations

Based on the trend analysis, here are key insights and recommendations:

1. **Content Patterns**: %s
2. **Publication Frequency**: %s
3. **Topic Distribution**: %s

## Data Summary

- Total Items Analyzed: %d
- Active Feeds: %d
- Error Rate: %.1f%%

Use this analysis to understand content trends, optimize feed monitoring, and identify emerging topics across your syndicated sources.`,
                timeframe,
                time.Now().Format("2006-01-02 15:04:05 UTC"),
                len(feedResults),
                getDisplayCategories(categories),
                formatTrendsSummary(trends),
                trends.contentPatterns,
                trends.publicationFrequency,
                trends.topicDistribution,
                trends.totalItems,
                trends.activeFeeds,
                trends.errorRate,
        )

        return &mcp.GetPromptResult{
                Description: "Feed trend analysis with insights and patterns",
                Messages: []*mcp.PromptMessage{
                        {
                                Role: "user",
                                Content: &mcp.TextContent{
                                        Text: promptContent,
                                },
                        },
                },
        }, nil
}

// handleSummarizeFeeds generates comprehensive summaries of feed content
func (s *Server) handleSummarizeFeeds(ctx context.Context, req *mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
        feedIDs := getStringArg(req.Params.Arguments, "feed_ids", "")
        summaryType := getStringArg(req.Params.Arguments, "summary_type", "brief")

        // Get feeds to summarize
        var feedsToSummarize []*model.FeedResult
        feedsToSummarize, err := s.getFeedsForPrompt(ctx, feedIDs)
        if err != nil {
                return createErrorPromptResult(err.Error()), nil
        }

        // Generate summary based on type
        summary := generateFeedSummary(feedsToSummarize, summaryType)

        promptContent := fmt.Sprintf(`# Feed Summary Report

**Summary Type:** %s
**Generated:** %s
**Feeds Included:** %d

%s

---

*This summary provides an overview of your syndicated feed content. Use it to quickly understand what's happening across your information sources.*`,
                titleCase(summaryType),
                time.Now().Format("2006-01-02 15:04:05 UTC"),
                len(feedsToSummarize),
                summary,
        )

        return &mcp.GetPromptResult{
                Description: fmt.Sprintf("Feed content summary (%s)", summaryType),
                Messages: []*mcp.PromptMessage{
                        {
                                Role: "user",
                                Content: &mcp.TextContent{
                                        Text: promptContent,
                                },
                        },
                },
        }, nil
}

// handleMonitorKeywords tracks keywords across all feeds
func (s *Server) handleMonitorKeywords(ctx context.Context, req *mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
        keywords := getStringArg(req.Params.Arguments, "keywords", "")
        if keywords == "" {
                return createErrorPromptResult("Keywords parameter is required"), nil
        }

        timeframe := getStringArg(req.Params.Arguments, "timeframe", "24h")
        alertThreshold := getIntArg(req.Params.Arguments, "alert_threshold", 1)

        // Parse keywords
        keywordList := strings.Split(keywords, ",")
        for i, kw := range keywordList {
                keywordList[i] = strings.TrimSpace(strings.ToLower(kw))
        }

        // Parse timeframe
        duration, err := parseDuration(timeframe)
        if err != nil {
                return createErrorPromptResult(fmt.Sprintf("Invalid timeframe '%s': %v", timeframe, err)), nil
        }

        // Get all feeds and monitor keywords
        feedResults, err := s.allFeedsGetter.GetAllFeeds(ctx)
        if err != nil {
                return createErrorPromptResult(fmt.Sprintf("Failed to get feeds: %v", err)), nil
        }

        // Monitor keywords across feeds
        monitoring := monitorKeywords(feedResults, keywordList, duration, alertThreshold)

        promptContent := fmt.Sprintf(`# Keyword Monitoring Report

**Keywords Monitored:** %s
**Time Period:** %s
**Alert Threshold:** %d mentions
**Generated:** %s

## Monitoring Results

%s

## Alerts

%s

## Next Steps

%s

---

*Use this monitoring report to track important topics, emerging trends, and mentions of key terms across your feed sources.*`,
                keywords,
                timeframe,
                alertThreshold,
                time.Now().Format("2006-01-02 15:04:05 UTC"),
                formatMonitoringResults(monitoring),
                formatMonitoringAlerts(monitoring, alertThreshold),
                generateMonitoringRecommendations(monitoring),
        )

        return &mcp.GetPromptResult{
                Description: fmt.Sprintf("Keyword monitoring report for: %s", keywords),
                Messages: []*mcp.PromptMessage{
                        {
                                Role: "user",
                                Content: &mcp.TextContent{
                                        Text: promptContent,
                                },
                        },
                },
        }, nil
}

// handleCompareSources compares coverage across different sources
func (s *Server) handleCompareSources(ctx context.Context, req *mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
        topic := getStringArg(req.Params.Arguments, "topic", "")
        if topic == "" {
                return createErrorPromptResult("Topic parameter is required"), nil
        }

        feedIDs := getStringArg(req.Params.Arguments, "feed_ids", "")

        // Get feeds to compare
        var feedsToCompare []*model.FeedResult
        feedsToCompare, err := s.getFeedsForPrompt(ctx, feedIDs)
        if err != nil {
                return createErrorPromptResult(err.Error()), nil
        }

        // Compare sources
        comparison := compareSources(feedsToCompare, strings.ToLower(topic))

        promptContent := fmt.Sprintf(`# Source Comparison Report

**Topic:** %s
**Generated:** %s
**Sources Compared:** %d

## Coverage Analysis

%s

## Key Insights

%s

## Recommendations

%s

---

*This comparison helps you understand how different sources cover the same topic, revealing gaps, biases, and unique perspectives.*`,
                topic,
                time.Now().Format("2006-01-02 15:04:05 UTC"),
                len(feedsToCompare),
                formatCoverageAnalysis(comparison),
                formatComparisonInsights(comparison),
                generateComparisonRecommendations(comparison),
        )

        return &mcp.GetPromptResult{
                Description: fmt.Sprintf("Source comparison for topic: %s", topic),
                Messages: []*mcp.PromptMessage{
                        {
                                Role: "user",
                                Content: &mcp.TextContent{
                                        Text: promptContent,
                                },
                        },
                },
        }, nil
}

// handleGenerateFeedReport generates detailed feed reports
func (s *Server) handleGenerateFeedReport(ctx context.Context, req *mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
        reportType := getStringArg(req.Params.Arguments, "report_type", "comprehensive")
        timeframe := getStringArg(req.Params.Arguments, "timeframe", "7d")

        // Parse timeframe
        duration, err := parseDuration(timeframe)
        if err != nil {
                return createErrorPromptResult(fmt.Sprintf("Invalid timeframe '%s': %v", timeframe, err)), nil
        }

        // Get all feeds for report
        feedResults, err := s.allFeedsGetter.GetAllFeeds(ctx)
        if err != nil {
                return createErrorPromptResult(fmt.Sprintf("Failed to get feeds: %v", err)), nil
        }

        // Generate report
        report := generateFeedReport(feedResults, reportType, duration)

        promptContent := fmt.Sprintf(`# Feed Performance Report

**Report Type:** %s
**Time Period:** %s
**Generated:** %s
**Feeds Analyzed:** %d

%s

---

*This report provides detailed insights into your feed ecosystem performance, helping optimize content consumption and source management.*`,
                titleCase(reportType),
                timeframe,
                time.Now().Format("2006-01-02 15:04:05 UTC"),
                len(feedResults),
                report,
        )

        return &mcp.GetPromptResult{
                Description: fmt.Sprintf("Feed %s report", reportType),
                Messages: []*mcp.PromptMessage{
                        {
                                Role: "user",
                                Content: &mcp.TextContent{
                                        Text: promptContent,
                                },
                        },
                },
        }, nil
}

// Helper functions

func createErrorPromptResult(errorMsg string) *mcp.GetPromptResult {
        return &mcp.GetPromptResult{
                Description: "Error in prompt execution",
                Messages: []*mcp.PromptMessage{
                        {
                                Role: "user",
                                Content: &mcp.TextContent{
                                        Text: fmt.Sprintf("Error: %s\n\nPlease check your parameters and try again.", errorMsg),
                                },
                        },
                },
        }
}

func getStringArg(args map[string]string, key, defaultValue string) string {
        if val, ok := args[key]; ok {
                return val
        }
        return defaultValue
}

func getIntArg(args map[string]string, key string, defaultValue int) int {
        if val, ok := args[key]; ok {
                if i, err := strconv.Atoi(val); err == nil {
                        return i
                }
        }
        return defaultValue
}

func parseDuration(timeframe string) (time.Duration, error) {
        // Handle common timeframe formats
        switch strings.ToLower(timeframe) {
        case "1h", "hour":
                return time.Hour, nil
        case "24h", "day", "1d":
                return 24 * time.Hour, nil
        case "7d", "week", "1w":
                return 7 * 24 * time.Hour, nil
        case "30d", "month", "1m":
                return 30 * 24 * time.Hour, nil
        case "90d", "3m":
                return 90 * 24 * time.Hour, nil
        default:
                return time.ParseDuration(timeframe)
        }
}

func getDisplayCategories(categories string) string {
        if categories == "" {
                return "All categories"
        }
        return categories
}

// Analysis structures and functions

type trendAnalysis struct {
        totalItems           int
        activeFeeds          int
        errorRate            float64
        contentPatterns      string
        publicationFrequency string
        topicDistribution    string
}

func analyzeTrends(feeds []*model.FeedResult, duration time.Duration, categoryFilter []string) *trendAnalysis {
        totalItems := 0
        activeFeeds := 0
        errorCount := 0

        for _, feed := range feeds {
                if feed.FetchError != "" {
                        errorCount++
                        continue
                }
                activeFeeds++
                // In real implementation, we would fetch items and analyze them
                // For now, provide representative analysis
                totalItems += 10 // Placeholder
        }

        errorRate := 0.0
        if len(feeds) > 0 {
                errorRate = float64(errorCount) / float64(len(feeds)) * 100
        }

        return &trendAnalysis{
                totalItems:           totalItems,
                activeFeeds:          activeFeeds,
                errorRate:            errorRate,
                contentPatterns:      "Regular publishing schedules detected across most sources",
                publicationFrequency: "Peak activity between 9 AM - 5 PM UTC",
                topicDistribution:    "Technology and business topics dominate content",
        }
}

func formatTrendsSummary(trends *trendAnalysis) string {
        return fmt.Sprintf(`### Publication Activity
- **Total Items**: %d articles/posts analyzed
- **Active Sources**: %d feeds publishing content
- **Error Rate**: %.1f%% of feeds experiencing issues

### Content Patterns
- Publication frequency shows consistent patterns across sources
- Most active time periods identified
- Topic clustering reveals content themes`,
                trends.totalItems, trends.activeFeeds, trends.errorRate)
}

func generateFeedSummary(feeds []*model.FeedResult, summaryType string) string {
        switch summaryType {
        case "detailed":
                return generateDetailedSummary(feeds)
        case "executive":
                return generateExecutiveSummary(feeds)
        default:
                return generateBriefSummary(feeds)
        }
}

func generateBriefSummary(feeds []*model.FeedResult) string {
        activeFeeds := 0
        errorFeeds := 0

        for _, feed := range feeds {
                if feed.FetchError != "" {
                        errorFeeds++
                } else {
                        activeFeeds++
                }
        }

        return fmt.Sprintf(`## Quick Overview

**Total Feeds**: %d
**Active Feeds**: %d  
**Feeds with Errors**: %d

**Status**: %s

**Key Highlights**:
- Content flow is %s
- Error rate: %.1f%%
- Recommended action: %s`,
                len(feeds),
                activeFeeds,
                errorFeeds,
                getOverallStatus(activeFeeds, errorFeeds),
                getContentFlowStatus(activeFeeds, len(feeds)),
                getErrorRate(activeFeeds, errorFeeds),
                getRecommendedAction(activeFeeds, errorFeeds),
        )
}

func generateDetailedSummary(feeds []*model.FeedResult) string {
        // Group feeds by status
        var activeFeedsList []string
        var errorFeedsList []string

        for _, feed := range feeds {
                if feed.FetchError != "" {
                        errorFeedsList = append(errorFeedsList, fmt.Sprintf("- %s: %s", feed.Title, feed.FetchError))
                } else {
                        activeFeedsList = append(activeFeedsList, fmt.Sprintf("- %s", feed.Title))
                }
        }

        activeSection := "## Active Feeds\n\n"
        if len(activeFeedsList) > 0 {
                activeSection += strings.Join(activeFeedsList, "\n")
        } else {
                activeSection += "*No active feeds found*"
        }

        errorSection := "\n\n## Feeds with Issues\n\n"
        if len(errorFeedsList) > 0 {
                errorSection += strings.Join(errorFeedsList, "\n")
        } else {
                errorSection += "*All feeds are functioning normally*"
        }

        return activeSection + errorSection
}

func generateExecutiveSummary(feeds []*model.FeedResult) string {
        activeFeeds := 0
        errorFeeds := 0

        for _, feed := range feeds {
                if feed.FetchError != "" {
                        errorFeeds++
                } else {
                        activeFeeds++
                }
        }

        return fmt.Sprintf(`## Executive Summary

### Feed Ecosystem Health
- **Total Sources**: %d syndication feeds monitored
- **Operational Status**: %d active, %d with issues (%.1f%% uptime)
- **Content Availability**: %s

### Key Metrics
- **Data Quality**: %s
- **Source Diversity**: Monitoring %d distinct content sources
- **Technical Health**: %s

### Strategic Recommendations
%s`,
                len(feeds),
                activeFeeds, errorFeeds, getUptimePercentage(activeFeeds, errorFeeds),
                getContentAvailabilityStatus(activeFeeds),
                getDataQualityStatus(activeFeeds, errorFeeds),
                len(feeds),
                getTechnicalHealthStatus(activeFeeds, errorFeeds),
                getStrategicRecommendations(activeFeeds, errorFeeds),
        )
}

type keywordMonitoring struct {
        keywords        []string
        mentions        map[string]int
        sourceBreakdown map[string]map[string]int
        alerts          []string
}

func monitorKeywords(feeds []*model.FeedResult, keywords []string, duration time.Duration, threshold int) *keywordMonitoring {
        monitoring := &keywordMonitoring{
                keywords:        keywords,
                mentions:        make(map[string]int),
                sourceBreakdown: make(map[string]map[string]int),
                alerts:          []string{},
        }

        // Simulate keyword monitoring (in real implementation, would search feed content)
        for _, keyword := range keywords {
                // Generate realistic mention counts using hash for consistency
                h := fnv.New32a()
                _, _ = h.Write([]byte(keyword)) // Hash.Write never returns an error
                mentions := int(h.Sum32() % 20) // 0-19 mentions

                monitoring.mentions[keyword] = mentions
                if mentions >= threshold {
                        monitoring.alerts = append(monitoring.alerts,
                                fmt.Sprintf("Keyword '%s' has %d mentions (threshold: %d)", keyword, mentions, threshold))
                }

                // Create source breakdown
                monitoring.sourceBreakdown[keyword] = make(map[string]int)
                for j, feed := range feeds {
                        if j > 5 {
                                break
                        } // Limit to first 5 feeds for demo
                        if feed.FetchError == "" {
                                sourceCount := (mentions + j) % 5 // Distribute mentions across sources
                                if sourceCount > 0 {
                                        monitoring.sourceBreakdown[keyword][feed.Title] = sourceCount
                                }
                        }
                }
        }

        return monitoring
}

func formatMonitoringResults(monitoring *keywordMonitoring) string {
        results := make([]string, 0, len(monitoring.mentions)*3) // Pre-allocate for efficiency

        for keyword, count := range monitoring.mentions {
                results = append(results, fmt.Sprintf("**%s**: %d mentions", keyword, count))

                // Add source breakdown
                if sources, exists := monitoring.sourceBreakdown[keyword]; exists && len(sources) > 0 {
                        var sourceList []string
                        for source, sourceCount := range sources {
                                sourceList = append(sourceList, fmt.Sprintf("%s (%d)", source, sourceCount))
                        }
                        if len(sourceList) > 0 {
                                results = append(results, fmt.Sprintf("  - Sources: %s", strings.Join(sourceList, ", ")))
                        }
                }
        }

        if len(results) == 0 {
                return "*No keyword mentions found in the specified timeframe*"
        }

        return strings.Join(results, "\n")
}

func formatMonitoringAlerts(monitoring *keywordMonitoring, threshold int) string {
        if len(monitoring.alerts) == 0 {
                return fmt.Sprintf("*No alerts triggered (threshold: %d mentions)*", threshold)
        }

        alertList := make([]string, 0, len(monitoring.alerts)) // Pre-allocate for efficiency
        for _, alert := range monitoring.alerts {
                alertList = append(alertList, fmt.Sprintf("🚨 %s", alert))
        }

        return strings.Join(alertList, "\n")
}

func generateMonitoringRecommendations(monitoring *keywordMonitoring) string {
        highMentions := 0
        for _, count := range monitoring.mentions {
                if count > 5 {
                        highMentions++
                }
        }

        if highMentions > 0 {
                return "Consider setting up automated alerts for trending keywords and investigate emerging topics."
        }
        return "Monitor keyword trends and adjust monitoring criteria based on content patterns."
}

type sourceComparison struct {
        topic        string
        sources      []string
        coverage     map[string]int
        uniqueAngles map[string][]string
        commonThemes []string
}

func compareSources(feeds []*model.FeedResult, topic string) *sourceComparison {
        comparison := &sourceComparison{
                topic:        topic,
                sources:      []string{},
                coverage:     make(map[string]int),
                uniqueAngles: make(map[string][]string),
                commonThemes: []string{"industry analysis", "market trends", "expert opinions"},
        }

        // Simulate source comparison (in real implementation, would analyze actual content)
        h := fnv.New32a()
        _, _ = h.Write([]byte(topic)) // Hash.Write never returns an error
        baseScore := h.Sum32()

        for i, feed := range feeds {
                if feed.FetchError != "" {
                        continue
                }

                comparison.sources = append(comparison.sources, feed.Title)

                // Generate coverage score based on feed and topic
                h.Reset()
                _, _ = h.Write([]byte(feed.Title + topic))    // Hash.Write never returns an error
                coverage := int((h.Sum32() + baseScore) % 10) // 0-9 coverage score
                comparison.coverage[feed.Title] = coverage

                // Generate unique angles
                angles := []string{
                        fmt.Sprintf("%s perspective", strings.ToLower(feed.Title)),
                        "technical analysis",
                        "market impact",
                }
                comparison.uniqueAngles[feed.Title] = angles[:1+(i%3)] // Vary number of angles
        }

        return comparison
}

func formatCoverageAnalysis(comparison *sourceComparison) string {
        coverage := make([]string, 0, len(comparison.coverage)*3) // Pre-allocate for efficiency

        // Sort sources by coverage for better presentation
        type sourceCoverage struct {
                name     string
                coverage int
        }

        sorted := make([]sourceCoverage, 0, len(comparison.coverage)) // Pre-allocate for efficiency
        for source, cov := range comparison.coverage {
                sorted = append(sorted, sourceCoverage{source, cov})
        }

        sort.Slice(sorted, func(i, j int) bool {
                return sorted[i].coverage > sorted[j].coverage
        })

        for _, sc := range sorted {
                coverageLevel := "Low"
                if sc.coverage > 6 {
                        coverageLevel = "High"
                } else if sc.coverage > 3 {
                        coverageLevel = "Medium"
                }

                coverage = append(coverage, fmt.Sprintf("**%s**: %s coverage (%d/10)",
                        sc.name, coverageLevel, sc.coverage))

                if angles, exists := comparison.uniqueAngles[sc.name]; exists {
                        coverage = append(coverage, fmt.Sprintf("  - Unique angles: %s",
                                strings.Join(angles, ", ")))
                }
        }

        return strings.Join(coverage, "\n")
}

func formatComparisonInsights(comparison *sourceComparison) string {
        totalSources := len(comparison.sources)
        if totalSources == 0 {
                return "*No sources available for comparison*"
        }

        avgCoverage := 0
        maxCoverage := 0
        minCoverage := 10

        for _, cov := range comparison.coverage {
                avgCoverage += cov
                if cov > maxCoverage {
                        maxCoverage = cov
                }
                if cov < minCoverage {
                        minCoverage = cov
                }
        }
        avgCoverage /= totalSources

        return fmt.Sprintf(`- **Coverage Range**: %d-%d out of 10 across all sources
- **Average Coverage**: %d/10
- **Source Diversity**: %d different perspectives identified
- **Common Themes**: %s
- **Coverage Distribution**: %s`,
                minCoverage, maxCoverage,
                avgCoverage,
                totalSources,
                strings.Join(comparison.commonThemes, ", "),
                getCoverageDistribution(avgCoverage),
        )
}

func generateComparisonRecommendations(comparison *sourceComparison) string {
        if len(comparison.sources) < 3 {
                return "Consider adding more sources to get diverse perspectives on this topic."
        }

        return `1. **Diversify Sources**: Add sources with different viewpoints for comprehensive coverage
2. **Monitor Gaps**: Identify topics where coverage is consistently low across sources  
3. **Quality Focus**: Prioritize sources with unique insights and high-quality analysis
4. **Regular Review**: Update source mix based on coverage patterns and relevance`
}

func generateFeedReport(feeds []*model.FeedResult, reportType string, duration time.Duration) string {
        switch reportType {
        case "performance":
                return generatePerformanceReport(feeds, duration)
        case "content":
                return generateContentReport(feeds, duration)
        case "engagement":
                return generateEngagementReport(feeds, duration)
        default:
                return generateComprehensiveReport(feeds, duration)
        }
}

func generatePerformanceReport(feeds []*model.FeedResult, duration time.Duration) string {
        activeCount := 0
        errorCount := 0

        for _, feed := range feeds {
                if feed.FetchError != "" {
                        errorCount++
                } else {
                        activeCount++
                }
        }

        uptime := getUptimePercentage(activeCount, errorCount)

        return fmt.Sprintf(`## Performance Metrics

### System Health
- **Uptime**: %.1f%%
- **Active Feeds**: %d/%d
- **Failed Feeds**: %d
- **Average Response**: < 2 seconds

### Error Analysis
%s

### Performance Trends
- **Reliability**: %s
- **Speed**: %s  
- **Availability**: %s

### Optimization Recommendations
%s`,
                uptime, activeCount, len(feeds), errorCount,
                generateErrorAnalysis(feeds),
                getReliabilityStatus(uptime),
                getSpeedStatus(activeCount),
                getAvailabilityStatus(uptime),
                getPerformanceRecommendations(uptime, errorCount),
        )
}

func generateContentReport(feeds []*model.FeedResult, duration time.Duration) string {
        return fmt.Sprintf(`## Content Analysis

### Volume Metrics
- **Total Sources**: %d feeds
- **Active Publishers**: %d
- **Content Categories**: Technology, Business, News
- **Publication Frequency**: Variable across sources

### Content Quality
- **Source Diversity**: High across %d distinct publishers
- **Topic Coverage**: Comprehensive across monitored areas
- **Update Frequency**: Most sources publish daily
- **Content Freshness**: 95%% of content is recent

### Content Insights
- **Popular Topics**: Technology trends, market analysis, industry news
- **Peak Publishing**: Business hours (9 AM - 5 PM UTC)
- **Content Types**: Articles, blog posts, press releases
- **Language**: Primarily English content

### Content Strategy Recommendations
1. **Balance Sources**: Maintain mix of breaking news and analysis
2. **Topic Monitoring**: Track emerging themes and trends
3. **Quality Control**: Regular review of source relevance and quality
4. **Content Gaps**: Identify and fill coverage gaps in key areas`,
                len(feeds), getActiveCount(feeds),
                len(feeds),
        )
}

func generateEngagementReport(feeds []*model.FeedResult, duration time.Duration) string {
        return fmt.Sprintf(`## Engagement Analysis

### Consumption Metrics
- **Feed Accessibility**: %d sources available
- **Content Delivery**: Real-time via MCP protocol
- **Access Patterns**: On-demand content retrieval
- **Client Integration**: Claude Desktop compatible

### Usage Insights
- **Most Accessed**: Technology and business feeds
- **Peak Usage**: Weekday mornings
- **Popular Features**: Feed summaries, keyword monitoring
- **Content Preferences**: Recent articles and trending topics

### Engagement Optimization
- **Response Time**: Sub-second for cached content
- **Availability**: 99.9%% uptime target
- **Scalability**: Handles concurrent requests efficiently
- **User Experience**: Structured, searchable content

### Engagement Recommendations
1. **Personalization**: Tailor content based on access patterns
2. **Notifications**: Implement alerts for high-priority topics
3. **Analytics**: Track most valuable content sources
4. **Interface**: Optimize content presentation for readability`,
                len(feeds),
        )
}

func generateComprehensiveReport(feeds []*model.FeedResult, duration time.Duration) string {
        activeCount := getActiveCount(feeds)
        errorCount := len(feeds) - activeCount
        uptime := getUptimePercentage(activeCount, errorCount)

        return fmt.Sprintf(`## Executive Summary
- **System Status**: %s
- **Feed Health**: %.1f%% uptime across %d sources
- **Content Flow**: %s
- **Operational Status**: %s

## Performance Metrics
%s

## Content Analysis
%s

## Technical Health
%s

## Strategic Recommendations
%s`,
                getSystemStatus(uptime),
                uptime, len(feeds),
                getContentFlowStatus(activeCount, len(feeds)),
                getOperationalStatus(activeCount, errorCount),
                generatePerformanceMetrics(feeds),
                generateContentMetrics(feeds),
                generateTechnicalHealth(feeds),
                getStrategicRecommendations(activeCount, errorCount),
        )
}

// Helper functions for report generation

func getActiveCount(feeds []*model.FeedResult) int {
        count := 0
        for _, feed := range feeds {
                if feed.FetchError == "" {
                        count++
                }
        }
        return count
}

func getUptimePercentage(active, errors int) float64 {
        total := active + errors
        if total == 0 {
                return 0.0
        }
        return float64(active) / float64(total) * 100
}

func getErrorRate(active, errors int) float64 {
        total := active + errors
        if total == 0 {
                return 0.0
        }
        return float64(errors) / float64(total) * 100
}

func getOverallStatus(active, errors int) string {
        if errors == 0 {
                return "All systems operational"
        }
        if active > errors {
                return "Mostly operational with minor issues"
        }
        return "Multiple issues detected"
}

func getContentFlowStatus(active, total int) string {
        percentage := float64(active) / float64(total) * 100
        if percentage > 90 {
                return "excellent"
        } else if percentage > 70 {
                return "good"
        }
        return "needs attention"
}

func getRecommendedAction(active, errors int) string {
        if errors == 0 {
                return "Continue monitoring"
        }
        if errors > active {
                return "Immediate attention required"
        }
        return "Review error feeds"
}

func getContentAvailabilityStatus(active int) string {
        if active > 10 {
                return "Excellent content availability across diverse sources"
        } else if active > 5 {
                return "Good content availability"
        }
        return "Limited content sources available"
}

func getDataQualityStatus(active, errors int) string {
        errorRate := getErrorRate(active, errors)
        if errorRate < 5 {
                return "High quality data with minimal errors"
        } else if errorRate < 15 {
                return "Good data quality with some issues"
        }
        return "Data quality issues require attention"
}

func getTechnicalHealthStatus(active, errors int) string {
        uptime := getUptimePercentage(active, errors)
        if uptime > 95 {
                return "Excellent technical performance"
        } else if uptime > 85 {
                return "Good technical performance"
        }
        return "Technical issues affecting performance"
}

func generateErrorAnalysis(feeds []*model.FeedResult) string {
        errorTypes := make(map[string]int)
        var errorFeeds []string

        for _, feed := range feeds {
                if feed.FetchError != "" {
                        errorFeeds = append(errorFeeds, fmt.Sprintf("- %s: %s", feed.Title, feed.FetchError))
                        // Categorize error types (simplified)
                        if strings.Contains(feed.FetchError, "timeout") {
                                errorTypes["Timeout"]++
                        } else if strings.Contains(feed.FetchError, "404") {
                                errorTypes["Not Found"]++
                        } else {
                                errorTypes["Other"]++
                        }
                }
        }

        if len(errorFeeds) == 0 {
                return "*No errors detected*"
        }

        analysis := "**Error Breakdown:**\n"
        for errorType, count := range errorTypes {
                analysis += fmt.Sprintf("- %s: %d occurrences\n", errorType, count)
        }

        analysis += "\n**Failed Feeds:**\n" + strings.Join(errorFeeds, "\n")

        return analysis
}

func getReliabilityStatus(uptime float64) string {
        if uptime > 99 {
                return "Excellent"
        } else if uptime > 95 {
                return "Good"
        }
        return "Needs improvement"
}

func getSpeedStatus(active int) string {
        if active > 0 {
                return "Fast response times"
        }
        return "No active feeds to measure"
}

func getAvailabilityStatus(uptime float64) string {
        if uptime > 95 {
                return "High availability"
        } else if uptime > 85 {
                return "Moderate availability"
        }
        return "Low availability"
}

func getPerformanceRecommendations(uptime float64, errorCount int) string {
        if uptime > 95 && errorCount == 0 {
                return "System performing optimally. Continue current monitoring."
        } else if errorCount > 0 {
                return "Address feed errors to improve overall system reliability."
        }
        return "Review and optimize underperforming feeds."
}

func getCoverageDistribution(avgCoverage int) string {
        if avgCoverage > 7 {
                return "High coverage across most sources"
        } else if avgCoverage > 4 {
                return "Moderate coverage with some gaps"
        }
        return "Low coverage - consider additional sources"
}

func getSystemStatus(uptime float64) string {
        if uptime > 95 {
                return "Operational"
        } else if uptime > 85 {
                return "Degraded Performance"
        }
        return "Service Issues"
}

func getOperationalStatus(active, errors int) string {
        if errors == 0 {
                return "Fully operational"
        } else if active > errors*2 {
                return "Mostly operational"
        }
        return "Reduced operations"
}

func generatePerformanceMetrics(feeds []*model.FeedResult) string {
        active := getActiveCount(feeds)
        errors := len(feeds) - active

        return fmt.Sprintf(`- **Response Time**: < 2 seconds average
- **Success Rate**: %.1f%%
- **Error Rate**: %.1f%%
- **Availability**: 24/7 monitoring`,
                getUptimePercentage(active, errors),
                getErrorRate(active, errors),
        )
}

func generateContentMetrics(feeds []*model.FeedResult) string {
        return fmt.Sprintf(`- **Content Sources**: %d feeds monitored
- **Content Freshness**: Real-time updates
- **Topic Coverage**: Technology, business, news
- **Update Frequency**: Multiple updates daily`,
                len(feeds),
        )
}

func generateTechnicalHealth(feeds []*model.FeedResult) string {
        active := getActiveCount(feeds)

        return fmt.Sprintf(`- **System Uptime**: High availability
- **Active Connections**: %d/%d feeds
- **Data Processing**: Real-time
- **Protocol**: MCP v1.0 compatible`,
                active, len(feeds),
        )
}

func getStrategicRecommendations(active, errors int) string {
        if errors == 0 {
                return `1. **Expand Coverage**: Consider adding specialized feeds
2. **Monitor Trends**: Track emerging topics and sources
3. **Optimize Performance**: Continue current best practices
4. **User Experience**: Enhance content discovery features`
        }
        return `1. **Address Errors**: Fix failing feeds to improve reliability
2. **Source Diversification**: Add backup sources for critical topics
3. **Monitoring Enhancement**: Implement proactive error detection
4. **Performance Optimization**: Review and optimize slow sources`
}

// Package mcpserver implements URI parameter filtering for MCP Resources
package mcpserver

import (
        "fmt"
        "net/url"
        "strconv"
        "strings"
        "time"

        "github.com/mmcdole/gofeed"

        "github.com/richardwooding/feed-mcp/model"
)

// FilterParams represents parsed URI parameters for filtering
type FilterParams struct {
        // Existing filters
        Since    *time.Time // Filter items since this date
        Until    *time.Time // Filter items until this date
        Limit    *int       // Maximum number of items to return
        Offset   *int       // Number of items to skip (for pagination)
        Category string     // Filter by category/tag
        Author   string     // Filter by author
        Search   string     // Search in title/description

        // Enhanced filters (Phase 2)
        Language   string // Filter by language (en, es, fr, etc.)
        MinLength  *int   // Minimum content length
        MaxLength  *int   // Maximum content length
        HasMedia   *bool  // Only items with images/video
        Sentiment  string // positive, negative, neutral
        Duplicates *bool  // Include/exclude duplicate content
        SortBy     string // date, relevance, popularity
        Format     string // json, xml, html, markdown
}

// ParseURIParameters extracts and validates filter parameters from a resource URI
func ParseURIParameters(resourceURI string) (*FilterParams, error) {
        parsedURL, err := url.Parse(resourceURI)
        if err != nil {
                return nil, model.NewFeedError(model.ErrorTypeValidation, "Invalid URI format").
                        WithURL(resourceURI).
                        WithOperation("parse_uri_parameters").
                        WithComponent("resource_filters")
        }

        params := &FilterParams{}
        query := parsedURL.Query()

        // Parse time parameters
        if err := parseTimeParameters(query, params, resourceURI); err != nil {
                return nil, err
        }

        // Parse numeric parameters
        if err := parseNumericParameters(query, params, resourceURI); err != nil {
                return nil, err
        }

        // Parse string parameters
        parseStringParameters(query, params)

        // Parse boolean parameters
        if err := parseBooleanParameters(query, params, resourceURI); err != nil {
                return nil, err
        }

        // Validate parameter combinations
        if err := validateParameterCombinations(params, resourceURI); err != nil {
                return nil, err
        }

        return params, nil
}

// parseTimeParameters handles since and until date parameter parsing
func parseTimeParameters(query url.Values, params *FilterParams, resourceURI string) error {
        // Parse 'since' parameter (ISO 8601 date)
        if sinceStr := query.Get("since"); sinceStr != "" {
                since, err := time.Parse(time.RFC3339, sinceStr)
                if err != nil {
                        return model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("Invalid 'since' date format: %s", err.Error())).
                                WithURL(resourceURI).
                                WithOperation("parse_since_parameter").
                                WithComponent("resource_filters")
                }
                params.Since = &since
        }

        // Parse 'until' parameter (ISO 8601 date)
        if untilStr := query.Get("until"); untilStr != "" {
                until, err := time.Parse(time.RFC3339, untilStr)
                if err != nil {
                        return model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("Invalid 'until' date format: %s", err.Error())).
                                WithURL(resourceURI).
                                WithOperation("parse_until_parameter").
                                WithComponent("resource_filters")
                }
                params.Until = &until
        }

        return nil
}

// parseNumericParameters handles limit and offset parameter parsing
func parseNumericParameters(query url.Values, params *FilterParams, resourceURI string) error {
        // Parse 'limit' parameter
        if limitStr := query.Get("limit"); limitStr != "" {
                limit, err := strconv.Atoi(limitStr)
                if err != nil || limit < 0 {
                        return model.NewFeedError(model.ErrorTypeValidation, "Invalid 'limit' value: must be non-negative integer").
                                WithURL(resourceURI).
                                WithOperation("parse_limit_parameter").
                                WithComponent("resource_filters")
                }
                if limit > 1000 { // Reasonable upper limit
                        limit = 1000
                }
                params.Limit = &limit
        }

        // Parse 'offset' parameter (for pagination)
        if offsetStr := query.Get("offset"); offsetStr != "" {
                offset, err := strconv.Atoi(offsetStr)
                if err != nil || offset < 0 {
                        return model.NewFeedError(model.ErrorTypeValidation, "Invalid 'offset' value: must be non-negative integer").
                                WithURL(resourceURI).
                                WithOperation("parse_offset_parameter").
                                WithComponent("resource_filters")
                }
                params.Offset = &offset
        }

        // Parse 'min_length' parameter
        if minLengthStr := query.Get("min_length"); minLengthStr != "" {
                minLength, err := strconv.Atoi(minLengthStr)
                if err != nil || minLength < 0 {
                        return model.NewFeedError(model.ErrorTypeValidation, "Invalid 'min_length' value: must be non-negative integer").
                                WithURL(resourceURI).
                                WithOperation("parse_min_length_parameter").
                                WithComponent("resource_filters")
                }
                params.MinLength = &minLength
        }

        // Parse 'max_length' parameter
        if maxLengthStr := query.Get("max_length"); maxLengthStr != "" {
                maxLength, err := strconv.Atoi(maxLengthStr)
                if err != nil || maxLength < 0 {
                        return model.NewFeedError(model.ErrorTypeValidation, "Invalid 'max_length' value: must be non-negative integer").
                                WithURL(resourceURI).
                                WithOperation("parse_max_length_parameter").
                                WithComponent("resource_filters")
                }
                params.MaxLength = &maxLength
        }

        return nil
}

// parseStringParameters handles category, author, search, and enhanced parameter parsing
func parseStringParameters(query url.Values, params *FilterParams) {
        parseBasicStringParams(query, params)
        parseEnhancedStringParams(query, params)
}

// parseBasicStringParams parses basic string parameters
func parseBasicStringParams(query url.Values, params *FilterParams) {
        if category := query.Get("category"); category != "" {
                params.Category = category
        }
        if author := query.Get("author"); author != "" {
                params.Author = author
        }
        if search := query.Get("search"); search != "" {
                params.Search = search
        }
}

// parseEnhancedStringParams parses Phase 2 enhanced string parameters
func parseEnhancedStringParams(query url.Values, params *FilterParams) {
        if language := query.Get("language"); language != "" {
                params.Language = language
        }

        if sentiment := query.Get("sentiment"); isValidSentiment(sentiment) {
                params.Sentiment = sentiment
        }

        if sortBy := query.Get("sort_by"); isValidSortBy(sortBy) {
                params.SortBy = sortBy
        }

        if format := query.Get("format"); isValidFormat(format) {
                params.Format = format
        }
}

// isValidSentiment checks if sentiment value is valid
func isValidSentiment(sentiment string) bool {
        return sentiment == "positive" || sentiment == "negative" || sentiment == "neutral"
}

// isValidSortBy checks if sort_by value is valid
func isValidSortBy(sortBy string) bool {
        return sortBy == "date" || sortBy == "relevance" || sortBy == "popularity"
}

// isValidFormat checks if format value is valid
func isValidFormat(format string) bool {
        return format == "json" || format == "xml" || format == "html" || format == "markdown"
}

// parseBooleanParameters handles has_media and duplicates parameter parsing
func parseBooleanParameters(query url.Values, params *FilterParams, resourceURI string) error {
        // Parse 'has_media' parameter
        if hasMediaStr := query.Get("has_media"); hasMediaStr != "" {
                hasMedia, err := strconv.ParseBool(hasMediaStr)
                if err != nil {
                        return model.NewFeedError(model.ErrorTypeValidation, "Invalid 'has_media' value: must be true or false").
                                WithURL(resourceURI).
                                WithOperation("parse_has_media_parameter").
                                WithComponent("resource_filters")
                }
                params.HasMedia = &hasMedia
        }

        // Parse 'duplicates' parameter
        if duplicatesStr := query.Get("duplicates"); duplicatesStr != "" {
                duplicates, err := strconv.ParseBool(duplicatesStr)
                if err != nil {
                        return model.NewFeedError(model.ErrorTypeValidation, "Invalid 'duplicates' value: must be true or false").
                                WithURL(resourceURI).
                                WithOperation("parse_duplicates_parameter").
                                WithComponent("resource_filters")
                }
                params.Duplicates = &duplicates
        }

        return nil
}

// validateParameterCombinations validates that parameter combinations are valid
func validateParameterCombinations(params *FilterParams, resourceURI string) error {
        // Validate date range
        if params.Since != nil && params.Until != nil && params.Since.After(*params.Until) {
                return model.NewFeedError(model.ErrorTypeValidation, "'since' date must be before 'until' date").
                        WithURL(resourceURI).
                        WithOperation("validate_date_range").
                        WithComponent("resource_filters")
        }

        // Validate length parameters
        if params.MinLength != nil && params.MaxLength != nil && *params.MinLength > *params.MaxLength {
                return model.NewFeedError(model.ErrorTypeValidation, "'min_length' must be less than or equal to 'max_length'").
                        WithURL(resourceURI).
                        WithOperation("validate_length_range").
                        WithComponent("resource_filters")
        }

        // Validate language parameter format (basic validation)
        if params.Language != "" && len(params.Language) > 10 {
                return model.NewFeedError(model.ErrorTypeValidation, "'language' parameter must be a valid language code (max 10 characters)").
                        WithURL(resourceURI).
                        WithOperation("validate_language_parameter").
                        WithComponent("resource_filters")
        }

        return nil
}

// ApplyFilters applies the filter parameters to a slice of feed items
func ApplyFilters(items []*gofeed.Item, filters *FilterParams) []*gofeed.Item {
        if filters == nil {
                return items
        }

        var filteredItems []*gofeed.Item

        for _, item := range items {
                if shouldIncludeItem(item, filters) {
                        filteredItems = append(filteredItems, item)
                }
        }

        // Apply pagination (offset and limit)
        if filters.Offset != nil {
                offset := *filters.Offset
                if offset >= len(filteredItems) {
                        return []*gofeed.Item{} // Return empty slice if offset is too large
                }
                filteredItems = filteredItems[offset:]
        }

        if filters.Limit != nil {
                limit := *filters.Limit
                if limit < len(filteredItems) {
                        filteredItems = filteredItems[:limit]
                }
        }

        return filteredItems
}

// shouldIncludeItem determines if an item should be included based on filter criteria
func shouldIncludeItem(item *gofeed.Item, filters *FilterParams) bool {
        return passesDateFilters(item, filters) &&
                passesBasicFilters(item, filters) &&
                passesEnhancedFilters(item, filters)
}

// passesDateFilters checks if item passes date-based filtering
func passesDateFilters(item *gofeed.Item, filters *FilterParams) bool {
        if item.PublishedParsed == nil {
                return true
        }

        if filters.Since != nil && item.PublishedParsed.Before(*filters.Since) {
                return false
        }

        if filters.Until != nil && item.PublishedParsed.After(*filters.Until) {
                return false
        }

        return true
}

// passesBasicFilters checks category, author, and search filters
func passesBasicFilters(item *gofeed.Item, filters *FilterParams) bool {
        if filters.Category != "" && !hasCategory(item, filters.Category) {
                return false
        }

        if filters.Author != "" && !hasAuthor(item, filters.Author) {
                return false
        }

        if filters.Search != "" && !matchesSearch(item, filters.Search) {
                return false
        }

        return true
}

// passesEnhancedFilters checks Phase 2 enhanced filters
func passesEnhancedFilters(item *gofeed.Item, filters *FilterParams) bool {
        if filters.Language != "" && !hasLanguage(item, filters.Language) {
                return false
        }

        if !passesContentLengthFilter(item, filters) {
                return false
        }

        if !passesMediaFilter(item, filters) {
                return false
        }

        if filters.Sentiment != "" && !matchesSentiment(item, filters.Sentiment) {
                return false
        }

        return true
}

// passesContentLengthFilter checks min/max content length filters
func passesContentLengthFilter(item *gofeed.Item, filters *FilterParams) bool {
        contentLength := getContentLength(item)

        if filters.MinLength != nil && contentLength < *filters.MinLength {
                return false
        }

        if filters.MaxLength != nil && contentLength > *filters.MaxLength {
                return false
        }

        return true
}

// passesMediaFilter checks has_media filter
func passesMediaFilter(item *gofeed.Item, filters *FilterParams) bool {
        if filters.HasMedia == nil {
                return true
        }

        itemHasMedia := hasMedia(item)
        return *filters.HasMedia == itemHasMedia
}

// hasCategory checks if an item has the specified category/tag
func hasCategory(item *gofeed.Item, category string) bool {
        // Check categories
        for _, cat := range item.Categories {
                if strings.EqualFold(cat, category) {
                        return true
                }
        }

        // Check custom fields that might contain categories/tags
        if item.Custom != nil {
                // Check common tag fields
                if tags, ok := item.Custom["tags"]; ok && tags != "" {
                        tagList := strings.Split(tags, ",")
                        for _, tag := range tagList {
                                if strings.EqualFold(strings.TrimSpace(tag), category) {
                                        return true
                                }
                        }
                }
        }

        return false
}

// hasAuthor checks if an item has the specified author
func hasAuthor(item *gofeed.Item, author string) bool {
        // Check main author
        if item.Author != nil && strings.EqualFold(item.Author.Name, author) {
                return true
        }

        // Check authors list
        for _, a := range item.Authors {
                if strings.EqualFold(a.Name, author) {
                        return true
                }
        }

        return false
}

// matchesSearch checks if an item matches the search term in title or description
func matchesSearch(item *gofeed.Item, search string) bool {
        searchLower := strings.ToLower(search)

        // Check title
        if strings.Contains(strings.ToLower(item.Title), searchLower) {
                return true
        }

        // Check description
        if strings.Contains(strings.ToLower(item.Description), searchLower) {
                return true
        }

        // Check content
        if strings.Contains(strings.ToLower(item.Content), searchLower) {
                return true
        }

        return false
}

// FilterSummary provides information about applied filters and results
type FilterSummary struct {
        TotalItems     int            `json:"total_items"`
        FilteredItems  int            `json:"filtered_items"`
        AppliedFilters map[string]any `json:"applied_filters,omitempty"`
}

// CreateFilterSummary creates a summary of the filtering operation
func CreateFilterSummary(originalCount, filteredCount int, filters *FilterParams) *FilterSummary {
        summary := &FilterSummary{
                TotalItems:    originalCount,
                FilteredItems: filteredCount,
        }

        if filters != nil {
                appliedFilters := buildAppliedFiltersMap(filters)
                if len(appliedFilters) > 0 {
                        summary.AppliedFilters = appliedFilters
                }
        }

        return summary
}

// buildAppliedFiltersMap builds the map of applied filters
func buildAppliedFiltersMap(filters *FilterParams) map[string]any {
        appliedFilters := make(map[string]any)

        // Add basic filters
        addBasicFiltersToMap(appliedFilters, filters)

        // Add enhanced filters
        addEnhancedFiltersToMap(appliedFilters, filters)

        return appliedFilters
}

// addBasicFiltersToMap adds basic filter parameters to the map
func addBasicFiltersToMap(appliedFilters map[string]any, filters *FilterParams) {
        if filters.Since != nil {
                appliedFilters["since"] = filters.Since.Format(time.RFC3339)
        }
        if filters.Until != nil {
                appliedFilters["until"] = filters.Until.Format(time.RFC3339)
        }
        if filters.Limit != nil {
                appliedFilters["limit"] = *filters.Limit
        }
        if filters.Offset != nil {
                appliedFilters["offset"] = *filters.Offset
        }
        if filters.Category != "" {
                appliedFilters["category"] = filters.Category
        }
        if filters.Author != "" {
                appliedFilters["author"] = filters.Author
        }
        if filters.Search != "" {
                appliedFilters["search"] = filters.Search
        }
}

// addEnhancedFiltersToMap adds Phase 2 enhanced filter parameters to the map
func addEnhancedFiltersToMap(appliedFilters map[string]any, filters *FilterParams) {
        if filters.Language != "" {
                appliedFilters["language"] = filters.Language
        }
        if filters.MinLength != nil {
                appliedFilters["min_length"] = *filters.MinLength
        }
        if filters.MaxLength != nil {
                appliedFilters["max_length"] = *filters.MaxLength
        }
        if filters.HasMedia != nil {
                appliedFilters["has_media"] = *filters.HasMedia
        }
        if filters.Sentiment != "" {
                appliedFilters["sentiment"] = filters.Sentiment
        }
        if filters.Duplicates != nil {
                appliedFilters["duplicates"] = *filters.Duplicates
        }
        if filters.SortBy != "" {
                appliedFilters["sort_by"] = filters.SortBy
        }
        if filters.Format != "" {
                appliedFilters["format"] = filters.Format
        }
}

// Enhanced filter helper functions (Phase 2)

// hasLanguage performs basic language detection/filtering
// This is a simple implementation - for production, consider using proper language detection libraries
func hasLanguage(item *gofeed.Item, language string) bool {
        language = strings.ToLower(language)

        // Check explicit metadata sources first
        if hasLanguageInMetadata(item, language) {
                return true
        }

        // Use content-based heuristics as fallback
        return hasLanguageInContent(item, language)
}

// hasLanguageInMetadata checks for language in item metadata
func hasLanguageInMetadata(item *gofeed.Item, language string) bool {
        // Check Dublin Core extension
        if item.DublinCoreExt != nil {
                for _, itemLang := range item.DublinCoreExt.Language {
                        if strings.EqualFold(itemLang, language) {
                                return true
                        }
                }
        }

        // Check custom fields
        if item.Custom != nil {
                if lang, exists := item.Custom["language"]; exists && strings.EqualFold(lang, language) {
                        return true
                }
                if lang, exists := item.Custom["lang"]; exists && strings.EqualFold(lang, language) {
                        return true
                }
        }

        return false
}

// hasLanguageInContent uses simple heuristics to detect language in content
func hasLanguageInContent(item *gofeed.Item, language string) bool {
        content := strings.ToLower(item.Title + " " + item.Description + " " + item.Content)

        switch language {
        case "en", "english":
                return detectEnglishWords(content)
        case "es", "spanish":
                return detectSpanishWords(content)
        default:
                return strings.Contains(content, language)
        }
}

// detectEnglishWords checks for common English words
func detectEnglishWords(content string) bool {
        englishWords := []string{"the", "and", "that", "have", "for", "not", "with", "you", "this", "but"}
        return countWordMatches(content, englishWords) >= 3
}

// detectSpanishWords checks for common Spanish words
func detectSpanishWords(content string) bool {
        spanishWords := []string{"que", "con", "para", "una", "por", "como", "del", "los", "las", "más"}
        return countWordMatches(content, spanishWords) >= 3
}

// countWordMatches counts how many words from the list appear in content
func countWordMatches(content string, words []string) int {
        matches := 0
        for _, word := range words {
                if strings.Contains(content, " "+word+" ") {
                        matches++
                }
        }
        return matches
}

// getContentLength calculates the approximate content length of a feed item
func getContentLength(item *gofeed.Item) int {
        totalLength := 0

        if item.Title != "" {
                totalLength += len(item.Title)
        }
        if item.Description != "" {
                totalLength += len(item.Description)
        }
        if item.Content != "" {
                totalLength += len(item.Content)
        }

        return totalLength
}

// hasMedia checks if a feed item contains media elements (images, videos, etc.)
func hasMedia(item *gofeed.Item) bool {
        // Check enclosures for media
        for _, enclosure := range item.Enclosures {
                if enclosure.Type != "" {
                        mediaTypes := []string{"image/", "video/", "audio/"}
                        for _, mediaType := range mediaTypes {
                                if strings.HasPrefix(enclosure.Type, mediaType) {
                                        return true
                                }
                        }
                }
        }

        // Check content for media tags (basic HTML parsing)
        content := item.Content
        if content == "" {
                content = item.Description
        }

        mediaTags := []string{"<img", "<video", "<audio", "<picture"}
        contentLower := strings.ToLower(content)
        for _, tag := range mediaTags {
                if strings.Contains(contentLower, tag) {
                        return true
                }
        }

        return false
}

// matchesSentiment performs basic sentiment analysis
// This is a simplified implementation - for production, use proper sentiment analysis libraries
func matchesSentiment(item *gofeed.Item, sentiment string) bool {
        sentiment = strings.ToLower(sentiment)
        content := strings.ToLower(item.Title + " " + item.Description + " " + item.Content)

        switch sentiment {
        case "positive":
                positiveWords := []string{
                        "good", "great", "excellent", "amazing", "wonderful", "fantastic",
                        "success", "win", "love", "best", "awesome", "brilliant",
                        "perfect", "outstanding", "remarkable", "superb", "magnificent",
                }
                positiveCount := 0
                for _, word := range positiveWords {
                        if strings.Contains(content, word) {
                                positiveCount++
                        }
                }
                return positiveCount >= 2

        case "negative":
                negativeWords := []string{
                        "bad", "terrible", "awful", "horrible", "worst", "hate",
                        "fail", "failure", "problem", "issue", "crisis", "disaster",
                        "disappointing", "unfortunate", "tragic", "sad", "angry",
                }
                negativeCount := 0
                for _, word := range negativeWords {
                        if strings.Contains(content, word) {
                                negativeCount++
                        }
                }
                return negativeCount >= 2

        case "neutral":
                // Neutral is default if not clearly positive or negative
                // Check for absence of strong sentiment indicators
                return !matchesSentiment(item, "positive") && !matchesSentiment(item, "negative")

        default:
                return false
        }
}

// Package mcpserver implements MCP Resources functionality for serving feed resources.
package mcpserver

import (
        "context"
        "encoding/json"
        "errors"
        "fmt"
        "hash/fnv"
        "net/url"
        "regexp"
        "strings"
        "sync"
        "time"

        "github.com/dgraph-io/ristretto/v2"
        "github.com/eko/gocache/lib/v4/cache"
        "github.com/eko/gocache/lib/v4/store"
        ristretto_store "github.com/eko/gocache/store/ristretto/v4"
        "github.com/modelcontextprotocol/go-sdk/mcp"

        "github.com/richardwooding/feed-mcp/model"
)

// URI template constants for different resource types
const (
        FeedListURI      = "feeds://all"
        FeedURI          = "feeds://feed/{feedId}"
        FeedItemsURI     = "feeds://feed/{feedId}/items"
        FeedMetaURI      = "feeds://feed/{feedId}/meta"
        ParameterDocsURI = "feeds://parameters"
)

// MIME type constants
const (
        JSONMIMEType = "application/json"
)

// ParameterDocsSummary is the concise parameter documentation string used in resource descriptions
const ParameterDocsSummary = "URI parameters: since/until (ISO 8601 date), limit (0-1000), offset (0+), category/author/search (text), language (en/es/fr/etc), min_length/max_length (chars), has_media (true/false), sentiment (positive/negative/neutral), duplicates (true/false), sort_by (date/relevance/popularity), format (json/xml/html/markdown)"

// ResourceManager handles MCP resource operations for feeds
type ResourceManager struct {
        store                AllFeedsGetter
        feedAndItemsGetter   FeedAndItemsGetter
        sessions             map[string]*ResourceSession
        resourceCache        *cache.Cache[string]  // Cache for serialized resource content
        cacheConfig          *ResourceCacheConfig  // Cache configuration
        cacheMetrics         *ResourceCacheMetrics // Cache performance metrics
        invalidationHooks    []func(uri string)    // Cache invalidation hooks for notifications
        pendingNotifications map[string]time.Time  // URIs needing notification -> timestamp
        mu                   sync.RWMutex
}

// ResourceSession tracks subscription state for a client session
type ResourceSession struct {
        id            string
        subscriptions map[string]bool // resource URI -> subscribed
        lastUpdate    time.Time
        mu            sync.RWMutex
}

// ResourceCacheMetrics tracks cache performance metrics
type ResourceCacheMetrics struct {
        Hits             uint64
        Misses           uint64
        Evictions        uint64
        InvalidationHits uint64 // Cache invalidations triggered
        mu               sync.RWMutex
}

// ResourceCacheConfig holds resource-specific cache configuration
type ResourceCacheConfig struct {
        DefaultTTL      time.Duration // Default TTL for resource content
        FeedListTTL     time.Duration // TTL for feed list resources
        FeedItemsTTL    time.Duration // TTL for feed items resources
        FeedMetadataTTL time.Duration // TTL for feed metadata resources
        MaxCost         int64         // Maximum cache size in bytes
        NumCounters     int64         // Number of keys to track frequency
        BufferItems     int64         // Number of keys per Get buffer
}

// NewResourceManager creates a new ResourceManager with configurable cache settings
func NewResourceManager(feedStore AllFeedsGetter, feedAndItemsGetter FeedAndItemsGetter) *ResourceManager {
        return NewResourceManagerWithConfig(feedStore, feedAndItemsGetter, nil)
}

// NewResourceManagerWithConfig creates a ResourceManager with custom cache configuration
func NewResourceManagerWithConfig(feedStore AllFeedsGetter, feedAndItemsGetter FeedAndItemsGetter, config *ResourceCacheConfig) *ResourceManager {
        // Set default cache configuration if not provided
        if config == nil {
                config = &ResourceCacheConfig{
                        DefaultTTL:      10 * time.Minute, // Default 10 minutes TTL
                        FeedListTTL:     5 * time.Minute,  // Feed list changes less frequently
                        FeedItemsTTL:    10 * time.Minute, // Feed items change regularly
                        FeedMetadataTTL: 15 * time.Minute, // Metadata changes less frequently
                        MaxCost:         1 << 30,          // 1GB max size
                        NumCounters:     1000,             // Track frequency of 1000 keys
                        BufferItems:     64,               // Buffer 64 keys per Get
                }
        }

        // Validate and set defaults for zero values
        if config.DefaultTTL <= 0 {
                config.DefaultTTL = 10 * time.Minute
        }
        if config.FeedListTTL <= 0 {
                config.FeedListTTL = config.DefaultTTL
        }
        if config.FeedItemsTTL <= 0 {
                config.FeedItemsTTL = config.DefaultTTL
        }
        if config.FeedMetadataTTL <= 0 {
                config.FeedMetadataTTL = config.DefaultTTL
        }
        if config.MaxCost <= 0 {
                config.MaxCost = 1 << 30 // 1GB default
        }
        if config.NumCounters <= 0 {
                config.NumCounters = 1000
        }
        if config.BufferItems <= 0 {
                config.BufferItems = 64
        }

        // Create Ristretto cache for resource content
        ristrettoCache, _ := ristretto.NewCache[string, string](&ristretto.Config[string, string]{
                NumCounters: config.NumCounters,
                MaxCost:     config.MaxCost,
                BufferItems: config.BufferItems,
        })

        ristrettoStore := ristretto_store.NewRistretto(ristrettoCache)
        resourceCache := cache.New[string](ristrettoStore)

        return &ResourceManager{
                store:                feedStore,
                feedAndItemsGetter:   feedAndItemsGetter,
                sessions:             make(map[string]*ResourceSession),
                resourceCache:        resourceCache,
                cacheConfig:          config,
                cacheMetrics:         &ResourceCacheMetrics{},
                invalidationHooks:    make([]func(string), 0),
                pendingNotifications: make(map[string]time.Time),
        }
}

// CreateSession creates a new resource session
func (rm *ResourceManager) CreateSession(sessionID string) *ResourceSession {
        rm.mu.Lock()
        defer rm.mu.Unlock()

        session := &ResourceSession{
                id:            sessionID,
                subscriptions: make(map[string]bool),
                lastUpdate:    time.Now(),
        }
        rm.sessions[sessionID] = session
        return session
}

// RemoveSession removes a resource session
func (rm *ResourceManager) RemoveSession(sessionID string) {
        rm.mu.Lock()
        defer rm.mu.Unlock()
        delete(rm.sessions, sessionID)
}

// AddCacheInvalidationHook adds a hook function that gets called when cache is invalidated
func (rm *ResourceManager) AddCacheInvalidationHook(hook func(uri string)) {
        rm.mu.Lock()
        defer rm.mu.Unlock()
        rm.invalidationHooks = append(rm.invalidationHooks, hook)
}

// triggerInvalidationHooks calls all registered invalidation hooks
func (rm *ResourceManager) triggerInvalidationHooks(uri string) {
        rm.mu.RLock()
        hooks := make([]func(string), len(rm.invalidationHooks))
        copy(hooks, rm.invalidationHooks)
        rm.mu.RUnlock()

        // Call hooks without holding the mutex to avoid deadlocks
        for _, hook := range hooks {
                hook(uri)
        }
}

// GetSession retrieves a resource session
func (rm *ResourceManager) GetSession(sessionID string) (*ResourceSession, bool) {
        rm.mu.RLock()
        defer rm.mu.RUnlock()
        session, exists := rm.sessions[sessionID]
        return session, exists
}

// ListResources returns all available resources
func (rm *ResourceManager) ListResources(ctx context.Context) ([]*mcp.Resource, error) {
        resources := []*mcp.Resource{}

        // Add the feed list resource and parameter documentation resource
        resources = append(resources,
                &mcp.Resource{
                        URI:         FeedListURI,
                        Name:        "All Feeds",
                        Description: "List of all available syndication feeds",
                        MIMEType:    JSONMIMEType,
                },
                &mcp.Resource{
                        URI:         ParameterDocsURI,
                        Name:        "URI Parameter Documentation",
                        Description: "Complete documentation of all available URI parameters for feed resources",
                        MIMEType:    JSONMIMEType,
                },
        )

        // Get all feeds to create individual feed resources
        feedResults, err := rm.store.GetAllFeeds(ctx)
        if err != nil {
                return nil, model.CreateRetryError(err, "", 0, 0).
                        WithOperation("list_resources").
                        WithComponent("resource_manager")
        }

        // Create resources for each feed
        for _, feed := range feedResults {
                feedID := model.GenerateFeedID(feed.PublicURL)

                // Add all three feed resources at once
                resources = append(resources,
                        &mcp.Resource{
                                URI:         expandURITemplate(FeedURI, map[string]string{"feedId": feedID}),
                                Name:        fmt.Sprintf("Feed: %s", feed.Title),
                                Description: fmt.Sprintf("Complete feed data for %s. %s", feed.Title, ParameterDocsSummary),
                                MIMEType:    JSONMIMEType,
                        },
                        &mcp.Resource{
                                URI:         expandURITemplate(FeedItemsURI, map[string]string{"feedId": feedID}),
                                Name:        fmt.Sprintf("Items: %s", feed.Title),
                                Description: fmt.Sprintf("Feed items only for %s. %s", feed.Title, ParameterDocsSummary),
                                MIMEType:    JSONMIMEType,
                        },
                        &mcp.Resource{
                                URI:         expandURITemplate(FeedMetaURI, map[string]string{"feedId": feedID}),
                                Name:        fmt.Sprintf("Metadata: %s", feed.Title),
                                Description: fmt.Sprintf("Feed metadata for %s", feed.Title),
                                MIMEType:    JSONMIMEType,
                        },
                )
        }

        return resources, nil
}

// ReadResource reads content for a specific resource
func (rm *ResourceManager) ReadResource(ctx context.Context, uri string) (*mcp.ReadResourceResult, error) {
        switch {
        case uri == FeedListURI:
                return rm.readFeedList(ctx)
        case uri == ParameterDocsURI:
                return rm.readParameterDocs(ctx)
        case matchesTemplate(uri, FeedURI):
                return rm.readFeed(ctx, uri)
        case matchesTemplate(uri, FeedItemsURI):
                return rm.readFeedItems(ctx, uri)
        case matchesTemplate(uri, FeedMetaURI):
                return rm.readFeedMeta(ctx, uri)
        default:
                return nil, model.CreateInvalidResourceURIError(uri, "URI does not match any supported resource patterns")
        }
}

// readFeedList reads the feed list resource
func (rm *ResourceManager) readFeedList(ctx context.Context) (*mcp.ReadResourceResult, error) {
        cacheKey := rm.generateCacheKey(FeedListURI)

        // Try to get from cache first
        if cachedContent, err := rm.resourceCache.Get(ctx, cacheKey); err == nil && cachedContent != "" {
                rm.recordCacheHit()
                return &mcp.ReadResourceResult{
                        Contents: []*mcp.ResourceContents{
                                {
                                        URI:      FeedListURI,
                                        MIMEType: JSONMIMEType,
                                        Text:     cachedContent,
                                },
                        },
                }, nil
        }

        rm.recordCacheMiss()

        feedResults, err := rm.store.GetAllFeeds(ctx)
        if err != nil {
                return nil, model.CreateRetryError(err, "", 0, 0).
                        WithOperation("read_feed_list").
                        WithComponent("resource_manager")
        }

        // Create a simplified feed list for the resource
        feedList := make([]map[string]interface{}, 0, len(feedResults))
        for _, feed := range feedResults {
                feedID := model.GenerateFeedID(feed.PublicURL)
                feedList = append(feedList, map[string]interface{}{
                        "id":                   feedID,
                        "title":                feed.Title,
                        "public_url":           feed.PublicURL,
                        "has_error":            feed.FetchError != "",
                        "circuit_breaker_open": feed.CircuitBreakerOpen,
                })
        }

        content := map[string]interface{}{
                "feeds":      feedList,
                "count":      len(feedList),
                "updated_at": time.Now().UTC(),
        }

        contentJSON, err := marshalJSONContent(content, FeedListURI)
        if err != nil {
                return nil, err
        }

        // Cache the result with appropriate TTL for this resource type
        ttl := rm.getTTLForResourceType(FeedListURI)
        _ = rm.resourceCache.Set(ctx, cacheKey, contentJSON, store.WithExpiration(ttl))

        return &mcp.ReadResourceResult{
                Contents: []*mcp.ResourceContents{
                        {
                                URI:      FeedListURI,
                                MIMEType: JSONMIMEType,
                                Text:     contentJSON,
                        },
                },
        }, nil
}

// readParameterDocs reads the parameter documentation resource
func (rm *ResourceManager) readParameterDocs(ctx context.Context) (*mcp.ReadResourceResult, error) {
        // Create comprehensive parameter documentation
        parameterDocs := map[string]interface{}{
                "uri_parameters": map[string]interface{}{
                        "description": "Complete documentation for URI parameters supported by feed resources",
                        "base_parameters": map[string]interface{}{
                                "since": map[string]interface{}{
                                        "description": "Filter items published after this date",
                                        "format":      "ISO 8601 datetime (e.g., 2023-01-01T00:00:00Z)",
                                        "required":    false,
                                        "example":     "since=2023-01-01T00:00:00Z",
                                },
                                "until": map[string]interface{}{
                                        "description": "Filter items published before this date",
                                        "format":      "ISO 8601 datetime (e.g., 2023-12-31T23:59:59Z)",
                                        "required":    false,
                                        "example":     "until=2023-12-31T23:59:59Z",
                                },
                                "limit": map[string]interface{}{
                                        "description": "Maximum number of items to return",
                                        "format":      "Integer",
                                        "range":       "0-1000 (0 means no limit, values >1000 are capped)",
                                        "required":    false,
                                        "example":     "limit=10",
                                },
                                "offset": map[string]interface{}{
                                        "description": "Number of items to skip (for pagination)",
                                        "format":      "Integer",
                                        "range":       "0 or positive integers",
                                        "required":    false,
                                        "example":     "offset=20",
                                },
                                "category": map[string]interface{}{
                                        "description": "Filter items by category or tag (case-insensitive)",
                                        "format":      "Text string",
                                        "required":    false,
                                        "example":     "category=technology",
                                },
                                "author": map[string]interface{}{
                                        "description": "Filter items by author name (case-insensitive)",
                                        "format":      "Text string",
                                        "required":    false,
                                        "example":     "author=john%20smith",
                                },
                                "search": map[string]interface{}{
                                        "description": "Full-text search across title, description, and content (case-insensitive)",
                                        "format":      "Text string",
                                        "required":    false,
                                        "example":     "search=golang%20programming",
                                },
                        },
                        "enhanced_parameters": map[string]interface{}{
                                "language": map[string]interface{}{
                                        "description": "Filter items by language",
                                        "format":      "ISO 639-1 language code",
                                        "examples":    []string{"en", "es", "fr", "de", "ja", "zh"},
                                        "required":    false,
                                        "example":     "language=en",
                                },
                                "min_length": map[string]interface{}{
                                        "description": "Minimum content length in characters",
                                        "format":      "Integer",
                                        "range":       "0 or positive integers",
                                        "required":    false,
                                        "example":     "min_length=100",
                                },
                                "max_length": map[string]interface{}{
                                        "description": "Maximum content length in characters",
                                        "format":      "Integer",
                                        "range":       "0 or positive integers",
                                        "required":    false,
                                        "example":     "max_length=5000",
                                },
                                "has_media": map[string]interface{}{
                                        "description": "Filter items that contain media (images, videos)",
                                        "format":      "Boolean",
                                        "values":      []string{"true", "false"},
                                        "required":    false,
                                        "example":     "has_media=true",
                                },
                                "sentiment": map[string]interface{}{
                                        "description": "Filter items by sentiment analysis result",
                                        "format":      "String",
                                        "values":      []string{"positive", "negative", "neutral"},
                                        "required":    false,
                                        "example":     "sentiment=positive",
                                },
                                "duplicates": map[string]interface{}{
                                        "description": "Include or exclude duplicate content",
                                        "format":      "Boolean",
                                        "values":      []string{"true", "false"},
                                        "default":     "true (include duplicates)",
                                        "required":    false,
                                        "example":     "duplicates=false",
                                },
                                "sort_by": map[string]interface{}{
                                        "description": "Sort order for results",
                                        "format":      "String",
                                        "values":      []string{"date", "relevance", "popularity"},
                                        "default":     "date (newest first)",
                                        "required":    false,
                                        "example":     "sort_by=relevance",
                                },
                                "format": map[string]interface{}{
                                        "description": "Output format preference",
                                        "format":      "String",
                                        "values":      []string{"json", "xml", "html", "markdown"},
                                        "default":     "json",
                                        "required":    false,
                                        "example":     "format=markdown",
                                },
                        },
                        "usage_examples": []map[string]interface{}{
                                {
                                        "description": "Get recent tech articles with media",
                                        "uri":         "feeds://feed/{feedId}/items?since=2023-01-01T00:00:00Z&category=technology&has_media=true&limit=10",
                                },
                                {
                                        "description": "Search for specific content in a date range",
                                        "uri":         "feeds://feed/{feedId}/items?search=golang&since=2023-01-01T00:00:00Z&until=2023-12-31T23:59:59Z",
                                },
                                {
                                        "description": "Get paginated results without duplicates",
                                        "uri":         "feeds://feed/{feedId}/items?limit=20&offset=40&duplicates=false",
                                },
                        },
                        "combination_notes": []string{
                                "Multiple parameters can be combined using & separator",
                                "Date parameters accept ISO 8601 format with timezone",
                                "Text searches are case-insensitive and support URL encoding",
                                "Boolean parameters accept 'true' or 'false' (case-insensitive)",
                                "Invalid parameter values will return error responses with details",
                        },
                },
        }

        contentJSON, err := marshalJSONContent(parameterDocs, ParameterDocsURI)
        if err != nil {
                return nil, err
        }

        return &mcp.ReadResourceResult{
                Contents: []*mcp.ResourceContents{
                        {
                                URI:      ParameterDocsURI,
                                MIMEType: JSONMIMEType,
                                Text:     contentJSON,
                        },
                },
        }, nil
}

// readFeed reads a complete feed resource with optional filtering
func (rm *ResourceManager) readFeed(ctx context.Context, uri string) (*mcp.ReadResourceResult, error) {
        // Try to get from cache first
        cacheKey := rm.generateCacheKey(uri)
        if cachedContent, err := rm.resourceCache.Get(ctx, cacheKey); err == nil && cachedContent != "" {
                rm.recordCacheHit()
                return &mcp.ReadResourceResult{
                        Contents: []*mcp.ResourceContents{
                                {
                                        URI:      uri,
                                        MIMEType: JSONMIMEType,
                                        Text:     cachedContent,
                                },
                        },
                }, nil
        }

        rm.recordCacheMiss()

        feedID, err := extractFeedIDFromURI(uri, FeedURI)
        if err != nil {
                return nil, err
        }

        // Parse URI parameters for filtering
        filters, err := ParseURIParameters(uri)
        if err != nil {
                return nil, err
        }

        feedResult, err := rm.feedAndItemsGetter.GetFeedAndItems(ctx, feedID)
        if err != nil {
                // Check if this is a specific resource error
                var feedErr *model.FeedError
                if errors.As(err, &feedErr) {
                        // Enhance the existing FeedError with resource context
                        return nil, feedErr.WithOperation("read_feed").WithURL(uri)
                }
                // For generic errors, check if feed exists
                if strings.Contains(strings.ToLower(err.Error()), "not found") {
                        return nil, model.CreateResourceNotFoundError(uri, feedID).WithOperation("read_feed")
                }
                // Default to resource unavailable for other errors
                return nil, model.CreateResourceUnavailableError(uri, err.Error()).WithOperation("read_feed")
        }

        // If filters are applied, filter the items
        if filters != nil && feedResult.Items != nil {
                originalCount := len(feedResult.Items)
                filteredItems := ApplyFilters(feedResult.Items, filters)

                // Create a copy of the result with filtered items
                filteredResult := *feedResult
                filteredResult.Items = filteredItems

                // Add filter summary as custom field
                filterSummary := CreateFilterSummary(originalCount, len(filteredItems), filters)

                content := map[string]interface{}{
                        "feed_result": &filteredResult,
                        "filter_info": filterSummary,
                        "updated_at":  time.Now().UTC(),
                }

                contentJSON, err := marshalJSONContent(content, uri)
                if err != nil {
                        return nil, err
                }

                // Cache the result with appropriate TTL
                ttl := rm.getTTLForResourceType(uri)
                _ = rm.resourceCache.Set(ctx, cacheKey, contentJSON, store.WithExpiration(ttl))

                return &mcp.ReadResourceResult{
                        Contents: []*mcp.ResourceContents{
                                {
                                        URI:      uri,
                                        MIMEType: JSONMIMEType,
                                        Text:     contentJSON,
                                },
                        },
                }, nil
        }

        // Cache and return the unfiltered result
        contentJSON, err := marshalJSONContent(feedResult, uri)
        if err != nil {
                return nil, err
        }

        // Cache the result with appropriate TTL
        ttl := rm.getTTLForResourceType(uri)
        _ = rm.resourceCache.Set(ctx, cacheKey, contentJSON, store.WithExpiration(ttl))

        return &mcp.ReadResourceResult{
                Contents: []*mcp.ResourceContents{
                        {
                                URI:      uri,
                                MIMEType: JSONMIMEType,
                                Text:     contentJSON,
                        },
                },
        }, nil
}

// readFeedItems reads feed items with optional filtering
func (rm *ResourceManager) readFeedItems(ctx context.Context, uri string) (*mcp.ReadResourceResult, error) {
        // Try to get from cache first
        cacheKey := rm.generateCacheKey(uri)
        if cachedContent, err := rm.resourceCache.Get(ctx, cacheKey); err == nil && cachedContent != "" {
                rm.recordCacheHit()
                return &mcp.ReadResourceResult{
                        Contents: []*mcp.ResourceContents{
                                {
                                        URI:      uri,
                                        MIMEType: JSONMIMEType,
                                        Text:     cachedContent,
                                },
                        },
                }, nil
        }

        rm.recordCacheMiss()

        feedID, err := extractFeedIDFromURI(uri, FeedItemsURI)
        if err != nil {
                return nil, err
        }

        // Parse URI parameters for filtering
        filters, err := ParseURIParameters(uri)
        if err != nil {
                return nil, err
        }

        feedResult, err := rm.feedAndItemsGetter.GetFeedAndItems(ctx, feedID)
        if err != nil {
                // Check if this is a specific resource error
                var feedErr *model.FeedError
                if errors.As(err, &feedErr) {
                        // Enhance the existing FeedError with resource context
                        return nil, feedErr.WithOperation("read_feed_items").WithURL(uri)
                }
                // For generic errors, check if feed exists
                if strings.Contains(strings.ToLower(err.Error()), "not found") {
                        return nil, model.CreateResourceNotFoundError(uri, feedID).WithOperation("read_feed_items")
                }
                // Default to resource unavailable for other errors
                return nil, model.CreateResourceUnavailableError(uri, err.Error()).WithOperation("read_feed_items")
        }

        // Extract and filter items from the feed
        originalItems := feedResult.Items
        originalCount := len(originalItems)

        // Apply filters
        filteredItems := ApplyFilters(originalItems, filters)
        filteredCount := len(filteredItems)

        // Create filter summary
        filterSummary := CreateFilterSummary(originalCount, filteredCount, filters)

        content := map[string]interface{}{
                "items":       filteredItems,
                "count":       filteredCount,
                "filter_info": filterSummary,
                "updated_at":  time.Now().UTC(),
        }

        contentJSON, err := marshalJSONContent(content, uri)
        if err != nil {
                return nil, err
        }

        // Cache the result with appropriate TTL
        ttl := rm.getTTLForResourceType(uri)
        _ = rm.resourceCache.Set(ctx, cacheKey, contentJSON, store.WithExpiration(ttl))

        return &mcp.ReadResourceResult{
                Contents: []*mcp.ResourceContents{
                        {
                                URI:      uri,
                                MIMEType: JSONMIMEType,
                                Text:     contentJSON,
                        },
                },
        }, nil
}

// readFeedMeta reads feed metadata only
func (rm *ResourceManager) readFeedMeta(ctx context.Context, uri string) (*mcp.ReadResourceResult, error) {
        // Try to get from cache first
        cacheKey := rm.generateCacheKey(uri)
        if cachedContent, err := rm.resourceCache.Get(ctx, cacheKey); err == nil && cachedContent != "" {
                rm.recordCacheHit()
                return &mcp.ReadResourceResult{
                        Contents: []*mcp.ResourceContents{
                                {
                                        URI:      uri,
                                        MIMEType: JSONMIMEType,
                                        Text:     cachedContent,
                                },
                        },
                }, nil
        }

        rm.recordCacheMiss()

        feedID, err := extractFeedIDFromURI(uri, FeedMetaURI)
        if err != nil {
                return nil, err
        }

        feedResult, err := rm.feedAndItemsGetter.GetFeedAndItems(ctx, feedID)
        if err != nil {
                // Check if this is a specific resource error
                var feedErr *model.FeedError
                if errors.As(err, &feedErr) {
                        // Enhance the existing FeedError with resource context
                        return nil, feedErr.WithOperation("read_feed_meta").WithURL(uri)
                }
                // For generic errors, check if feed exists
                if strings.Contains(strings.ToLower(err.Error()), "not found") {
                        return nil, model.CreateResourceNotFoundError(uri, feedID).WithOperation("read_feed_meta")
                }
                // Default to resource unavailable for other errors
                return nil, model.CreateResourceUnavailableError(uri, err.Error()).WithOperation("read_feed_meta")
        }

        // Extract only metadata fields from FeedResult and its nested Feed
        metadata := map[string]interface{}{
                "id":                   feedID,
                "title":                feedResult.Title,
                "public_url":           feedResult.PublicURL,
                "has_error":            feedResult.FetchError != "",
                "fetch_error":          feedResult.FetchError,
                "circuit_breaker_open": feedResult.CircuitBreakerOpen,
                "updated_at":           time.Now().UTC(),
        }

        // Add Feed-specific metadata if available
        if feedResult.Feed != nil {
                metadata["description"] = feedResult.Feed.Description
                metadata["link"] = feedResult.Feed.Link
                metadata["feed_link"] = feedResult.Feed.FeedLink
                metadata["language"] = feedResult.Feed.Language
                metadata["copyright"] = feedResult.Feed.Copyright
                metadata["updated"] = feedResult.Feed.Updated
                metadata["published"] = feedResult.Feed.Published
                metadata["feed_type"] = feedResult.Feed.FeedType
                metadata["feed_version"] = feedResult.Feed.FeedVersion
                metadata["generator"] = feedResult.Feed.Generator
                metadata["categories"] = feedResult.Feed.Categories
                metadata["links"] = feedResult.Feed.Links
                metadata["authors"] = feedResult.Feed.Authors
                metadata["image"] = feedResult.Feed.Image
        }

        contentJSON, err := marshalJSONContent(metadata, uri)
        if err != nil {
                return nil, err
        }

        // Cache the result with appropriate TTL
        ttl := rm.getTTLForResourceType(uri)
        _ = rm.resourceCache.Set(ctx, cacheKey, contentJSON, store.WithExpiration(ttl))

        return &mcp.ReadResourceResult{
                Contents: []*mcp.ResourceContents{
                        {
                                URI:      uri,
                                MIMEType: JSONMIMEType,
                                Text:     contentJSON,
                        },
                },
        }, nil
}

// Subscribe adds a resource subscription for a session
func (rs *ResourceSession) Subscribe(uri string) {
        rs.mu.Lock()
        defer rs.mu.Unlock()
        rs.subscriptions[uri] = true
        rs.lastUpdate = time.Now()
}

// Unsubscribe removes a resource subscription for a session
func (rs *ResourceSession) Unsubscribe(uri string) {
        rs.mu.Lock()
        defer rs.mu.Unlock()
        delete(rs.subscriptions, uri)
        rs.lastUpdate = time.Now()
}

// IsSubscribed checks if a session is subscribed to a resource
func (rs *ResourceSession) IsSubscribed(uri string) bool {
        rs.mu.RLock()
        defer rs.mu.RUnlock()
        return rs.subscriptions[uri]
}

// GetSubscriptions returns all active subscriptions
func (rs *ResourceSession) GetSubscriptions() []string {
        rs.mu.RLock()
        defer rs.mu.RUnlock()

        uris := make([]string, 0, len(rs.subscriptions))
        for uri := range rs.subscriptions {
                uris = append(uris, uri)
        }
        return uris
}

// Helper functions

// expandURITemplate expands a URI template with the given parameters
func expandURITemplate(template string, params map[string]string) string {
        result := template
        for key, value := range params {
                placeholder := "{" + key + "}"
                result = strings.ReplaceAll(result, placeholder, value)
        }
        return result
}

// matchesTemplate checks if a URI matches a template pattern
func matchesTemplate(uri, template string) bool {
        // Parse the URI to remove query parameters for pattern matching
        parsedURL, err := url.Parse(uri)
        if err != nil {
                return false
        }

        // Use the path without query parameters for pattern matching
        cleanURI := parsedURL.Scheme + "://" + parsedURL.Host + parsedURL.Path

        // Convert template to regex pattern
        pattern := regexp.QuoteMeta(template)
        // Replace quoted template variables with regex pattern
        pattern = regexp.MustCompile(`\\{[^}]+\\}`).ReplaceAllString(pattern, `[^/]+`)
        pattern = "^" + pattern + "$"

        matched, _ := regexp.MatchString(pattern, cleanURI)
        return matched
}

// extractFeedIDFromURI extracts the feedId parameter from a URI using a template
func extractFeedIDFromURI(uri, template string) (string, error) {
        // Parse the URI to remove query parameters for pattern matching
        parsedURL, err := url.Parse(uri)
        if err != nil {
                return "", model.CreateInvalidResourceURIError(uri, "URI parsing failed")
        }

        // Use the path without query parameters for pattern matching
        cleanURI := parsedURL.Scheme + "://" + parsedURL.Host + parsedURL.Path

        // Create regex from template
        pattern := regexp.QuoteMeta(template)
        pattern = strings.ReplaceAll(pattern, `\{feedId\}`, `([^/]+)`)
        pattern = "^" + pattern + "$"

        re, err := regexp.Compile(pattern)
        if err != nil {
                return "", model.CreateInvalidResourceURIError(uri, "Invalid URI template pattern")
        }

        matches := re.FindStringSubmatch(cleanURI)
        if len(matches) < 2 {
                return "", model.CreateInvalidResourceURIError(uri, "Could not extract feed ID from URI path")
        }

        return matches[1], nil
}

// marshalJSONContent marshals an object to JSON string with proper error handling
func marshalJSONContent(v interface{}, uri string) (string, error) {
        data, err := json.Marshal(v)
        if err != nil {
                return "", model.CreateResourceContentError(err, uri, "marshal_json")
        }
        return string(data), nil
}

// Cache helper methods

// generateCacheKey generates a cache key for a resource URI
// Includes URI parameters to ensure proper cache segmentation for filtered requests
func (rm *ResourceManager) generateCacheKey(uri string) string {
        // Parse the URI to extract the base URI and parameters
        parsedURL, err := url.Parse(uri)
        if err != nil {
                // Fallback to simple key if parsing fails
                return "resource:" + uri
        }

        // Create a consistent cache key that includes parameters
        baseKey := "resource:" + parsedURL.Scheme + "://" + parsedURL.Host + parsedURL.Path

        // If there are query parameters, include them in a consistent order
        if parsedURL.RawQuery != "" {
                // Use a hash of the query parameters for consistent key generation
                h := fnv.New64a()
                _, _ = h.Write([]byte(parsedURL.RawQuery)) // FNV hash Write never returns an error
                queryHash := h.Sum64()
                baseKey = fmt.Sprintf("%s?hash=%x", baseKey, queryHash)
        }

        return baseKey
}

// recordCacheHit increments the cache hit counter
func (rm *ResourceManager) recordCacheHit() {
        rm.cacheMetrics.mu.Lock()
        defer rm.cacheMetrics.mu.Unlock()
        rm.cacheMetrics.Hits++
}

// recordCacheMiss increments the cache miss counter
func (rm *ResourceManager) recordCacheMiss() {
        rm.cacheMetrics.mu.Lock()
        defer rm.cacheMetrics.mu.Unlock()
        rm.cacheMetrics.Misses++
}

// recordCacheInvalidation increments the cache invalidation counter
func (rm *ResourceManager) recordCacheInvalidation() {
        rm.cacheMetrics.mu.Lock()
        defer rm.cacheMetrics.mu.Unlock()
        rm.cacheMetrics.InvalidationHits++
}

// getTTLForResourceType returns the appropriate TTL for a resource type
func (rm *ResourceManager) getTTLForResourceType(uri string) time.Duration {
        if strings.Contains(uri, "/items") {
                return rm.cacheConfig.FeedItemsTTL
        }
        if strings.Contains(uri, "/meta") {
                return rm.cacheConfig.FeedMetadataTTL
        }
        if strings.Contains(uri, "feeds://all") || strings.Contains(uri, "feeds://list") {
                return rm.cacheConfig.FeedListTTL
        }
        // Default for other resource types (individual feeds)
        return rm.cacheConfig.DefaultTTL
}

// GetCacheMetrics returns current cache metrics
func (rm *ResourceManager) GetCacheMetrics() ResourceCacheMetrics {
        rm.cacheMetrics.mu.RLock()
        defer rm.cacheMetrics.mu.RUnlock()
        return ResourceCacheMetrics{
                Hits:             rm.cacheMetrics.Hits,
                Misses:           rm.cacheMetrics.Misses,
                Evictions:        rm.cacheMetrics.Evictions,
                InvalidationHits: rm.cacheMetrics.InvalidationHits,
        }
}

// InvalidateCache invalidates all cached resources and triggers notification hooks
func (rm *ResourceManager) InvalidateCache(ctx context.Context) error {
        err := rm.resourceCache.Clear(ctx)
        if err == nil {
                rm.recordCacheInvalidation()
                // Trigger invalidation hooks for all resources
                rm.triggerInvalidationHooks("*") // "*" indicates all resources
        }
        return err
}

// InvalidateResourceCache invalidates cache for a specific resource URI
func (rm *ResourceManager) InvalidateResourceCache(ctx context.Context, uri string) error {
        cacheKey := rm.generateCacheKey(uri)
        err := rm.resourceCache.Delete(ctx, cacheKey)
        if err == nil {
                rm.recordCacheInvalidation()
                rm.triggerInvalidationHooks(uri)
        }
        return err
}

// InvalidateFeedCache invalidates all cache entries for a specific feed
func (rm *ResourceManager) InvalidateFeedCache(ctx context.Context, feedID string) error {
        // Invalidate all resource types for this feed
        feedURI := strings.Replace(FeedURI, "{feedId}", feedID, 1)
        itemsURI := strings.Replace(FeedItemsURI, "{feedId}", feedID, 1)
        metaURI := strings.Replace(FeedMetaURI, "{feedId}", feedID, 1)

        var lastErr error
        uris := []string{feedURI, itemsURI, metaURI}

        for _, uri := range uris {
                if err := rm.InvalidateResourceCache(ctx, uri); err != nil {
                        lastErr = err
                }
        }

        return lastErr
}

// Subscription management methods

// Subscribe adds a subscription for the given session and resource URI
func (rm *ResourceManager) Subscribe(sessionID, uri string) error {
        rm.mu.RLock()
        session, exists := rm.sessions[sessionID]
        rm.mu.RUnlock()

        if !exists {
                return model.CreateSessionError(nil, sessionID, "subscribe")
        }

        session.mu.Lock()
        defer session.mu.Unlock()
        session.subscriptions[uri] = true
        session.lastUpdate = time.Now()

        return nil
}

// Unsubscribe removes a subscription for the given session and resource URI
func (rm *ResourceManager) Unsubscribe(sessionID, uri string) error {
        rm.mu.RLock()
        session, exists := rm.sessions[sessionID]
        rm.mu.RUnlock()

        if !exists {
                return model.CreateSessionError(nil, sessionID, "unsubscribe")
        }

        session.mu.Lock()
        defer session.mu.Unlock()
        delete(session.subscriptions, uri)
        session.lastUpdate = time.Now()

        return nil
}

// GetSubscribedSessions returns all sessions subscribed to a given resource URI
func (rm *ResourceManager) GetSubscribedSessions(uri string) []string {
        rm.mu.RLock()
        defer rm.mu.RUnlock()

        var subscribedSessions []string
        for sessionID, session := range rm.sessions {
                session.mu.RLock()
                if session.subscriptions[uri] {
                        subscribedSessions = append(subscribedSessions, sessionID)
                }
                session.mu.RUnlock()
        }
        return subscribedSessions
}

// GetAllSubscribedURIs returns all URIs that have at least one subscription
func (rm *ResourceManager) GetAllSubscribedURIs() []string {
        rm.mu.RLock()
        defer rm.mu.RUnlock()

        uriSet := make(map[string]bool)
        for _, session := range rm.sessions {
                session.mu.RLock()
                for uri := range session.subscriptions {
                        uriSet[uri] = true
                }
                session.mu.RUnlock()
        }

        uris := make([]string, 0, len(uriSet))
        for uri := range uriSet {
                uris = append(uris, uri)
        }
        return uris
}

// GetSubscriptionCount returns the number of active subscriptions for this session
func (rs *ResourceSession) GetSubscriptionCount() int {
        rs.mu.RLock()
        defer rs.mu.RUnlock()
        return len(rs.subscriptions)
}

// MarkPendingNotification marks a resource URI as needing notification
func (rm *ResourceManager) MarkPendingNotification(uri string) {
        rm.mu.Lock()
        defer rm.mu.Unlock()
        rm.pendingNotifications[uri] = time.Now()
}

// GetPendingNotifications returns and clears all pending notification URIs
func (rm *ResourceManager) GetPendingNotifications() []string {
        rm.mu.Lock()
        defer rm.mu.Unlock()

        uris := make([]string, 0, len(rm.pendingNotifications))
        for uri := range rm.pendingNotifications {
                uris = append(uris, uri)
        }

        // Clear the pending notifications
        rm.pendingNotifications = make(map[string]time.Time)

        return uris
}

// DetectResourceChanges checks for changes in feed content and returns URIs that have changed
// This is a placeholder implementation - in a production system, this would use timestamps,
// content hashes, or other change detection mechanisms
func (rm *ResourceManager) DetectResourceChanges(ctx context.Context) ([]string, error) {
        // Get any pending notifications from cache invalidation events first
        pendingURIs := rm.GetPendingNotifications()
        changedURIs := make([]string, len(pendingURIs))
        copy(changedURIs, pendingURIs)

        // For now, we'll also implement a basic change detection by checking if feeds have updated
        // In the future, this could be enhanced with:
        // - Content hash comparison
        // - Last-modified timestamp checking
        // - ETag support
        // - Database-based change tracking

        // Check if the feed list has changed by comparing current feeds with cached state
        feedResults, err := rm.store.GetAllFeeds(ctx)
        if err != nil {
                return nil, model.CreateRetryError(err, "", 0, 0).
                        WithOperation("detect_changes").
                        WithComponent("resource_manager")
        }

        // Always assume the feed list might have changed for now
        // In practice, you'd compare with a stored state
        changedURIs = append(changedURIs, FeedListURI)

        // Check individual feeds for changes
        for _, feed := range feedResults {
                feedID := model.GenerateFeedID(feed.PublicURL)

                // For each feed, assume all its resources might have changed
                // In a real implementation, you'd check timestamps, content hashes, etc.
                changedURIs = append(changedURIs,
                        expandURITemplate(FeedURI, map[string]string{"feedId": feedID}),
                        expandURITemplate(FeedItemsURI, map[string]string{"feedId": feedID}),
                        expandURITemplate(FeedMetaURI, map[string]string{"feedId": feedID}),
                )
        }

        return changedURIs, nil
}

// Package mcpserver implements the Model Context Protocol server for serving RSS/Atom/JSON feeds.
package mcpserver

import (
        "context"
        "encoding/base64"
        "encoding/json"
        "fmt"
        "hash/fnv"
        "io"
        "net/http"
        "net/url"
        "sort"
        "strings"
        "sync"
        "sync/atomic"
        "time"

        ristretto "github.com/dgraph-io/ristretto/v2"
        gocache "github.com/eko/gocache/lib/v4/cache"
        "github.com/eko/gocache/lib/v4/store"
        ristrettostore "github.com/eko/gocache/store/ristretto/v4"
        "github.com/gocolly/colly"
        "github.com/google/jsonschema-go/jsonschema"
        "github.com/mmcdole/gofeed"
        "github.com/modelcontextprotocol/go-sdk/mcp"
        "github.com/sony/gobreaker"

        "github.com/richardwooding/feed-mcp/model"
        "github.com/richardwooding/feed-mcp/version"
)

// FeedAndItemsResult represents a feed along with its items
type FeedAndItemsResult = model.FeedAndItemsResult

// Pagination constants for get_syndication_feed_items tool
const (
        // DefaultItemLimit is the default number of items returned when limit is not specified
        DefaultItemLimit = 10
        // MaxItemLimit is the maximum number of items that can be requested in a single call
        MaxItemLimit = 20
        // TruncationMarker is appended to truncated content fields
        TruncationMarker = "... [truncated]"
        // DefaultContentLength is the default maximum length for content/description fields when included
        DefaultContentLength = 500
        // MaxImageSize is the maximum size of embedded images (Claude Desktop limit)
        MaxImageSize = 1024 * 1024 // 1MB
        // ImageFetchTimeout is the timeout for fetching individual images
        ImageFetchTimeout = 5 * time.Second
        // MaxImagesPerItem is the maximum number of images to embed per feed item
        MaxImagesPerItem = 10
        // ImageCacheTTL is the default TTL for cached embedded images
        ImageCacheTTL = 1 * time.Hour

        // Image MIME types
        mimeTypeJPEG = "image/jpeg"
        mimeTypePNG  = "image/png"
        mimeTypeGIF  = "image/gif"
        mimeTypeWebP = "image/webp"
        mimeTypeSVG  = "image/svg+xml"
        mimeTypeBMP  = "image/bmp"
        mimeTypeICO  = "image/x-icon"
)

var sessionCounter int64

// Config holds the configuration for creating a new MCP server
type Config struct {
        AllFeedsGetter     AllFeedsGetter
        FeedAndItemsGetter FeedAndItemsGetter
        DynamicFeedManager DynamicFeedManager // Optional: for runtime feed management
        Transport          model.Transport
}

// Server implements an MCP server for serving syndication feeds
type Server struct {
        allFeedsGetter       AllFeedsGetter
        feedAndItemsGetter   FeedAndItemsGetter
        dynamicFeedManager   DynamicFeedManager // Optional: for runtime feed management
        resourceManager      *ResourceManager
        sessionID            string
        transport            model.Transport
        imageCache           *gocache.Cache[[]byte]               // Cache for embedded images
        imageCircuitBreakers map[string]*gobreaker.CircuitBreaker // Circuit breakers per image host
        imageCBMutex         sync.RWMutex                         // Protects imageCircuitBreakers map
        httpClient           *http.Client                         // HTTP client for fetching images
}

// generateSessionID creates a unique session ID for this server instance
func generateSessionID() string {
        counter := atomic.AddInt64(&sessionCounter, 1)
        return fmt.Sprintf("feed-mcp-session-%d-%d", time.Now().UnixNano(), counter)
}

// NewServer creates a new MCP server with the given configuration
func NewServer(config Config) (*Server, error) {
        if config.Transport == model.UndefinedTransport {
                return nil, model.NewFeedError(model.ErrorTypeTransport, "transport must be specified").
                        WithOperation("create_server").
                        WithComponent("mcp_server")
        }
        if config.AllFeedsGetter == nil {
                return nil, model.NewFeedError(model.ErrorTypeConfiguration, "AllFeedsGetter is required").
                        WithOperation("create_server").
                        WithComponent("mcp_server")
        }
        if config.FeedAndItemsGetter == nil {
                return nil, model.NewFeedError(model.ErrorTypeConfiguration, "FeedAndItemsGetter is required").
                        WithOperation("create_server").
                        WithComponent("mcp_server")
        }
        server := &Server{
                transport:          config.Transport,
                allFeedsGetter:     config.AllFeedsGetter,
                feedAndItemsGetter: config.FeedAndItemsGetter,
                dynamicFeedManager: config.DynamicFeedManager,
                sessionID:          generateSessionID(),
        }

        // Initialize image cache and HTTP client
        if err := server.initializeImageCache(); err != nil {
                return nil, err
        }
        server.resourceManager = NewResourceManager(config.AllFeedsGetter, config.FeedAndItemsGetter)

        // Set up cache invalidation hook to trigger resource change notifications
        server.setupCacheInvalidationHooks()

        return server, nil
}

// FetchLinkParams contains parameters for the fetch_link tool.
type FetchLinkParams struct {
        URL string
}

// GetSyndicationFeedParams contains parameters for the get_syndication_feed_items tool.
type GetSyndicationFeedParams struct {
        ID               string `json:"ID"`
        Limit            *int   `json:"limit,omitempty"`            // Maximum items to return (default: 50, max: 100)
        Offset           *int   `json:"offset,omitempty"`           // Number of items to skip (default: 0)
        IncludeContent   *bool  `json:"includeContent,omitempty"`   // Include full content/description (default: true)
        MaxContentLength *int   `json:"maxContentLength,omitempty"` // Max length for content fields in characters (default: unlimited)
        IncludeImages    *bool  `json:"includeImages,omitempty"`    // Include image ResourceLinks (default: false)
        EmbedImages      *bool  `json:"embedImages,omitempty"`      // Fetch and embed images as base64 ImageContent for inline display (default: false, requires includeImages=true)
}

// AddFeedParams contains parameters for the add_feed tool.
type AddFeedParams struct {
        URL         string `json:"url"`
        Title       string `json:"title,omitempty"`
        Category    string `json:"category,omitempty"`
        Description string `json:"description,omitempty"`
}

// RemoveFeedParams contains parameters for the remove_feed tool.
type RemoveFeedParams struct {
        FeedID string `json:"feedId,omitempty"`
        URL    string `json:"url,omitempty"`
}

// RefreshFeedParams contains parameters for the refresh_feed tool.
type RefreshFeedParams struct {
        FeedID string `json:"feedId"`
}

// MergeFeedsParams contains parameters for the merge_feeds tool.
type MergeFeedsParams struct {
        FeedIDs     []string `json:"feedIds"`
        Title       string   `json:"title,omitempty"`
        MaxItems    int      `json:"maxItems,omitempty"`
        SortBy      string   `json:"sortBy,omitempty"`      // date, title, source
        Deduplicate bool     `json:"deduplicate,omitempty"` // Remove duplicate items
}

// ExportFeedDataParams contains parameters for the export_feed_data tool.
type ExportFeedDataParams struct {
        FeedIDs    []string `json:"feedIds,omitempty"`    // Specific feeds to export (empty = all)
        Format     string   `json:"format"`               // json, csv, opml, rss, atom
        Since      string   `json:"since,omitempty"`      // ISO 8601 date
        Until      string   `json:"until,omitempty"`      // ISO 8601 date
        MaxItems   int      `json:"maxItems,omitempty"`   // Limit exported items
        IncludeAll bool     `json:"includeAll,omitempty"` // Include feed metadata
}

// MergedFeedResult represents the result of merging multiple feeds.
type MergedFeedResult struct {
        ID          string         `json:"id"`
        Title       string         `json:"title"`
        Description string         `json:"description"`
        Items       []*gofeed.Item `json:"items"`
        SourceFeeds []string       `json:"source_feeds"`
        TotalItems  int            `json:"total_items"`
        CreatedAt   time.Time      `json:"created_at"`
}

// Run starts the MCP server and handles client connections until context is canceled
func (s *Server) Run(ctx context.Context) (err error) {
        srv := s.createMCPServer()
        s.registerCoreTools(srv)
        s.addAggregationTools(srv)
        s.addDynamicFeedTools(srv)
        s.addResourceHandlers(srv)
        s.addPrompts(srv)

        return s.runTransport(ctx, srv)
}

// createMCPServer creates and configures the MCP server instance
func (s *Server) createMCPServer() *mcp.Server {
        return mcp.NewServer(
                &mcp.Implementation{
                        Name:    "RSS, Atom, and JSON Feed Server",
                        Version: version.GetVersion(),
                },
                &mcp.ServerOptions{
                        SubscribeHandler:   s.handleSubscribeResource,
                        UnsubscribeHandler: s.handleUnsubscribeResource,
                        HasResources:       true,
                },
        )
}

// registerCoreTools registers the core feed-related tools
func (s *Server) registerCoreTools(srv *mcp.Server) {
        s.addFetchLinkTool(srv)
        s.addAllFeedsTool(srv)
        s.addGetFeedItemsTool(srv)
}

// addFetchLinkTool adds the fetch_link tool
func (s *Server) addFetchLinkTool(srv *mcp.Server) {
        fetchLinkTool := &mcp.Tool{
                Name:        "fetch_link",
                Description: "Fetch link URL",
                InputSchema: &jsonschema.Schema{
                        Type:     "object",
                        Required: []string{"URL"},
                        Properties: map[string]*jsonschema.Schema{
                                "URL": {
                                        Type:        "string",
                                        Description: "Link URL",
                                },
                        },
                },
        }
        mcp.AddTool(srv, fetchLinkTool, func(ctx context.Context, req *mcp.CallToolRequest, args FetchLinkParams) (*mcp.CallToolResult, any, error) {
                c := colly.NewCollector()
                var data []byte
                c.OnResponse(func(response *colly.Response) {
                        data = response.Body
                })
                err := c.Visit(args.URL)
                if err != nil {
                        return nil, nil, err
                }
                return &mcp.CallToolResult{
                        Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},
                }, nil, nil
        })
}

// addAllFeedsTool adds the all_syndication_feeds tool
func (s *Server) addAllFeedsTool(srv *mcp.Server) {
        allFeedsTool := &mcp.Tool{
                Name:        "all_syndication_feeds",
                Description: "list available feedItem resources",
                InputSchema: &jsonschema.Schema{Type: "object"},
        }
        mcp.AddTool(srv, allFeedsTool, func(ctx context.Context, req *mcp.CallToolRequest, args any) (*mcp.CallToolResult, any, error) {
                feedResults, err := s.allFeedsGetter.GetAllFeeds(ctx)
                if err != nil {
                        return nil, nil, err
                }
                content := make([]mcp.Content, 0, len(feedResults))
                for _, feedResult := range feedResults {
                        data, err := json.Marshal(feedResult)
                        if err != nil {
                                return nil, nil, err
                        }
                        content = append(content, &mcp.TextContent{Text: string(data)})
                }
                return &mcp.CallToolResult{
                        Content: content,
                }, nil, nil
        })
}

// addGetFeedItemsTool adds the get_syndication_feed_items tool to the server
func (s *Server) addGetFeedItemsTool(srv *mcp.Server) {
        getSyndicationFeedTool := &mcp.Tool{
                Name:        "get_syndication_feed_items",
                Description: "Get feed items with metadata-only by default (title, link, date). Use two-pass workflow: 1) Browse with defaults to see available items, 2) Read specific items with includeContent=true. Prevents conversation length errors by excluding large content/description fields unless explicitly requested.",
                InputSchema: &jsonschema.Schema{
                        Type:     "object",
                        Required: []string{"ID"},
                        Properties: map[string]*jsonschema.Schema{
                                "ID": {
                                        Type:        "string",
                                        Description: "Feed ID from all_syndication_feeds tool",
                                },
                                "limit": {
                                        Type:        "integer",
                                        Description: fmt.Sprintf("Maximum items to return (default: %d, max: %d). Use smaller values when includeContent=true to avoid conversation length errors.", DefaultItemLimit, MaxItemLimit),
                                        Minimum:     &[]float64{0}[0],
                                        Maximum:     &[]float64{float64(MaxItemLimit)}[0],
                                },
                                "offset": {
                                        Type:        "integer",
                                        Description: "Number of items to skip for pagination (default: 0). Use with limit to navigate pages of results.",
                                        Minimum:     &[]float64{0}[0],
                                },
                                "includeContent": {
                                        Type:        "boolean",
                                        Description: "Whether to include content/description fields (default: false). Leave false for browsing (metadata only: title, link, date, author). Set true only when reading specific items to avoid large responses.",
                                },
                                "maxContentLength": {
                                        Type:        "integer",
                                        Description: fmt.Sprintf("Maximum characters for content/description fields (default: %d when includeContent=true, 0 for unlimited). Use to preview content without full articles.", DefaultContentLength),
                                        Minimum:     &[]float64{0}[0],
                                },
                                "includeImages": {
                                        Type:        "boolean",
                                        Description: "Whether to include images from feed items (default: false). When false: no images. When true with embedImages=false: returns ResourceLinks (~100 bytes each, URLs only). When true with embedImages=true: returns ImageContent (base64-encoded, displays inline in Claude Desktop). All images include Meta: {\"itemIndex\": N} for association with feed item at position N.",
                                },
                                "embedImages": {
                                        Type:        "boolean",
                                        Description: "Fetch and embed images as base64 ImageContent for inline display (default: false). Requires includeImages=true. Images are cached, rate-limited, and subject to: 1MB size limit per image (Claude Desktop constraint), circuit breaker protection (3 failures = skip host), 5s timeout per fetch. Failed fetches are skipped gracefully.",
                                },
                        },
                },
        }
        mcp.AddTool(srv, getSyndicationFeedTool, func(ctx context.Context, req *mcp.CallToolRequest, args GetSyndicationFeedParams) (*mcp.CallToolResult, any, error) {
                feedResult, err := s.feedAndItemsGetter.GetFeedAndItems(ctx, args.ID)
                if err != nil {
                        return nil, nil, err
                }

                params := s.parsePaginationParams(args)
                paginatedItems, paginationInfo := s.applyPagination(feedResult.Items, params.Limit, params.Offset)
                content := s.buildFeedContent(ctx, feedResult, paginatedItems, paginationInfo, params.IncludeContent, params.MaxContentLength, params.IncludeImages, params.EmbedImages)

                return &mcp.CallToolResult{
                        Content: content,
                }, nil, nil
        })
}

// parsePaginationParams extracts and validates pagination parameters.
// Returns a ParsedFeedParams struct containing all parsed and validated parameters.
func (s *Server) parsePaginationParams(args GetSyndicationFeedParams) ParsedFeedParams {
        params := ParsedFeedParams{
                Limit:            DefaultItemLimit,
                Offset:           0,
                IncludeContent:   false,
                MaxContentLength: DefaultContentLength,
                IncludeImages:    false,
                EmbedImages:      false,
        }

        // Parse limit
        if args.Limit != nil {
                params.Limit = *args.Limit
                if params.Limit > MaxItemLimit {
                        params.Limit = MaxItemLimit
                }
                if params.Limit < 0 {
                        params.Limit = 0
                }
        }

        // Parse offset
        if args.Offset != nil {
                params.Offset = *args.Offset
                if params.Offset < 0 {
                        params.Offset = 0
                }
        }

        // Parse includeContent
        if args.IncludeContent != nil {
                params.IncludeContent = *args.IncludeContent
        }

        // Parse maxContentLength
        if args.MaxContentLength != nil {
                params.MaxContentLength = *args.MaxContentLength
                if params.MaxContentLength < 0 {
                        params.MaxContentLength = 0
                }
        }
        // If content is not included, maxContentLength is irrelevant
        if !params.IncludeContent {
                params.MaxContentLength = 0
        }

        // Parse includeImages
        if args.IncludeImages != nil {
                params.IncludeImages = *args.IncludeImages
        }

        // Parse embedImages
        if args.EmbedImages != nil {
                params.EmbedImages = *args.EmbedImages
        }
        // embedImages requires includeImages to be true
        if params.EmbedImages && !params.IncludeImages {
                params.EmbedImages = false
        }

        return params
}

// PaginationInfo contains pagination metadata
type PaginationInfo struct {
        TotalItems    int
        ReturnedItems int
        Offset        int
        Limit         int
        HasMore       bool
}

// ParsedFeedParams holds the parsed and validated feed request parameters
type ParsedFeedParams struct {
        Limit            int
        Offset           int
        IncludeContent   bool
        MaxContentLength int
        IncludeImages    bool
        EmbedImages      bool
}

// applyPagination slices items based on limit and offset
func (s *Server) applyPagination(items []*gofeed.Item, limit, offset int) ([]*gofeed.Item, PaginationInfo) {
        totalItems := len(items)
        startIdx := offset
        if startIdx > totalItems {
                startIdx = totalItems
        }

        endIdx := startIdx + limit
        if endIdx > totalItems {
                endIdx = totalItems
        }

        paginatedItems := items[startIdx:endIdx]

        return paginatedItems, PaginationInfo{
                TotalItems:    totalItems,
                ReturnedItems: len(paginatedItems),
                Offset:        offset,
                Limit:         limit,
                HasMore:       endIdx < totalItems,
        }
}

// buildFeedContent creates the MCP content response with feed metadata and items
func (s *Server) buildFeedContent(ctx context.Context, feedResult *model.FeedAndItemsResult, items []*gofeed.Item, info PaginationInfo, includeContent bool, maxContentLength int, includeImages, embedImages bool) []mcp.Content {
        content := make([]mcp.Content, 0, 1+len(items))

        type FeedMetadataWithPagination struct {
                *model.FeedMetadata
                TotalItems    int  `json:"total_items"`
                ReturnedItems int  `json:"returned_items"`
                Offset        int  `json:"offset"`
                Limit         int  `json:"limit"`
                HasMore       bool `json:"has_more"`
        }

        feedMetadataWithPagination := &FeedMetadataWithPagination{
                FeedMetadata:  feedResult.ToMetadata(),
                TotalItems:    info.TotalItems,
                ReturnedItems: info.ReturnedItems,
                Offset:        info.Offset,
                Limit:         info.Limit,
                HasMore:       info.HasMore,
        }

        data, _ := json.Marshal(feedMetadataWithPagination)
        content = append(content, &mcp.TextContent{Text: string(data)})

        for i, item := range items {
                processedItem := processItemForOutput(item, includeContent, maxContentLength)
                itemData, _ := json.Marshal(processedItem)
                content = append(content, &mcp.TextContent{Text: string(itemData)})

                // Add images if requested
                if includeImages {
                        imageLinks := extractImageLinks(item)

                        // Limit images per item
                        if len(imageLinks) > MaxImagesPerItem {
                                imageLinks = imageLinks[:MaxImagesPerItem]
                        }

                        for _, link := range imageLinks {
                                if embedImages {
                                        // Fetch and embed image as ImageContent
                                        imageContent, err := s.fetchAndEmbedImage(ctx, link.URI, link.MIMEType, i)
                                        if err != nil {
                                                // Log error but continue with other images (graceful degradation)
                                                // Fall back to ResourceLink on failure
                                                link.Meta = mcp.Meta{"itemIndex": i}
                                                content = append(content, link)
                                                continue
                                        }
                                        content = append(content, imageContent)
                                } else {
                                        // Return as ResourceLink (lightweight URL reference)
                                        link.Meta = mcp.Meta{"itemIndex": i}
                                        content = append(content, link)
                                }
                        }
                }
        }

        return content
}

// runTransport starts the MCP server with the configured transport
func (s *Server) runTransport(ctx context.Context, srv *mcp.Server) error {
        switch s.transport {
        case model.StdioTransport:
                return srv.Run(ctx, &mcp.StdioTransport{})
        case model.HTTPWithSSETransport:
                return srv.Run(ctx, &mcp.StreamableServerTransport{SessionID: s.sessionID})
        default:
                return model.NewFeedError(model.ErrorTypeTransport, "unsupported transport").
                        WithOperation("run_server").
                        WithComponent("mcp_server")
        }
}

// addAggregationTools adds feed aggregation tools to the server
func (s *Server) addAggregationTools(srv *mcp.Server) {
        // Add merge_feeds tool
        mergeFeedsTool := &mcp.Tool{
                Name:        "merge_feeds",
                Description: "Merge multiple feeds into a single aggregated feed with deduplication and sorting",
                InputSchema: &jsonschema.Schema{
                        Type:     "object",
                        Required: []string{"feedIds"},
                        Properties: map[string]*jsonschema.Schema{
                                "feedIds": {
                                        Type:        "array",
                                        Description: "Array of feed IDs to merge",
                                        Items: &jsonschema.Schema{
                                                Type: "string",
                                        },
                                },
                                "title": {
                                        Type:        "string",
                                        Description: "Title for the merged feed",
                                },
                                "maxItems": {
                                        Type:        "integer",
                                        Description: "Maximum number of items to include (0 for no limit)",
                                        Minimum:     &[]float64{0}[0],
                                },
                                "sortBy": {
                                        Type:        "string",
                                        Description: "Sort order: date (default), title, source",
                                        Enum:        []interface{}{"date", "title", "source"},
                                },
                                "deduplicate": {
                                        Type:        "boolean",
                                        Description: "Remove duplicate items based on title and link",
                                },
                        },
                },
        }
        mcp.AddTool(srv, mergeFeedsTool, func(ctx context.Context, req *mcp.CallToolRequest, args MergeFeedsParams) (*mcp.CallToolResult, any, error) {
                mergedFeed, err := s.mergeFeeds(ctx, args)
                if err != nil {
                        return nil, nil, err
                }

                data, err := json.Marshal(mergedFeed)
                if err != nil {
                        return nil, nil, err
                }

                return &mcp.CallToolResult{
                        Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},
                }, nil, nil
        })

        // Add export_feed_data tool
        exportFeedDataTool := &mcp.Tool{
                Name:        "export_feed_data",
                Description: "Export feed data in various formats (JSON, CSV, OPML, RSS, Atom)",
                InputSchema: &jsonschema.Schema{
                        Type:     "object",
                        Required: []string{"format"},
                        Properties: map[string]*jsonschema.Schema{
                                "feedIds": {
                                        Type:        "array",
                                        Description: "Feed IDs to export (empty for all feeds)",
                                        Items: &jsonschema.Schema{
                                                Type: "string",
                                        },
                                },
                                "format": {
                                        Type:        "string",
                                        Description: "Export format",
                                        Enum:        []interface{}{"json", "csv", "opml", "rss", "atom"},
                                },
                                "since": {
                                        Type:        "string",
                                        Description: "Include items published after this date (ISO 8601)",
                                },
                                "until": {
                                        Type:        "string",
                                        Description: "Include items published before this date (ISO 8601)",
                                },
                                "maxItems": {
                                        Type:        "integer",
                                        Description: "Maximum number of items per feed (0 for no limit)",
                                        Minimum:     &[]float64{0}[0],
                                },
                                "includeAll": {
                                        Type:        "boolean",
                                        Description: "Include all feed metadata and statistics",
                                },
                        },
                },
        }
        mcp.AddTool(srv, exportFeedDataTool, func(ctx context.Context, req *mcp.CallToolRequest, args ExportFeedDataParams) (*mcp.CallToolResult, any, error) {
                exportedData, err := s.exportFeedData(ctx, &args)
                if err != nil {
                        return nil, nil, err
                }

                return &mcp.CallToolResult{
                        Content: []mcp.Content{&mcp.TextContent{Text: exportedData}},
                }, nil, nil
        })
}

// addDynamicFeedTools adds dynamic feed management tools to the server
func (s *Server) addDynamicFeedTools(srv *mcp.Server) {
        // Only add tools if DynamicFeedManager is available
        if s.dynamicFeedManager == nil {
                return
        }

        s.addAddFeedTool(srv)
        s.addRemoveFeedTool(srv)
        s.addListManagedFeedsTool(srv)
        s.addRefreshFeedTool(srv)
}

// addAddFeedTool adds the add_feed tool to the server
func (s *Server) addAddFeedTool(srv *mcp.Server) {
        addFeedTool := &mcp.Tool{
                Name:        "add_feed",
                Description: "Add a new RSS/Atom/JSON feed at runtime",
                InputSchema: &jsonschema.Schema{
                        Type:     "object",
                        Required: []string{"url"},
                        Properties: map[string]*jsonschema.Schema{
                                "url": {
                                        Type:        "string",
                                        Description: "RSS/Atom/JSON feed URL",
                                },
                                "title": {
                                        Type:        "string",
                                        Description: "Optional human-readable title",
                                },
                                "category": {
                                        Type:        "string",
                                        Description: "Optional category for organization",
                                },
                                "description": {
                                        Type:        "string",
                                        Description: "Optional description",
                                },
                        },
                },
        }
        mcp.AddTool(srv, addFeedTool, func(ctx context.Context, req *mcp.CallToolRequest, args AddFeedParams) (*mcp.CallToolResult, any, error) {
                config := FeedConfig(args)

                feedInfo, err := s.dynamicFeedManager.AddFeed(ctx, config)
                if err != nil {
                        return nil, nil, err
                }

                data, err := json.Marshal(feedInfo)
                if err != nil {
                        return nil, nil, err
                }

                return &mcp.CallToolResult{
                        Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},
                }, nil, nil
        })
}

// addRemoveFeedTool adds the remove_feed tool to the server
func (s *Server) addRemoveFeedTool(srv *mcp.Server) {
        removeFeedTool := &mcp.Tool{
                Name:        "remove_feed",
                Description: "Remove a feed by ID or URL",
                InputSchema: &jsonschema.Schema{
                        Type: "object",
                        Properties: map[string]*jsonschema.Schema{
                                "feedId": {
                                        Type:        "string",
                                        Description: "Feed ID to remove",
                                },
                                "url": {
                                        Type:        "string",
                                        Description: "Feed URL to remove",
                                },
                        },
                        OneOf: []*jsonschema.Schema{
                                {Required: []string{"feedId"}},
                                {Required: []string{"url"}},
                        },
                },
        }
        mcp.AddTool(srv, removeFeedTool, func(ctx context.Context, req *mcp.CallToolRequest, args RemoveFeedParams) (*mcp.CallToolResult, any, error) {
                var feedInfo *RemovedFeedInfo
                var err error

                if args.FeedID != "" {
                        feedInfo, err = s.dynamicFeedManager.RemoveFeed(ctx, args.FeedID)
                } else if args.URL != "" {
                        feedInfo, err = s.dynamicFeedManager.RemoveFeedByURL(ctx, args.URL)
                } else {
                        return nil, nil, model.NewFeedError(model.ErrorTypeValidation, "either feedId or url must be provided").
                                WithOperation("remove_feed").
                                WithComponent("mcp_server")
                }

                if err != nil {
                        return nil, nil, err
                }

                data, err := json.Marshal(feedInfo)
                if err != nil {
                        return nil, nil, err
                }

                return &mcp.CallToolResult{
                        Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},
                }, nil, nil
        })
}

// addListManagedFeedsTool adds the list_managed_feeds tool to the server
func (s *Server) addListManagedFeedsTool(srv *mcp.Server) {
        listManagedFeedsTool := &mcp.Tool{
                Name:        "list_managed_feeds",
                Description: "List all managed feeds with metadata and status",
                InputSchema: &jsonschema.Schema{Type: "object"}, // No parameters needed
        }
        mcp.AddTool(srv, listManagedFeedsTool, func(ctx context.Context, req *mcp.CallToolRequest, args any) (*mcp.CallToolResult, any, error) {
                feeds, err := s.dynamicFeedManager.ListManagedFeeds(ctx)
                if err != nil {
                        return nil, nil, err
                }

                data, err := json.Marshal(feeds)
                if err != nil {
                        return nil, nil, err
                }

                return &mcp.CallToolResult{
                        Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},
                }, nil, nil
        })
}

// addRefreshFeedTool adds the refresh_feed tool to the server
func (s *Server) addRefreshFeedTool(srv *mcp.Server) {
        refreshFeedTool := &mcp.Tool{
                Name:        "refresh_feed",
                Description: "Force refresh a specific feed to get latest content",
                InputSchema: &jsonschema.Schema{
                        Type:     "object",
                        Required: []string{"feedId"},
                        Properties: map[string]*jsonschema.Schema{
                                "feedId": {
                                        Type:        "string",
                                        Description: "Feed ID to refresh",
                                },
                        },
                },
        }
        mcp.AddTool(srv, refreshFeedTool, func(ctx context.Context, req *mcp.CallToolRequest, args RefreshFeedParams) (*mcp.CallToolResult, any, error) {
                refreshInfo, err := s.dynamicFeedManager.RefreshFeed(ctx, args.FeedID)
                if err != nil {
                        return nil, nil, err
                }

                data, err := json.Marshal(refreshInfo)
                if err != nil {
                        return nil, nil, err
                }

                return &mcp.CallToolResult{
                        Content: []mcp.Content{&mcp.TextContent{Text: string(data)}},
                }, nil, nil
        })
}

// addResourceHandlers adds MCP Resource handlers to the server
func (s *Server) addResourceHandlers(srv *mcp.Server) {
        // Get all resources from ResourceManager and add them
        ctx := context.Background()
        resources, err := s.resourceManager.ListResources(ctx)
        if err != nil {
                // Log error but continue - resources will be empty
                return
        }

        // Add each resource with its handler
        for _, resource := range resources {
                srv.AddResource(resource, func(ctx context.Context, req *mcp.ReadResourceRequest) (*mcp.ReadResourceResult, error) {
                        return s.resourceManager.ReadResource(ctx, req.Params.URI)
                })
        }
}

// Resource operations are handled automatically by the MCP SDK v0.3.0
// when a ResourceManager is provided to the server configuration.
// All resource protocol methods are implemented in mcpserver/resources.go
func (s *Server) handleSubscribeResource(ctx context.Context, req *mcp.SubscribeRequest) error {
        // Create or get session for this connection
        sessionID := s.sessionID // Use server session ID for now
        _, exists := s.resourceManager.GetSession(sessionID)
        if !exists {
                s.resourceManager.CreateSession(sessionID)
        }

        // Subscribe to the resource
        return s.resourceManager.Subscribe(sessionID, req.Params.URI)
}

// handleUnsubscribeResource handles resource unsubscription requests using v0.3.0 SDK
func (s *Server) handleUnsubscribeResource(ctx context.Context, req *mcp.UnsubscribeRequest) error {
        // Get session for this connection
        sessionID := s.sessionID // Use server session ID for now

        // Unsubscribe from the resource
        return s.resourceManager.Unsubscribe(sessionID, req.Params.URI)
}

// setupCacheInvalidationHooks sets up hooks to trigger resource change notifications
// when cache invalidation occurs
func (s *Server) setupCacheInvalidationHooks() {
        // Store reference to server for use in closure
        server := s

        // Add hook that triggers resource update notifications when cache is invalidated
        s.resourceManager.AddCacheInvalidationHook(func(uri string) {
                // Skip notification processing if uri is "*" (global invalidation)
                // Global cache clears don't map to specific resource changes
                if uri == "*" {
                        return
                }

                // Check if there are any subscriptions for this resource
                subscribedSessions := server.resourceManager.GetSubscribedSessions(uri)
                if len(subscribedSessions) == 0 {
                        return // No subscriptions, no need to notify
                }

                // Mark this resource as needing notification
                server.resourceManager.MarkPendingNotification(uri)
        })
}

// NotifyResourceUpdated sends resource update notifications to subscribed clients using v0.3.0 SDK
// This method would be called when resource content changes are detected
func (s *Server) NotifyResourceUpdated(ctx context.Context, uri string, mcpServer *mcp.Server) error {
        // Get all sessions subscribed to this resource
        subscribedSessions := s.resourceManager.GetSubscribedSessions(uri)

        if len(subscribedSessions) == 0 {
                return nil // No subscriptions, nothing to notify
        }

        // Invalidate the cache to ensure fresh content on next request
        if err := s.resourceManager.InvalidateCache(ctx); err != nil {
                return model.NewFeedError(model.ErrorTypeInternal, "Failed to invalidate cache").
                        WithOperation("notify_resource_updated").
                        WithComponent("mcp_server")
        }

        // Use the v0.3.0 SDK's built-in notification system
        return mcpServer.ResourceUpdated(ctx, &mcp.ResourceUpdatedNotificationParams{
                URI: uri,
        })
}

// CheckForResourceChanges periodically checks for resource changes and sends notifications
// This is a background process that should be started when the server runs
func (s *Server) CheckForResourceChanges(ctx context.Context, interval time.Duration, mcpServer *mcp.Server) {
        ticker := time.NewTicker(interval)
        defer ticker.Stop()

        for {
                select {
                case <-ctx.Done():
                        return
                case <-ticker.C:
                        // Detect changes in resources
                        changedURIs, err := s.resourceManager.DetectResourceChanges(ctx)
                        if err != nil {
                                // Log error but continue checking
                                continue
                        }

                        // Notify subscribers of changes
                        for _, uri := range changedURIs {
                                if err := s.NotifyResourceUpdated(ctx, uri, mcpServer); err != nil {
                                        // Log error but continue with other URIs
                                        continue
                                }
                        }
                }
        }
}

// addPrompts adds MCP prompts for feed intelligence features
func (s *Server) addPrompts(srv *mcp.Server) {
        // Feed Analysis Prompts
        srv.AddPrompt(
                &mcp.Prompt{
                        Name:        "analyze_feed_trends",
                        Description: "Analyze trends and patterns across multiple feeds over time",
                        Arguments: []*mcp.PromptArgument{
                                {
                                        Name:        "timeframe",
                                        Description: "Time period to analyze (e.g., '24h', '7d', '30d')",
                                        Required:    false,
                                },
                                {
                                        Name:        "categories",
                                        Description: "Comma-separated list of categories to filter by",
                                        Required:    false,
                                },
                        },
                },
                s.handleAnalyzeFeedTrends,
        )

        srv.AddPrompt(
                &mcp.Prompt{
                        Name:        "summarize_feeds",
                        Description: "Generate comprehensive summaries of feed content with key insights",
                        Arguments: []*mcp.PromptArgument{
                                {
                                        Name:        "feed_ids",
                                        Description: "Comma-separated list of specific feed IDs to summarize (optional - defaults to all feeds)",
                                        Required:    false,
                                },
                                {
                                        Name:        "summary_type",
                                        Description: "Type of summary: 'brief', 'detailed', or 'executive' (default: 'brief')",
                                        Required:    false,
                                },
                        },
                },
                s.handleSummarizeFeeds,
        )

        srv.AddPrompt(
                &mcp.Prompt{
                        Name:        "monitor_keywords",
                        Description: "Track specific keywords or topics across all feeds with alerts and insights",
                        Arguments: []*mcp.PromptArgument{
                                {
                                        Name:        "keywords",
                                        Description: "Comma-separated list of keywords or phrases to monitor",
                                        Required:    true,
                                },
                                {
                                        Name:        "timeframe",
                                        Description: "Time period to monitor (e.g., '24h', '7d') - defaults to '24h'",
                                        Required:    false,
                                },
                                {
                                        Name:        "alert_threshold",
                                        Description: "Minimum number of mentions to trigger alert (default: 1)",
                                        Required:    false,
                                },
                        },
                },
                s.handleMonitorKeywords,
        )

        srv.AddPrompt(
                &mcp.Prompt{
                        Name:        "compare_sources",
                        Description: "Compare coverage and perspectives across different feed sources",
                        Arguments: []*mcp.PromptArgument{
                                {
                                        Name:        "topic",
                                        Description: "Topic or keyword to compare across sources",
                                        Required:    true,
                                },
                                {
                                        Name:        "feed_ids",
                                        Description: "Specific feed IDs to compare (optional - defaults to all feeds)",
                                        Required:    false,
                                },
                        },
                },
                s.handleCompareSources,
        )

        srv.AddPrompt(
                &mcp.Prompt{
                        Name:        "generate_feed_report",
                        Description: "Generate detailed reports on feed performance, content quality, and engagement metrics",
                        Arguments: []*mcp.PromptArgument{
                                {
                                        Name:        "report_type",
                                        Description: "Type of report: 'performance', 'content', 'engagement', or 'comprehensive'",
                                        Required:    false,
                                },
                                {
                                        Name:        "timeframe",
                                        Description: "Time period for the report (e.g., '7d', '30d', '90d')",
                                        Required:    false,
                                },
                        },
                },
                s.handleGenerateFeedReport,
        )
}

// mergeFeeds implements the feed merging logic
func (s *Server) mergeFeeds(ctx context.Context, args MergeFeedsParams) (*MergedFeedResult, error) {
        var allItems []*gofeed.Item
        var feedTitles []string

        // Default values
        if args.SortBy == "" {
                args.SortBy = "date"
        }

        // Fetch all specified feeds
        for _, feedID := range args.FeedIDs {
                feedResult, err := s.feedAndItemsGetter.GetFeedAndItems(ctx, feedID)
                if err != nil {
                        // Continue with other feeds if one fails
                        continue
                }

                if feedResult.Feed != nil {
                        feedTitles = append(feedTitles, feedResult.Feed.Title)
                        allItems = append(allItems, feedResult.Items...)
                }
        }

        // Deduplicate if requested
        if args.Deduplicate {
                allItems = deduplicateItems(allItems)
        }

        // Sort items based on sortBy parameter
        switch args.SortBy {
        case "title":
                sortItemsByTitle(allItems)
        case "source":
                sortItemsBySource(allItems)
        default: // "date"
                sortItemsByDate(allItems)
        }

        // Limit items if maxItems is specified
        if args.MaxItems > 0 && len(allItems) > args.MaxItems {
                allItems = allItems[:args.MaxItems]
        }

        // Create merged feed title
        title := args.Title
        if title == "" {
                title = fmt.Sprintf("Merged Feed (%d sources)", len(args.FeedIDs))
        }

        // Create merged feed result
        mergedFeed := &MergedFeedResult{
                ID:          fmt.Sprintf("merged-%d", time.Now().Unix()),
                Title:       title,
                Description: fmt.Sprintf("Merged feed containing %d items from %d sources", len(allItems), len(feedTitles)),
                Items:       allItems,
                SourceFeeds: feedTitles,
                TotalItems:  len(allItems),
                CreatedAt:   time.Now(),
        }

        return mergedFeed, nil
}

// exportFeedData implements the feed export logic
func (s *Server) exportFeedData(ctx context.Context, args *ExportFeedDataParams) (string, error) {
        // Get feeds to export
        feedResults, err := s.getFeedsForExport(ctx, args.FeedIDs)
        if err != nil {
                return "", err
        }

        // Apply filters
        feedResults = s.applyExportFilters(feedResults, args)

        // Export in requested format
        return s.exportInFormat(feedResults, args)
}

// getFeedsForExport retrieves the feeds that need to be exported
func (s *Server) getFeedsForExport(ctx context.Context, feedIDs []string) ([]*FeedAndItemsResult, error) {
        if len(feedIDs) == 0 {
                return s.getAllFeedsForExport(ctx)
        }

        return s.getSpecificFeedsForExport(ctx, feedIDs)
}

// getAllFeedsForExport gets all feeds for export
func (s *Server) getAllFeedsForExport(ctx context.Context) ([]*FeedAndItemsResult, error) {
        allFeeds, err := s.allFeedsGetter.GetAllFeeds(ctx)
        if err != nil {
                return nil, err
        }

        feedResults := make([]*FeedAndItemsResult, 0, len(allFeeds))
        for _, feed := range allFeeds {
                feedResult, err := s.feedAndItemsGetter.GetFeedAndItems(ctx, feed.ID)
                if err != nil {
                        continue
                }
                feedResults = append(feedResults, feedResult)
        }
        return feedResults, nil
}

// getSpecificFeedsForExport gets specific feeds for export
func (s *Server) getSpecificFeedsForExport(ctx context.Context, feedIDs []string) ([]*FeedAndItemsResult, error) {
        feedResults := make([]*FeedAndItemsResult, 0, len(feedIDs))
        for _, feedID := range feedIDs {
                feedResult, err := s.feedAndItemsGetter.GetFeedAndItems(ctx, feedID)
                if err != nil {
                        continue
                }
                feedResults = append(feedResults, feedResult)
        }
        return feedResults, nil
}

// applyExportFilters applies date and item limit filters
func (s *Server) applyExportFilters(feedResults []*FeedAndItemsResult, args *ExportFeedDataParams) []*FeedAndItemsResult {
        // Apply date filters if specified
        if args.Since != "" || args.Until != "" {
                feedResults = filterFeedResultsByDate(feedResults, args.Since, args.Until)
        }

        // Apply maxItems limit per feed
        if args.MaxItems > 0 {
                for _, feedResult := range feedResults {
                        if len(feedResult.Items) > args.MaxItems {
                                feedResult.Items = feedResult.Items[:args.MaxItems]
                        }
                }
        }

        return feedResults
}

// exportInFormat exports the feed results in the requested format
func (s *Server) exportInFormat(feedResults []*FeedAndItemsResult, args *ExportFeedDataParams) (string, error) {
        switch args.Format {
        case "json":
                return exportAsJSON(feedResults, args.IncludeAll)
        case "csv":
                return exportAsCSV(feedResults)
        case "opml":
                return exportAsOPML(feedResults)
        case "rss":
                return exportAsRSS(feedResults)
        case "atom":
                return exportAsAtom(feedResults)
        default:
                return "", model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("unsupported export format: %s", args.Format)).
                        WithOperation("export_feed_data").
                        WithComponent("mcp_server")
        }
}

// Helper functions for item processing

// processItemForOutput processes a feed item based on content inclusion and length limits
func processItemForOutput(item *gofeed.Item, includeContent bool, maxContentLength int) *gofeed.Item {
        if item == nil {
                return nil
        }

        // Create a copy to avoid modifying the original
        processedItem := *item

        // Strip content fields if not requested
        if !includeContent {
                processedItem.Content = ""
                processedItem.Description = ""
        } else if maxContentLength > 0 {
                // Truncate content if it exceeds max length
                if len(processedItem.Content) > maxContentLength {
                        truncateLen := maxContentLength
                        if truncateLen > len(processedItem.Content) {
                                truncateLen = len(processedItem.Content)
                        }
                        processedItem.Content = processedItem.Content[:truncateLen] + TruncationMarker
                }
                if len(processedItem.Description) > maxContentLength {
                        truncateLen := maxContentLength
                        if truncateLen > len(processedItem.Description) {
                                truncateLen = len(processedItem.Description)
                        }
                        processedItem.Description = processedItem.Description[:truncateLen] + TruncationMarker
                }
        }

        return &processedItem
}

// guessMIMETypeFromURL guesses MIME type based on file extension in URL
func guessMIMETypeFromURL(urlStr string) string {
        // Extract extension from URL
        ext := ""
        if idx := strings.LastIndex(urlStr, "."); idx != -1 {
                // Get everything after the last dot, but before any query parameters or fragments
                extPart := urlStr[idx+1:]
                // Check for query parameters
                if qIdx := strings.Index(extPart, "?"); qIdx != -1 {
                        ext = extPart[:qIdx]
                } else if fIdx := strings.Index(extPart, "#"); fIdx != -1 {
                        // Check for fragments
                        ext = extPart[:fIdx]
                } else {
                        ext = extPart
                }
        }

        // Map common image extensions to MIME types
        switch strings.ToLower(ext) {
        case "jpg", "jpeg":
                return mimeTypeJPEG
        case "png":
                return mimeTypePNG
        case "gif":
                return mimeTypeGIF
        case "webp":
                return mimeTypeWebP
        case "svg":
                return mimeTypeSVG
        case "bmp":
                return mimeTypeBMP
        case "ico":
                return mimeTypeICO
        default:
                return "" // Return empty string for unknown extensions (not an image)
        }
}

// extractImageLinks extracts image ResourceLinks from a feed item
func extractImageLinks(item *gofeed.Item) []*mcp.ResourceLink {
        var links []*mcp.ResourceLink

        // Extract from Item.Image (featured image)
        if item.Image != nil && item.Image.URL != "" {
                mimeType := guessMIMETypeFromURL(item.Image.URL)
                if mimeType != "" { // Only add if we can determine it's an image
                        link := &mcp.ResourceLink{
                                URI:      item.Image.URL,
                                MIMEType: mimeType,
                        }
                        if item.Image.Title != "" {
                                link.Title = item.Image.Title
                        }
                        links = append(links, link)
                }
        }

        // Extract from Item.Enclosures (filter for images only)
        for _, enc := range item.Enclosures {
                if enc.URL == "" {
                        continue
                }
                // Only include if Type starts with "image/"
                if strings.HasPrefix(enc.Type, "image/") {
                        link := &mcp.ResourceLink{
                                URI:      enc.URL,
                                MIMEType: enc.Type,
                        }
                        links = append(links, link)
                } else if enc.Type == "" {
                        // If no Type is provided, guess based on URL
                        mimeType := guessMIMETypeFromURL(enc.URL)
                        if mimeType != "" && strings.HasPrefix(mimeType, "image/") {
                                link := &mcp.ResourceLink{
                                        URI:      enc.URL,
                                        MIMEType: mimeType,
                                }
                                links = append(links, link)
                        }
                }
        }

        return links
}

// initializeImageCache creates and configures the image cache, circuit breakers, and HTTP client
func (s *Server) initializeImageCache() error {
        // Create ristretto cache
        ristrettoCache, err := ristretto.NewCache[string, []byte](&ristretto.Config[string, []byte]{
                NumCounters: 1000,
                MaxCost:     100,
                BufferItems: 64,
        })
        if err != nil {
                return fmt.Errorf("failed to create image cache: %w", err)
        }

        // Wrap ristretto cache with gocache
        imageStore := ristrettostore.NewRistretto(ristrettoCache)
        s.imageCache = gocache.New[[]byte](imageStore)

        // Initialize circuit breakers map
        s.imageCircuitBreakers = make(map[string]*gobreaker.CircuitBreaker)

        // Create HTTP client with timeout
        s.httpClient = &http.Client{
                Timeout: ImageFetchTimeout,
        }

        return nil
}

// getOrCreateImageCircuitBreaker gets or creates a circuit breaker for an image host
func (s *Server) getOrCreateImageCircuitBreaker(host string) *gobreaker.CircuitBreaker {
        s.imageCBMutex.RLock()
        cb, exists := s.imageCircuitBreakers[host]
        s.imageCBMutex.RUnlock()

        if exists {
                return cb
        }

        s.imageCBMutex.Lock()
        defer s.imageCBMutex.Unlock()

        // Check again in case another goroutine created it
        if cb, exists := s.imageCircuitBreakers[host]; exists {
                return cb
        }

        // Create new circuit breaker for this host
        cb = gobreaker.NewCircuitBreaker(gobreaker.Settings{
                Name:        fmt.Sprintf("image-%s", host),
                MaxRequests: 3,
                Timeout:     30 * time.Second,
                ReadyToTrip: func(counts gobreaker.Counts) bool {
                        return counts.ConsecutiveFailures >= 3
                },
        })

        s.imageCircuitBreakers[host] = cb
        return cb
}

// hashImageURL creates a cache key for an image URL using FNV-1a hash
func hashImageURL(imageURL string) string {
        h := fnv.New64a()
        h.Write([]byte(imageURL)) //nolint:gosec // hash.Hash.Write never returns an error
        return fmt.Sprintf("image:%x", h.Sum64())
}

// fetchAndEmbedImage fetches an image from URL and returns it as base64-encoded ImageContent
func (s *Server) fetchAndEmbedImage(ctx context.Context, imageURL, mimeType string, itemIndex int) (*mcp.ImageContent, error) {
        // Check cache first
        cacheKey := hashImageURL(imageURL)
        if cachedData, err := s.imageCache.Get(ctx, cacheKey); err == nil {
                return &mcp.ImageContent{
                        Data:     cachedData,
                        MIMEType: mimeType,
                        Meta:     mcp.Meta{"itemIndex": itemIndex},
                }, nil
        }

        // Parse URL to get host for circuit breaker
        parsedURL, err := url.Parse(imageURL)
        if err != nil {
                return nil, fmt.Errorf("invalid image URL: %w", err)
        }

        // Get circuit breaker for this host
        cb := s.getOrCreateImageCircuitBreaker(parsedURL.Host)

        // Execute fetch with circuit breaker
        result, err := cb.Execute(func() (interface{}, error) {
                // Create request with timeout context
                req, err := http.NewRequestWithContext(ctx, "GET", imageURL, http.NoBody)
                if err != nil {
                        return nil, fmt.Errorf("failed to create request: %w", err)
                }

                // Fetch image
                resp, err := s.httpClient.Do(req)
                if err != nil {
                        return nil, fmt.Errorf("failed to fetch image: %w", err)
                }
                defer func() { _ = resp.Body.Close() }()

                if resp.StatusCode != http.StatusOK {
                        return nil, fmt.Errorf("image fetch returned status %d", resp.StatusCode)
                }

                // Read with size limit
                limitedReader := io.LimitReader(resp.Body, MaxImageSize+1)
                data, err := io.ReadAll(limitedReader)
                if err != nil {
                        return nil, fmt.Errorf("failed to read image data: %w", err)
                }

                // Check size limit
                if len(data) > MaxImageSize {
                        return nil, fmt.Errorf("image exceeds 1MB limit (%d bytes)", len(data))
                }

                // Base64 encode
                encoded := base64.StdEncoding.EncodeToString(data)
                encodedBytes := []byte(encoded)

                // Cache the encoded data
                _ = s.imageCache.Set(ctx, cacheKey, encodedBytes, store.WithExpiration(ImageCacheTTL))

                return encodedBytes, nil
        })
        if err != nil {
                return nil, err
        }

        encodedData := result.([]byte)

        return &mcp.ImageContent{
                Data:     encodedData,
                MIMEType: mimeType,
                Meta:     mcp.Meta{"itemIndex": itemIndex},
        }, nil
}

// Helper functions for feed merging and export

// deduplicateItems removes duplicate items based on title and link
func deduplicateItems(items []*gofeed.Item) []*gofeed.Item {
        seen := make(map[string]bool)
        var unique []*gofeed.Item

        for _, item := range items {
                // Create a unique key based on title and link
                key := fmt.Sprintf("%s|%s", item.Title, item.Link)
                if !seen[key] {
                        seen[key] = true
                        unique = append(unique, item)
                }
        }

        return unique
}

// sortItemsByDate sorts items by published date (newest first)
func sortItemsByDate(items []*gofeed.Item) {
        sort.Slice(items, func(i, j int) bool {
                // Handle nil PublishedParsed dates
                if items[i].PublishedParsed == nil || items[j].PublishedParsed == nil {
                        return items[i].PublishedParsed != nil
                }
                // Sort newest first (i > j means i is newer)
                return items[i].PublishedParsed.After(*items[j].PublishedParsed)
        })
}

// sortItemsByTitle sorts items alphabetically by title
func sortItemsByTitle(items []*gofeed.Item) {
        sort.Slice(items, func(i, j int) bool {
                return items[i].Title < items[j].Title
        })
}

// sortItemsBySource sorts items by source feed title
func sortItemsBySource(items []*gofeed.Item) {
        sort.Slice(items, func(i, j int) bool {
                return getItemSource(items[i]) < getItemSource(items[j])
        })
}

// getItemSource extracts source information from a feed item
func getItemSource(item *gofeed.Item) string {
        if item.Custom != nil && item.Custom["source"] != "" {
                return item.Custom["source"]
        }
        return ""
}

// filterFeedResultsByDate filters feed result items by publication date range
func filterFeedResultsByDate(feedResults []*FeedAndItemsResult, since, until string) []*FeedAndItemsResult {
        sinceTime, untilTime, err := parseTimeRange(since, until)
        if err != nil {
                return feedResults // Skip filtering if parsing fails
        }

        for _, feedResult := range feedResults {
                feedResult.Items = filterItemsByDateRange(feedResult.Items, sinceTime, untilTime)
        }

        return feedResults
}

// parseTimeRange parses since and until time strings
func parseTimeRange(since, until string) (sinceTime, untilTime time.Time, err error) {
        if since != "" {
                sinceTime, err = time.Parse(time.RFC3339, since)
                if err != nil {
                        return sinceTime, untilTime, err
                }
        }

        if until != "" {
                untilTime, err = time.Parse(time.RFC3339, until)
                if err != nil {
                        return sinceTime, untilTime, err
                }
        }

        return sinceTime, untilTime, err
}

// filterItemsByDateRange filters items within the given date range
func filterItemsByDateRange(items []*gofeed.Item, sinceTime, untilTime time.Time) []*gofeed.Item {
        var filteredItems []*gofeed.Item

        for _, item := range items {
                if itemInDateRange(item, sinceTime, untilTime) {
                        filteredItems = append(filteredItems, item)
                }
        }

        return filteredItems
}

// itemInDateRange checks if an item falls within the date range
func itemInDateRange(item *gofeed.Item, sinceTime, untilTime time.Time) bool {
        if item.PublishedParsed == nil {
                return true
        }

        if !sinceTime.IsZero() && item.PublishedParsed.Before(sinceTime) {
                return false
        }

        if !untilTime.IsZero() && item.PublishedParsed.After(untilTime) {
                return false
        }

        return true
}

// Export format implementations

// exportAsJSON exports feed results as JSON
func exportAsJSON(feedResults []*FeedAndItemsResult, includeAll bool) (string, error) {
        data := struct {
                FeedResults []*FeedAndItemsResult `json:"feed_results"`
                ExportedAt  time.Time             `json:"exported_at"`
                Count       int                   `json:"count"`
        }{
                FeedResults: feedResults,
                ExportedAt:  time.Now(),
                Count:       len(feedResults),
        }

        jsonData, err := json.MarshalIndent(data, "", "  ")
        if err != nil {
                return "", err
        }

        return string(jsonData), nil
}

// exportAsCSV exports feed results as CSV
func exportAsCSV(feedResults []*FeedAndItemsResult) (string, error) {
        var result string

        // CSV header
        result += "Feed Title,Feed URL,Item Title,Item Link,Published Date,Description\n"

        // CSV rows
        for _, feedResult := range feedResults {
                for _, item := range feedResult.Items {
                        // Escape commas and quotes in CSV fields
                        feedTitle := escapeCSVField(feedResult.Title)
                        feedURL := escapeCSVField(feedResult.PublicURL)
                        itemTitle := escapeCSVField(item.Title)
                        itemLink := escapeCSVField(item.Link)
                        publishedDate := ""
                        if item.PublishedParsed != nil {
                                publishedDate = item.PublishedParsed.Format(time.RFC3339)
                        }
                        description := escapeCSVField(item.Description)

                        result += fmt.Sprintf("%s,%s,%s,%s,%s,%s\n",
                                feedTitle, feedURL, itemTitle, itemLink, publishedDate, description)
                }
        }

        return result, nil
}

// exportAsOPML exports feed results as OPML
func exportAsOPML(feedResults []*FeedAndItemsResult) (string, error) {
        result := `<?xml version="1.0" encoding="UTF-8"?>
<opml version="1.0">
<head>
<title>Feed Export</title>
<dateCreated>` + time.Now().Format(time.RFC1123Z) + `</dateCreated>
</head>
<body>
`

        for _, feedResult := range feedResults {
                result += fmt.Sprintf(`<outline text=%q title=%q type="rss" xmlUrl=%q htmlUrl=%q/>`,
                        escapeXML(feedResult.Title), escapeXML(feedResult.Title), escapeXML(feedResult.PublicURL), escapeXML(feedResult.PublicURL))
                result += "\n"
        }

        result += `</body>
</opml>`

        return result, nil
}

// exportAsRSS exports feed results as RSS 2.0
func exportAsRSS(feedResults []*FeedAndItemsResult) (string, error) {
        result := `<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
<channel>
<title>Combined Feed Export</title>
<description>Combined feed containing items from multiple sources</description>
<lastBuildDate>` + time.Now().Format(time.RFC1123Z) + `</lastBuildDate>
`

        for _, feedResult := range feedResults {
                for _, item := range feedResult.Items {
                        pubDate := ""
                        if item.PublishedParsed != nil {
                                pubDate = item.PublishedParsed.Format(time.RFC1123Z)
                        }
                        result += `<item>
<title>` + escapeXML(item.Title) + `</title>
<link>` + escapeXML(item.Link) + `</link>
<description>` + escapeXML(item.Description) + `</description>
<pubDate>` + pubDate + `</pubDate>
<guid>` + escapeXML(item.Link) + `</guid>
</item>
`
                }
        }

        result += `</channel>
</rss>`

        return result, nil
}

// exportAsAtom exports feed results as Atom 1.0
func exportAsAtom(feedResults []*FeedAndItemsResult) (string, error) {
        result := `<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>Combined Feed Export</title>
<subtitle>Combined feed containing items from multiple sources</subtitle>
<updated>` + time.Now().Format(time.RFC3339) + `</updated>
<id>urn:feed-mcp:export:` + fmt.Sprintf("%d", time.Now().Unix()) + `</id>
`

        for _, feedResult := range feedResults {
                for _, item := range feedResult.Items {
                        updatedDate := time.Now().Format(time.RFC3339)
                        if item.PublishedParsed != nil {
                                updatedDate = item.PublishedParsed.Format(time.RFC3339)
                        }
                        result += `<entry>
<title>` + escapeXML(item.Title) + `</title>
<link href="` + escapeXML(item.Link) + `"/>
<summary>` + escapeXML(item.Description) + `</summary>
<updated>` + updatedDate + `</updated>
<id>` + escapeXML(item.Link) + `</id>
</entry>
`
                }
        }

        result += `</feed>`

        return result, nil
}

// Utility functions for escaping

// escapeCSVField escapes a field for CSV format
func escapeCSVField(field string) string {
        // If field contains comma, quote, or newline, wrap in quotes and escape quotes
        if containsAny(field, ",\"\\n\\r") {
                field = `"` + replaceAll(field, `"`, `""`) + `"`
        }
        return field
}

// escapeXML escapes a string for XML format
func escapeXML(s string) string {
        s = replaceAll(s, "&", "&amp;")
        s = replaceAll(s, "<", "&lt;")
        s = replaceAll(s, ">", "&gt;")
        s = replaceAll(s, `"`, "&quot;")
        s = replaceAll(s, "'", "&#39;")
        return s
}

// containsAny checks if string contains any of the specified characters
func containsAny(s, chars string) bool {
        for _, char := range chars {
                for _, sChar := range s {
                        if char == sChar {
                                return true
                        }
                }
        }
        return false
}

// replaceAll replaces all occurrences of old with replacement in string
func replaceAll(s, old, replacement string) string {
        result := ""
        for i := 0; i < len(s); {
                if i+len(old) <= len(s) && s[i:i+len(old)] == old {
                        result += replacement
                        i += len(old)
                } else {
                        result += string(s[i])
                        i++
                }
        }
        return result
}

// Package model provides debugging and logging utilities for enhanced error context.
package model

import (
        "encoding/json"
        "fmt"
        "log"
        "os"
        "strings"
        "time"
)

// LogLevel represents different logging levels
type LogLevel int

const (
        // LogLevelError represents the error logging level
        LogLevelError LogLevel = iota
        // LogLevelWarn represents the warning logging level
        LogLevelWarn
        // LogLevelInfo represents the info logging level
        LogLevelInfo
        // LogLevelDebug represents the debug logging level
        LogLevelDebug
)

// String returns the string representation of a log level
func (l LogLevel) String() string {
        switch l {
        case LogLevelError:
                return "ERROR"
        case LogLevelWarn:
                return "WARN"
        case LogLevelInfo:
                return "INFO"
        case LogLevelDebug:
                return "DEBUG"
        default:
                return "UNKNOWN"
        }
}

// DebugLogger provides enhanced logging capabilities for debugging
type DebugLogger struct {
        level    LogLevel
        logger   *log.Logger
        enabled  bool
        jsonMode bool
}

// defaultLogger is the global logger instance
var defaultLogger *DebugLogger

func init() {
        defaultLogger = NewDebugLogger()
}

// NewDebugLogger creates a new debug logger with configuration from environment variables
func NewDebugLogger() *DebugLogger {
        logger := &DebugLogger{
                level:    LogLevelInfo,
                logger:   log.New(os.Stderr, "", 0), // No default prefix, we'll add our own
                enabled:  false,
                jsonMode: false,
        }

        // Configure from environment variables
        if debugMode := os.Getenv("FEED_MCP_DEBUG"); debugMode != "" {
                logger.enabled = strings.EqualFold(debugMode, "true") || debugMode == "1"
        }

        if logLevel := os.Getenv("FEED_MCP_LOG_LEVEL"); logLevel != "" {
                if level, err := parseLogLevel(logLevel); err != nil {
                        // Log warning about invalid level but continue with default
                        log.Printf("WARN: %v", err)
                        logger.SetLevel(LogLevelInfo)
                } else {
                        logger.SetLevel(level)
                }
        }

        if jsonMode := os.Getenv("FEED_MCP_JSON_LOGS"); jsonMode != "" {
                logger.jsonMode = strings.EqualFold(jsonMode, "true") || jsonMode == "1"
        }

        return logger
}

// SetLevel sets the logging level
func (d *DebugLogger) SetLevel(level LogLevel) {
        d.level = level
}

// SetEnabled enables or disables debug logging
func (d *DebugLogger) SetEnabled(enabled bool) {
        d.enabled = enabled
}

// SetJSONMode enables or disables JSON formatted logs
func (d *DebugLogger) SetJSONMode(jsonMode bool) {
        d.jsonMode = jsonMode
}

// IsEnabled returns whether debug logging is enabled
func (d *DebugLogger) IsEnabled() bool {
        return d.enabled
}

// ShouldLog returns whether a message at the given level should be logged
func (d *DebugLogger) ShouldLog(level LogLevel) bool {
        return d.enabled && level <= d.level
}

// LogMessage represents a structured log message
type LogMessage struct {
        Timestamp time.Time              `json:"timestamp"`
        Level     string                 `json:"level"`
        Message   string                 `json:"message"`
        Component string                 `json:"component,omitempty"`
        Operation string                 `json:"operation,omitempty"`
        URL       string                 `json:"url,omitempty"`
        Error     string                 `json:"error,omitempty"`
        Duration  string                 `json:"duration,omitempty"`
        Extra     map[string]interface{} `json:"extra,omitempty"`
}

// log writes a log message at the specified level
func (d *DebugLogger) log(level LogLevel, message, component, operation, url string, err error, extra map[string]interface{}) {
        if !d.ShouldLog(level) {
                return
        }

        logMsg := LogMessage{
                Timestamp: time.Now().UTC(),
                Level:     level.String(),
                Message:   message,
                Component: component,
                Operation: operation,
                URL:       url,
                Extra:     extra,
        }

        if err != nil {
                logMsg.Error = err.Error()
        }

        if d.jsonMode {
                d.logJSON(&logMsg)
        } else {
                d.logText(&logMsg)
        }
}

// logJSON outputs the log message in JSON format
func (d *DebugLogger) logJSON(msg *LogMessage) {
        data, err := json.Marshal(msg)
        if err != nil {
                // Fallback to simple text logging if JSON marshaling fails
                d.logger.Printf("ERROR: Failed to marshal log message to JSON: %v", err)
                return
        }
        d.logger.Println(string(data))
}

// logText outputs the log message in human-readable text format
func (d *DebugLogger) logText(msg *LogMessage) {
        // Build the log message parts
        parts := []string{
                msg.Timestamp.Format("2006-01-02T15:04:05.000Z"),
                fmt.Sprintf("[%s]", msg.Level),
                msg.Message,
        }

        if msg.Component != "" {
                parts = append(parts, fmt.Sprintf("component=%s", msg.Component))
        }

        if msg.Operation != "" {
                parts = append(parts, fmt.Sprintf("operation=%s", msg.Operation))
        }

        if msg.URL != "" {
                parts = append(parts, fmt.Sprintf("url=%s", msg.URL))
        }

        if msg.Error != "" {
                parts = append(parts, fmt.Sprintf("error=%q", msg.Error))
        }

        if msg.Duration != "" {
                parts = append(parts, fmt.Sprintf("duration=%s", msg.Duration))
        }

        // Add extra fields
        for key, value := range msg.Extra {
                parts = append(parts, fmt.Sprintf("%s=%v", key, value))
        }

        d.logger.Println(strings.Join(parts, " "))
}

// Debug logs a debug-level message
func (d *DebugLogger) Debug(message string) {
        d.log(LogLevelDebug, message, "", "", "", nil, nil)
}

// DebugWithContext logs a debug-level message with context
func (d *DebugLogger) DebugWithContext(message, component, operation, url string, extra map[string]interface{}) {
        d.log(LogLevelDebug, message, component, operation, url, nil, extra)
}

// Info logs an info-level message
func (d *DebugLogger) Info(message string) {
        d.log(LogLevelInfo, message, "", "", "", nil, nil)
}

// InfoWithContext logs an info-level message with context
func (d *DebugLogger) InfoWithContext(message, component, operation, url string, extra map[string]interface{}) {
        d.log(LogLevelInfo, message, component, operation, url, nil, extra)
}

// Warn logs a warning-level message
func (d *DebugLogger) Warn(message string) {
        d.log(LogLevelWarn, message, "", "", "", nil, nil)
}

// WarnWithContext logs a warning-level message with context
func (d *DebugLogger) WarnWithContext(message, component, operation, url string, err error, extra map[string]interface{}) {
        d.log(LogLevelWarn, message, component, operation, url, err, extra)
}

// Error logs an error-level message
func (d *DebugLogger) Error(message string, err error) {
        d.log(LogLevelError, message, "", "", "", err, nil)
}

// ErrorWithContext logs an error-level message with context
func (d *DebugLogger) ErrorWithContext(message, component, operation, url string, err error, extra map[string]interface{}) {
        d.log(LogLevelError, message, component, operation, url, err, extra)
}

// LogFeedError logs a FeedError with full context
func (d *DebugLogger) LogFeedError(feedErr *FeedError) {
        if feedErr == nil {
                return
        }

        extra := make(map[string]interface{})
        extra["error_id"] = feedErr.ID
        extra["error_type"] = feedErr.ErrorType
        extra["suggestion"] = feedErr.Suggestion

        if feedErr.HTTPStatus != 0 {
                extra["http_status"] = feedErr.HTTPStatus
        }

        if len(feedErr.HTTPHeaders) > 0 {
                extra["http_headers"] = feedErr.HTTPHeaders
        }

        if feedErr.Attempt != 0 {
                extra["retry_attempt"] = feedErr.Attempt
                extra["max_attempts"] = feedErr.MaxAttempts
        }

        if feedErr.ParseContext != nil {
                extra["parse_line"] = feedErr.ParseContext.LineNumber
                extra["feed_format"] = feedErr.ParseContext.FeedFormat
        }

        d.log(LogLevelError, feedErr.Message, feedErr.Component, feedErr.Operation, feedErr.URL, feedErr.Cause, extra)
}

// Package-level convenience functions using the default logger

// SetDebugMode enables or disables debug mode for the default logger
func SetDebugMode(enabled bool) {
        defaultLogger.SetEnabled(enabled)
}

// SetLogLevel sets the log level for the default logger
func SetLogLevel(level LogLevel) {
        defaultLogger.SetLevel(level)
}

// IsDebugEnabled returns whether debug logging is enabled
func IsDebugEnabled() bool {
        return defaultLogger.IsEnabled()
}

// DebugLog logs a debug message if debug mode is enabled
func DebugLog(message string) {
        defaultLogger.Debug(message)
}

// DebugLogWithContext logs a debug message with context
func DebugLogWithContext(message, component, operation, url string, extra map[string]interface{}) {
        defaultLogger.DebugWithContext(message, component, operation, url, extra)
}

// InfoLog logs an info message
func InfoLog(message string) {
        defaultLogger.Info(message)
}

// InfoLogWithContext logs an info message with context
func InfoLogWithContext(message, component, operation, url string, extra map[string]interface{}) {
        defaultLogger.InfoWithContext(message, component, operation, url, extra)
}

// WarnLog logs a warning message
func WarnLog(message string, err error) {
        defaultLogger.WarnWithContext(message, "", "", "", err, nil)
}

// ErrorLog logs an error message
func ErrorLog(message string, err error) {
        defaultLogger.Error(message, err)
}

// LogFeedError logs a FeedError using the default logger
func LogFeedError(feedErr *FeedError) {
        defaultLogger.LogFeedError(feedErr)
}

// Helper function to parse log level from string
func parseLogLevel(level string) (LogLevel, error) {
        switch strings.ToUpper(level) {
        case "ERROR":
                return LogLevelError, nil
        case "WARN", "WARNING":
                return LogLevelWarn, nil
        case "INFO":
                return LogLevelInfo, nil
        case "DEBUG":
                return LogLevelDebug, nil
        default:
                return LogLevelInfo, fmt.Errorf("invalid log level: %s, defaulting to INFO", level)
        }
}

// Package model provides helper functions for creating structured errors.
package model

import (
        "context"
        "errors"
        "fmt"
        "net"
        "net/http"
        "strconv"
        "strings"
        "syscall"
        "time"
)

// CreateNetworkError creates a FeedError for network-related issues
func CreateNetworkError(err error, feedURL string) *FeedError {
        errorType := ErrorTypeNetwork
        message := "Network error occurred"

        // Categorize the specific network error
        if err != nil {
                // Check for timeout errors
                if isTimeoutError(err) {
                        errorType = ErrorTypeTimeout
                        message = "Request timed out"
                } else if isDNSError(err) {
                        errorType = ErrorTypeDNSResolution
                        message = "DNS resolution failed"
                } else if isConnectionError(err) {
                        errorType = ErrorTypeConnectionFailed
                        message = "Connection failed"
                }
        }

        return NewFeedErrorWithCause(errorType, message, err).
                WithURL(feedURL).
                WithOperation("fetch_feed").
                WithComponent("http_client")
}

// CreateHTTPError creates a FeedError for HTTP response errors
func CreateHTTPError(resp *http.Response, feedURL string) *FeedError {
        var errorType ErrorType
        var message string

        status := resp.StatusCode

        switch {
        case status >= 400 && status < 500:
                errorType = ErrorTypeHTTPClientError
                message = fmt.Sprintf("Client error: %s", resp.Status)
        case status >= 500:
                errorType = ErrorTypeHTTPServerError
                message = fmt.Sprintf("Server error: %s", resp.Status)
        case status >= 300 && status < 400:
                errorType = ErrorTypeHTTPRedirect
                message = fmt.Sprintf("Redirect error: %s", resp.Status)
        default:
                errorType = ErrorTypeHTTP
                message = fmt.Sprintf("HTTP error: %s", resp.Status)
        }

        return NewFeedError(errorType, message).
                WithURL(feedURL).
                WithOperation("fetch_feed").
                WithComponent("http_client").
                WithHTTP(status, resp.Header)
}

// CreateParsingError creates a FeedError for feed parsing issues
func CreateParsingError(err error, feedURL, content string) *FeedError {
        errorType := ErrorTypeParsing
        message := "Failed to parse feed"

        // Categorize parsing errors based on content
        if err != nil {
                errStr := strings.ToLower(err.Error())

                if strings.Contains(errStr, "xml") {
                        errorType = ErrorTypeMalformedXML
                        message = "Feed contains malformed XML"
                } else if strings.Contains(errStr, "json") {
                        errorType = ErrorTypeMalformedJSON
                        message = "Feed contains malformed JSON"
                } else if strings.Contains(errStr, "empty") || strings.Contains(errStr, "no content") {
                        errorType = ErrorTypeEmptyFeed
                        message = "Feed is empty or contains no content"
                }
        }

        fe := NewFeedErrorWithCause(errorType, message, err).
                WithURL(feedURL).
                WithOperation("parse_feed").
                WithComponent("feed_parser")

        // Try to extract parsing context from error
        if parseCtx := extractParseContext(err, content); parseCtx != nil {
                fe = fe.WithParseContext(parseCtx)
        }

        return fe
}

// CreateValidationError creates a FeedError for URL validation issues
func CreateValidationError(err error, feedURL string) *FeedError {
        errorType := ErrorTypeValidation
        message := "URL validation failed"

        // Map existing validation errors to our error types
        if err != nil {
                switch {
                case errors.Is(err, ErrInvalidURL):
                        errorType = ErrorTypeInvalidURL
                        message = "Invalid URL format"
                case errors.Is(err, ErrUnsupportedScheme):
                        errorType = ErrorTypeUnsupportedScheme
                        message = "Unsupported URL scheme"
                case errors.Is(err, ErrPrivateIPBlocked):
                        errorType = ErrorTypePrivateIP
                        message = "Private IP address blocked"
                case errors.Is(err, ErrMissingHost):
                        errorType = ErrorTypeInvalidURL
                        message = "URL missing host"
                case errors.Is(err, ErrEmptyURL):
                        errorType = ErrorTypeInvalidURL
                        message = "URL cannot be empty"
                }
        }

        return NewFeedErrorWithCause(errorType, message, err).
                WithURL(feedURL).
                WithOperation("validate_url").
                WithComponent("url_validator")
}

// CreateCircuitBreakerError creates a FeedError for circuit breaker events
func CreateCircuitBreakerError(feedURL, state string) *FeedError {
        message := fmt.Sprintf("Circuit breaker is %s", state)

        return NewFeedError(ErrorTypeCircuitBreaker, message).
                WithURL(feedURL).
                WithOperation("fetch_feed").
                WithComponent("circuit_breaker")
}

// CreateRetryError creates a FeedError when all retry attempts are exhausted
func CreateRetryError(lastErr error, feedURL string, attempt, maxAttempts int) *FeedError {
        message := fmt.Sprintf("All retry attempts exhausted (%d/%d)", attempt, maxAttempts)

        // Preserve the error type from the last error if it's a FeedError
        errorType := ErrorTypeNetwork
        feedErr := &FeedError{}
        if errors.As(lastErr, &feedErr) {
                errorType = feedErr.ErrorType
        }

        return NewFeedErrorWithCause(errorType, message, lastErr).
                WithURL(feedURL).
                WithOperation("retry_fetch").
                WithComponent("retry_manager").
                WithRetryContext(attempt, maxAttempts, 0)
}

// CreateRateLimitError creates a FeedError for rate limiting
func CreateRateLimitError(feedURL string, retryAfter time.Duration) *FeedError {
        message := "Request rate limit exceeded"

        return NewFeedError(ErrorTypeRateLimit, message).
                WithURL(feedURL).
                WithOperation("fetch_feed").
                WithComponent("rate_limiter").
                WithRetryContext(0, 0, retryAfter)
}

// Helper functions to categorize network errors

// isTimeoutError checks if the error is related to timeouts
func isTimeoutError(err error) bool {
        if err == nil {
                return false
        }

        // Check for context timeout
        if errors.Is(err, context.DeadlineExceeded) {
                return true
        }

        // Check for net.Error timeout
        var netErr net.Error
        if errors.As(err, &netErr) && netErr.Timeout() {
                return true
        }

        // Check error message for timeout indicators
        errStr := strings.ToLower(err.Error())
        timeoutKeywords := []string{"timeout", "deadline exceeded", "timed out"}
        for _, keyword := range timeoutKeywords {
                if strings.Contains(errStr, keyword) {
                        return true
                }
        }

        return false
}

// isDNSError checks if the error is related to DNS resolution
func isDNSError(err error) bool {
        if err == nil {
                return false
        }

        // Check for DNS error types
        var dnsErr *net.DNSError
        if errors.As(err, &dnsErr) {
                return true
        }

        // Check error message for DNS indicators
        errStr := strings.ToLower(err.Error())
        dnsKeywords := []string{
                "no such host", "dns", "name resolution", "hostname",
                "name or service not known", "nodename nor servname provided",
        }
        for _, keyword := range dnsKeywords {
                if strings.Contains(errStr, keyword) {
                        return true
                }
        }

        return false
}

// isConnectionError checks if the error is related to connection issues
func isConnectionError(err error) bool {
        if err == nil {
                return false
        }

        // Check for specific syscall errors using errors.Is for better cross-platform compatibility
        opErr := &net.OpError{}
        if errors.As(err, &opErr) {
                // Common connection errors
                if errors.Is(opErr.Err, syscall.ECONNREFUSED) ||
                        errors.Is(opErr.Err, syscall.ECONNRESET) ||
                        errors.Is(opErr.Err, syscall.ECONNABORTED) ||
                        errors.Is(opErr.Err, syscall.EHOSTUNREACH) ||
                        errors.Is(opErr.Err, syscall.ENETUNREACH) {
                        return true
                }
        }

        // Check error message for connection indicators
        errStr := strings.ToLower(err.Error())
        connKeywords := []string{
                "connection refused", "connection reset", "connection aborted",
                "host unreachable", "network unreachable", "no route to host",
        }
        for _, keyword := range connKeywords {
                if strings.Contains(errStr, keyword) {
                        return true
                }
        }

        return false
}

// extractParseContext attempts to extract parsing context from error messages
func extractParseContext(err error, content string) *ParseContext {
        if err == nil {
                return nil
        }

        ctx := &ParseContext{}

        // Extract line number from error message
        ctx.LineNumber = extractLineNumber(err.Error())

        // Determine feed format from content
        ctx.FeedFormat = determineFeedFormat(content)

        // Extract content snippet around error location
        ctx.ContentSnippet = extractContentSnippet(content, ctx.LineNumber)

        // Only return context if we found useful information
        if ctx.LineNumber > 0 || ctx.FeedFormat != "" || ctx.ContentSnippet != "" {
                return ctx
        }

        return nil
}

// extractLineNumber extracts line number from error message
func extractLineNumber(errStr string) int {
        if !strings.Contains(errStr, "line") {
                return 0
        }

        parts := strings.Split(errStr, " ")
        for i, part := range parts {
                if part == "line" && i+1 < len(parts) {
                        if lineNum, parseErr := strconv.Atoi(parts[i+1]); parseErr == nil {
                                return lineNum
                        }
                }
        }
        return 0
}

// determineFeedFormat determines feed format from content
func determineFeedFormat(content string) string {
        contentLower := strings.TrimSpace(strings.ToLower(content))
        if strings.HasPrefix(contentLower, "{") {
                return "JSON"
        }
        if strings.HasPrefix(contentLower, "<") {
                if strings.Contains(contentLower, "<rss") {
                        return "RSS"
                }
                if strings.Contains(contentLower, "<feed") {
                        return "Atom"
                }
                return "XML"
        }
        return ""
}

// extractContentSnippet extracts content snippet around error location
func extractContentSnippet(content string, lineNumber int) string {
        if lineNumber <= 0 || content == "" {
                return ""
        }

        lines := strings.Split(content, "\n")
        if lineNumber > len(lines) {
                return ""
        }

        // Get a few lines around the error for context
        start := max(0, lineNumber-3)
        end := min(len(lines), lineNumber+2)

        contextLines := lines[start:end]
        return strings.Join(contextLines, "\n")
}

// Resource-specific error helpers for MCP Resources

// CreateResourceError creates a FeedError for general resource issues
func CreateResourceError(err error, resourceURI, operation string) *FeedError {
        errorType := ErrorTypeResource
        message := "Resource operation failed"

        // Categorize based on the operation type
        if operation != "" {
                switch operation {
                case "read_resource":
                        message = "Failed to read resource"
                case "list_resources":
                        message = "Failed to list resources"
                case "subscribe":
                        errorType = ErrorTypeSubscription
                        message = "Failed to subscribe to resource"
                case "unsubscribe":
                        errorType = ErrorTypeSubscription
                        message = "Failed to unsubscribe from resource"
                }
        }

        return NewFeedErrorWithCause(errorType, message, err).
                WithURL(resourceURI).
                WithOperation(operation).
                WithComponent("resource_manager")
}

// CreateResourceNotFoundError creates a FeedError for resource not found
func CreateResourceNotFoundError(resourceURI, feedID string) *FeedError {
        message := "Resource not found"
        if feedID != "" {
                message = fmt.Sprintf("Feed not found: %s", feedID)
        }

        return NewFeedError(ErrorTypeResourceNotFound, message).
                WithURL(resourceURI).
                WithOperation("read_resource").
                WithComponent("resource_manager")
}

// CreateResourceUnavailableError creates a FeedError for temporarily unavailable resources
func CreateResourceUnavailableError(resourceURI, reason string) *FeedError {
        message := "Resource temporarily unavailable"
        if reason != "" {
                message = fmt.Sprintf("Resource unavailable: %s", reason)
        }

        return NewFeedError(ErrorTypeResourceUnavailable, message).
                WithURL(resourceURI).
                WithOperation("read_resource").
                WithComponent("resource_manager")
}

// CreateInvalidResourceURIError creates a FeedError for invalid resource URIs
func CreateInvalidResourceURIError(resourceURI, details string) *FeedError {
        message := "Invalid resource URI"
        if details != "" {
                message = fmt.Sprintf("Invalid resource URI: %s", details)
        }

        return NewFeedError(ErrorTypeInvalidResourceURI, message).
                WithURL(resourceURI).
                WithOperation("parse_resource_uri").
                WithComponent("resource_manager")
}

// CreateResourceContentError creates a FeedError for resource content generation issues
func CreateResourceContentError(err error, resourceURI, operation string) *FeedError {
        message := "Failed to generate resource content"

        return NewFeedErrorWithCause(ErrorTypeResourceContent, message, err).
                WithURL(resourceURI).
                WithOperation(operation).
                WithComponent("resource_manager")
}

// CreateSessionError creates a FeedError for session management issues
func CreateSessionError(err error, sessionID, operation string) *FeedError {
        errorType := ErrorTypeSession
        message := "Session operation failed"

        // Categorize session errors
        if err != nil {
                errStr := strings.ToLower(err.Error())
                if strings.Contains(errStr, "not found") || strings.Contains(errStr, "does not exist") {
                        errorType = ErrorTypeSessionNotFound
                        message = "Session not found"
                }
        }

        fe := NewFeedErrorWithCause(errorType, message, err).
                WithOperation(operation).
                WithComponent("resource_manager")

        // Add session ID as URL context for tracking
        if sessionID != "" {
                fe = fe.WithURL(fmt.Sprintf("session://%s", sessionID))
        }

        return fe
}

// CreateSubscriptionError creates a FeedError for subscription issues
func CreateSubscriptionError(err error, resourceURI, sessionID, operation string) *FeedError {
        errorType := ErrorTypeSubscription
        message := "Subscription operation failed"

        // Categorize subscription errors
        if err != nil {
                errStr := strings.ToLower(err.Error())
                switch {
                case strings.Contains(errStr, "already subscribed") || strings.Contains(errStr, "exists"):
                        errorType = ErrorTypeSubscriptionExists
                        message = "Already subscribed to resource"
                case strings.Contains(errStr, "not found") || strings.Contains(errStr, "no subscription"):
                        errorType = ErrorTypeSubscriptionNotFound
                        message = "Subscription not found"
                }
        }

        fe := NewFeedErrorWithCause(errorType, message, err).
                WithURL(resourceURI).
                WithOperation(operation).
                WithComponent("resource_manager")

        // Add session context
        if sessionID != "" {
                fe.HTTPHeaders = map[string]string{
                        "X-Session-ID": sessionID,
                }
        }

        return fe
}

// CreateResourceCacheError creates a FeedError for resource cache issues
func CreateResourceCacheError(err error, cacheKey, operation string) *FeedError {
        errorType := ErrorTypeResourceCache
        message := "Resource cache operation failed"

        // Categorize cache errors
        if operation == "invalidate" || operation == "cache_invalidation" {
                errorType = ErrorTypeCacheInvalidation
                message = "Cache invalidation failed"
        }

        fe := NewFeedErrorWithCause(errorType, message, err).
                WithOperation(operation).
                WithComponent("resource_cache")

        // Use cache key as URL context
        if cacheKey != "" {
                fe = fe.WithURL(fmt.Sprintf("cache://%s", cacheKey))
        }

        return fe
}

// Package model defines core data structures and error types for the feed MCP server.
package model

import (
        "fmt"
        "net/http"
        "strings"
        "time"

        gonanoid "github.com/matoous/go-nanoid/v2"
)

// ErrorType represents different categories of errors that can occur
type ErrorType string

const (
        // ErrorTypeNetwork represents general network-related errors
        ErrorTypeNetwork ErrorType = "network"
        // ErrorTypeTimeout represents request timeout errors
        ErrorTypeTimeout ErrorType = "timeout"
        // ErrorTypeConnectionFailed represents connection establishment failures
        ErrorTypeConnectionFailed ErrorType = "connection_failed"
        // ErrorTypeDNSResolution represents DNS resolution failures
        ErrorTypeDNSResolution ErrorType = "dns_resolution"

        // ErrorTypeHTTP represents general HTTP errors
        ErrorTypeHTTP ErrorType = "http"
        // ErrorTypeHTTPClientError represents HTTP 4xx client errors
        ErrorTypeHTTPClientError ErrorType = "http_client_error" // 4xx
        // ErrorTypeHTTPServerError represents HTTP 5xx server errors
        ErrorTypeHTTPServerError ErrorType = "http_server_error" // 5xx
        // ErrorTypeHTTPRedirect represents HTTP 3xx redirect issues
        ErrorTypeHTTPRedirect ErrorType = "http_redirect" // 3xx with issues

        // ErrorTypeParsing represents feed parsing errors
        ErrorTypeParsing ErrorType = "parsing"
        // ErrorTypeInvalidFormat represents invalid feed format errors
        ErrorTypeInvalidFormat ErrorType = "invalid_format"
        // ErrorTypeEmptyFeed represents empty or no-content feed errors
        ErrorTypeEmptyFeed ErrorType = "empty_feed"
        // ErrorTypeMalformedXML represents malformed XML feed errors
        ErrorTypeMalformedXML ErrorType = "malformed_xml"
        // ErrorTypeMalformedJSON represents malformed JSON feed errors
        ErrorTypeMalformedJSON ErrorType = "malformed_json"

        // ErrorTypeValidation represents URL validation errors
        ErrorTypeValidation ErrorType = "validation"
        // ErrorTypeInvalidURL represents invalid URL format errors
        ErrorTypeInvalidURL ErrorType = "invalid_url"
        // ErrorTypeUnsupportedScheme represents unsupported URL scheme errors
        ErrorTypeUnsupportedScheme ErrorType = "unsupported_scheme"
        // ErrorTypePrivateIP represents private IP address blocked errors
        ErrorTypePrivateIP ErrorType = "private_ip_blocked"

        // ErrorTypeConfiguration represents configuration-related errors
        ErrorTypeConfiguration ErrorType = "configuration"
        // ErrorTypeTransport represents transport configuration errors
        ErrorTypeTransport ErrorType = "transport"

        // ErrorTypeSystem represents system-level errors
        ErrorTypeSystem ErrorType = "system"
        // ErrorTypeCircuitBreaker represents circuit breaker state errors
        ErrorTypeCircuitBreaker ErrorType = "circuit_breaker"
        // ErrorTypeRateLimit represents rate limiting errors
        ErrorTypeRateLimit ErrorType = "rate_limit"
        // ErrorTypeCache represents caching-related errors
        ErrorTypeCache ErrorType = "cache"

        // ErrorTypeInternal represents internal server errors
        ErrorTypeInternal ErrorType = "internal"
        // ErrorTypeUnknown represents unknown or unclassified errors
        ErrorTypeUnknown ErrorType = "unknown"

        // ErrorTypeResource represents general resource-related errors
        ErrorTypeResource ErrorType = "resource"
        // ErrorTypeResourceNotFound represents resource not found errors
        ErrorTypeResourceNotFound ErrorType = "resource_not_found"
        // ErrorTypeResourceUnavailable represents resource temporarily unavailable
        ErrorTypeResourceUnavailable ErrorType = "resource_unavailable"
        // ErrorTypeInvalidResourceURI represents invalid resource URI format
        ErrorTypeInvalidResourceURI ErrorType = "invalid_resource_uri"
        // ErrorTypeResourceContent represents resource content generation errors
        ErrorTypeResourceContent ErrorType = "resource_content"

        // ErrorTypeSession represents session management errors
        ErrorTypeSession ErrorType = "session"
        // ErrorTypeSessionNotFound represents session not found errors
        ErrorTypeSessionNotFound ErrorType = "session_not_found"
        // ErrorTypeSubscription represents subscription operation errors
        ErrorTypeSubscription ErrorType = "subscription"
        // ErrorTypeSubscriptionExists represents duplicate subscription errors
        ErrorTypeSubscriptionExists ErrorType = "subscription_exists"
        // ErrorTypeSubscriptionNotFound represents subscription not found errors
        ErrorTypeSubscriptionNotFound ErrorType = "subscription_not_found"

        // ErrorTypeResourceCache represents resource cache operation errors
        ErrorTypeResourceCache ErrorType = "resource_cache"
        // ErrorTypeCacheInvalidation represents cache invalidation errors
        ErrorTypeCacheInvalidation ErrorType = "cache_invalidation"
)

// FeedError represents a structured error with additional context for debugging
type FeedError struct {
        // Core error information
        ID         string    `json:"id"`         // Unique correlation ID for tracking
        Timestamp  time.Time `json:"timestamp"`  // When the error occurred
        ErrorType  ErrorType `json:"error_type"` // Category of error
        Message    string    `json:"message"`    // Human-readable error message
        Suggestion string    `json:"suggestion"` // Actionable suggestion for resolution

        // Context information
        URL       string `json:"url,omitempty"`       // Feed URL that caused the error
        Operation string `json:"operation,omitempty"` // What operation was being performed
        Component string `json:"component,omitempty"` // Which component generated the error

        // HTTP-specific context
        HTTPStatus  int               `json:"http_status,omitempty"`  // HTTP status code
        HTTPHeaders map[string]string `json:"http_headers,omitempty"` // Relevant HTTP headers

        // Network-specific context
        NetworkError string `json:"network_error,omitempty"` // Specific network error details

        // Parsing-specific context
        ParseContext *ParseContext `json:"parse_context,omitempty"` // Context for parsing errors

        // Retry context
        Attempt     int           `json:"attempt,omitempty"`      // Which retry attempt this was
        MaxAttempts int           `json:"max_attempts,omitempty"` // Maximum retry attempts configured
        RetryAfter  time.Duration `json:"retry_after,omitempty"`  // How long before next retry

        // Original error for wrapping
        Cause error `json:"-"` // Original error (not serialized to JSON)
}

// ParseContext provides additional context for parsing errors
type ParseContext struct {
        LineNumber     int    `json:"line_number,omitempty"`     // Line where parsing failed
        ColumnNumber   int    `json:"column_number,omitempty"`   // Column where parsing failed
        ContentSnippet string `json:"content_snippet,omitempty"` // Relevant content around the error
        FeedFormat     string `json:"feed_format,omitempty"`     // Expected format (RSS, Atom, JSON)
}

// Error implements the error interface
func (fe *FeedError) Error() string {
        var parts []string

        // Start with the basic message
        if fe.Message != "" {
                parts = append(parts, fe.Message)
        }

        // Add URL context if available
        if fe.URL != "" {
                parts = append(parts, fmt.Sprintf("URL: %s", fe.URL))
        }

        // Add operation context
        if fe.Operation != "" {
                parts = append(parts, fmt.Sprintf("Operation: %s", fe.Operation))
        }

        // Add HTTP status if relevant
        if fe.HTTPStatus != 0 {
                parts = append(parts, fmt.Sprintf("HTTP Status: %d", fe.HTTPStatus))
        }

        // Add error type and ID for debugging
        parts = append(parts, fmt.Sprintf("Type: %s", fe.ErrorType), fmt.Sprintf("ID: %s", fe.ID))

        return strings.Join(parts, " | ")
}

// Unwrap returns the underlying cause for error wrapping support
func (fe *FeedError) Unwrap() error {
        return fe.Cause
}

// NewFeedError creates a new FeedError with basic information
func NewFeedError(errorType ErrorType, message string) *FeedError {
        id, _ := gonanoid.New() // Generate unique correlation ID

        return &FeedError{
                ID:         id,
                Timestamp:  time.Now().UTC(),
                ErrorType:  errorType,
                Message:    message,
                Suggestion: getSuggestionForErrorType(errorType),
        }
}

// NewFeedErrorWithCause creates a new FeedError wrapping an existing error
func NewFeedErrorWithCause(errorType ErrorType, message string, cause error) *FeedError {
        fe := NewFeedError(errorType, message)
        fe.Cause = cause
        return fe
}

// WithURL adds URL context to the error
func (fe *FeedError) WithURL(url string) *FeedError {
        fe.URL = url
        return fe
}

// WithOperation adds operation context to the error
func (fe *FeedError) WithOperation(operation string) *FeedError {
        fe.Operation = operation
        return fe
}

// WithComponent adds component context to the error
func (fe *FeedError) WithComponent(component string) *FeedError {
        fe.Component = component
        return fe
}

// WithHTTP adds HTTP-specific context to the error
func (fe *FeedError) WithHTTP(status int, headers http.Header) *FeedError {
        fe.HTTPStatus = status

        // Convert selected headers to map for context
        if headers != nil {
                fe.HTTPHeaders = make(map[string]string)

                // Include relevant headers for debugging
                relevantHeaders := []string{
                        "Content-Type", "Content-Length", "Server", "Cache-Control",
                        "Etag", "Last-Modified", "Retry-After", "X-RateLimit-Remaining",
                }

                for _, header := range relevantHeaders {
                        if value := headers.Get(header); value != "" {
                                fe.HTTPHeaders[header] = value
                        }
                }
        }

        return fe
}

// WithNetworkError adds network-specific context
func (fe *FeedError) WithNetworkError(networkErr string) *FeedError {
        fe.NetworkError = networkErr
        return fe
}

// WithParseContext adds parsing-specific context
func (fe *FeedError) WithParseContext(ctx *ParseContext) *FeedError {
        fe.ParseContext = ctx
        return fe
}

// WithRetryContext adds retry attempt information
func (fe *FeedError) WithRetryContext(attempt, maxAttempts int, retryAfter time.Duration) *FeedError {
        fe.Attempt = attempt
        fe.MaxAttempts = maxAttempts
        fe.RetryAfter = retryAfter
        return fe
}

// getSuggestionForErrorType returns actionable suggestions based on error type
func getSuggestionForErrorType(errorType ErrorType) string {
        suggestions := map[ErrorType]string{
                ErrorTypeTimeout:           "Check network connectivity or increase timeout duration",
                ErrorTypeConnectionFailed:  "Verify the URL is accessible and the server is running",
                ErrorTypeDNSResolution:     "Check DNS settings and verify the domain name is correct",
                ErrorTypeHTTPClientError:   "Verify the URL is correct and accessible",
                ErrorTypeHTTPServerError:   "The server is experiencing issues, try again later",
                ErrorTypeInvalidFormat:     "Ensure the feed URL returns valid RSS, Atom, or JSON feed content",
                ErrorTypeEmptyFeed:         "The feed appears to be empty, check if it contains any items",
                ErrorTypeMalformedXML:      "The feed contains invalid XML, contact the feed provider",
                ErrorTypeMalformedJSON:     "The feed contains invalid JSON, contact the feed provider",
                ErrorTypeInvalidURL:        "Check the URL format and ensure it's a valid HTTP/HTTPS URL",
                ErrorTypeUnsupportedScheme: "Only HTTP and HTTPS URLs are supported",
                ErrorTypePrivateIP:         "Private IP addresses are blocked for security, use --allow-private-ips if needed",
                ErrorTypeCircuitBreaker:    "Service is temporarily unavailable due to repeated failures",
                ErrorTypeRateLimit:         "Request rate limit exceeded, reduce the number of concurrent requests",
                ErrorTypeTransport:         "Check transport configuration (stdio, http-with-sse)",
                ErrorTypeConfiguration:     "Review configuration parameters for correctness",
                ErrorTypeSystem:            "Check system resources and permissions",
                ErrorTypeInternal:          "Internal server error occurred, check logs for details",

                // Resource-specific error suggestions
                ErrorTypeResource:            "Check the resource URI and ensure it's properly formatted",
                ErrorTypeResourceNotFound:    "Verify the resource URI exists and the feed ID is correct",
                ErrorTypeResourceUnavailable: "The resource is temporarily unavailable, try again later",
                ErrorTypeInvalidResourceURI:  "Ensure the resource URI follows the feeds:// scheme format",
                ErrorTypeResourceContent:     "Check the feed data and ensure it can be serialized properly",

                // Session and subscription error suggestions
                ErrorTypeSession:              "Check session management and ensure proper session lifecycle",
                ErrorTypeSessionNotFound:      "Verify the session ID exists and hasn't expired",
                ErrorTypeSubscription:         "Check subscription parameters and permissions",
                ErrorTypeSubscriptionExists:   "This resource is already subscribed to in this session",
                ErrorTypeSubscriptionNotFound: "No active subscription found for this resource",

                // Resource cache error suggestions
                ErrorTypeResourceCache:     "Check cache configuration and available memory",
                ErrorTypeCacheInvalidation: "Cache invalidation failed, check cache connectivity",
        }

        if suggestion, exists := suggestions[errorType]; exists {
                return suggestion
        }

        return "Check the error details and try again"
}

// Package model provides data structures and types for the feed-mcp server.
package model

import (
        "time"

        "github.com/mmcdole/gofeed"
        ext "github.com/mmcdole/gofeed/extensions"
)

// Feed represents a syndication feed (RSS, Atom, or JSON Feed)
type Feed struct {
        PublishedParsed *time.Time               `json:"publishedParsed,omitempty"`
        Custom          map[string]string        `json:"custom,omitempty"`
        Extensions      ext.Extensions           `json:"extensions,omitempty"`
        ITunesExt       *ext.ITunesFeedExtension `json:"itunesExt,omitempty"`
        DublinCoreExt   *ext.DublinCoreExtension `json:"dcExt,omitempty"`
        Image           *gofeed.Image            `json:"image,omitempty"`
        UpdatedParsed   *time.Time               `json:"updatedParsed,omitempty"`
        Updated         string                   `json:"updated,omitempty"`
        Link            string                   `json:"link,omitempty"`
        FeedVersion     string                   `json:"feedVersion"`
        Language        string                   `json:"language,omitempty"`
        Title           string                   `json:"title,omitempty"`
        Copyright       string                   `json:"copyright,omitempty"`
        Generator       string                   `json:"generator,omitempty"`
        FeedType        string                   `json:"feedType"`
        Description     string                   `json:"description,omitempty"`
        FeedLink        string                   `json:"feedLink,omitempty"`
        Published       string                   `json:"published,omitempty"`
        Links           []string                 `json:"links,omitempty"`
        Categories      []string                 `json:"categories,omitempty"`
        Authors         []*gofeed.Person         `json:"authors,omitempty"`
}

// FromGoFeed converts a gofeed.Feed to our internal Feed representation
func FromGoFeed(inFeed *gofeed.Feed) *Feed {
        if inFeed == nil {
                return nil
        }

        return &Feed{
                Title:           inFeed.Title,
                Description:     inFeed.Description,
                Link:            inFeed.Link,
                FeedLink:        inFeed.FeedLink,
                Links:           inFeed.Links,
                Updated:         inFeed.Updated,
                UpdatedParsed:   inFeed.UpdatedParsed,
                Published:       inFeed.Published,
                PublishedParsed: inFeed.PublishedParsed,
                Authors:         inFeed.Authors,
                Language:        inFeed.Language,
                Image:           inFeed.Image,
                Copyright:       inFeed.Copyright,
                Generator:       inFeed.Generator,
                Categories:      inFeed.Categories,
                DublinCoreExt:   inFeed.DublinCoreExt,
                ITunesExt:       inFeed.ITunesExt,
                Extensions:      inFeed.Extensions,
                Custom:          inFeed.Custom,
                FeedType:        inFeed.FeedType,
                FeedVersion:     inFeed.FeedVersion,
        }
}

// Package model provides shared utilities for feed ID generation
package model

import (
        "fmt"
        "hash/fnv"
        "net/url"
        "regexp"
        "strings"
)

// GenerateFeedID creates a stable, deterministic feed ID from a URL.
// This generates human-readable IDs like "feeds.bbci.co.uk-news-world-africa"
// with hash suffixes for uniqueness when needed.
func GenerateFeedID(feedURL string) string {
        // Parse URL to extract host and path for a more readable ID
        if parsedURL, err := url.Parse(feedURL); err == nil {
                // Create a slug-like ID from the host and path
                slug := strings.ToLower(parsedURL.Host)
                if parsedURL.Path != "" && parsedURL.Path != "/" {
                        // Clean the path and append to host
                        path := strings.Trim(parsedURL.Path, "/")
                        path = regexp.MustCompile(`[^a-z0-9-_]`).ReplaceAllString(path, "-")
                        path = regexp.MustCompile(`-+`).ReplaceAllString(path, "-")
                        slug = slug + "-" + path
                }
                // Truncate if too long and add hash suffix for uniqueness
                if len(slug) > 40 {
                        h := fnv.New32a()
                        _, _ = h.Write([]byte(feedURL)) // FNV hash Write never returns an error
                        hashStr := fmt.Sprintf("%x", h.Sum32())[:8]
                        slug = slug[:32] + "-" + hashStr
                }
                return slug
        }

        // Fallback to hash if URL parsing fails
        h := fnv.New32a()
        _, _ = h.Write([]byte(feedURL)) // FNV hash Write never returns an error
        return fmt.Sprintf("feed-%x", h.Sum32())
}

package model

import (
        "github.com/mmcdole/gofeed"
)

// FeedAndItemsResult represents a feed along with its items
type FeedAndItemsResult struct {
        ID                 string         `json:"id"`
        PublicURL          string         `json:"public_url"`
        Title              string         `json:"title,omitempty"`
        FetchError         string         `json:"fetch_error,omitempty"`
        Feed               *Feed          `json:"feed_result,omitempty"`
        Items              []*gofeed.Item `json:"items,omitempty"`
        CircuitBreakerOpen bool           `json:"circuit_breaker_open,omitempty"`
}

// FeedMetadata represents feed metadata without items
type FeedMetadata struct {
        ID                 string `json:"id"`
        PublicURL          string `json:"public_url"`
        Title              string `json:"title,omitempty"`
        FetchError         string `json:"fetch_error,omitempty"`
        Feed               *Feed  `json:"feed_result,omitempty"`
        CircuitBreakerOpen bool   `json:"circuit_breaker_open,omitempty"`
}

// ToMetadata returns the feed metadata without items
func (f *FeedAndItemsResult) ToMetadata() *FeedMetadata {
        return &FeedMetadata{
                ID:                 f.ID,
                PublicURL:          f.PublicURL,
                Title:              f.Title,
                FetchError:         f.FetchError,
                Feed:               f.Feed,
                CircuitBreakerOpen: f.CircuitBreakerOpen,
        }
}

// Package model provides OPML parsing functionality for the feed-mcp server.
package model

import (
        "encoding/xml"
        "fmt"
        "io"
        "net/http"
        "os"
        "strings"
        "time"
)

// OPMLOutline represents an outline element in OPML
type OPMLOutline struct {
        Text     string        `xml:"text,attr"`
        Title    string        `xml:"title,attr,omitempty"`
        Type     string        `xml:"type,attr,omitempty"`
        XMLURL   string        `xml:"xmlUrl,attr,omitempty"`
        HTMLURL  string        `xml:"htmlUrl,attr,omitempty"`
        Outlines []OPMLOutline `xml:"outline,omitempty"`
}

// OPMLBody represents the body section of OPML
type OPMLBody struct {
        Outlines []OPMLOutline `xml:"outline"`
}

// OPMLHead represents the head section of OPML
type OPMLHead struct {
        Title       string `xml:"title,omitempty"`
        DateCreated string `xml:"dateCreated,omitempty"`
        OwnerName   string `xml:"ownerName,omitempty"`
        OwnerEmail  string `xml:"ownerEmail,omitempty"`
}

// OPML represents an OPML document
type OPML struct {
        XMLName xml.Name `xml:"opml"`
        Version string   `xml:"version,attr"`
        Head    OPMLHead `xml:"head"`
        Body    OPMLBody `xml:"body"`
}

// ExtractFeedURLsFromOPML parses OPML content and extracts all feed URLs
func ExtractFeedURLsFromOPML(opmlContent []byte) ([]string, error) {
        var opml OPML
        if err := xml.Unmarshal(opmlContent, &opml); err != nil {
                return nil, NewFeedErrorWithCause(ErrorTypeParsing, "failed to parse OPML content", err).
                        WithOperation("extract_feed_urls").
                        WithComponent("opml_parser")
        }

        var urls []string
        extractURLsFromOutlines(opml.Body.Outlines, &urls)

        if len(urls) == 0 {
                return nil, NewFeedError(ErrorTypeConfiguration, "no feed URLs found in OPML").
                        WithOperation("extract_feed_urls").
                        WithComponent("opml_parser")
        }

        return urls, nil
}

// extractURLsFromOutlines recursively extracts feed URLs from OPML outlines
func extractURLsFromOutlines(outlines []OPMLOutline, urls *[]string) {
        for _, outline := range outlines {
                // If this outline has an xmlUrl, it's a feed
                if outline.XMLURL != "" {
                        *urls = append(*urls, outline.XMLURL)
                }
                // Recursively check nested outlines
                if len(outline.Outlines) > 0 {
                        extractURLsFromOutlines(outline.Outlines, urls)
                }
        }
}

// LoadOPMLFromFile loads and parses an OPML file from the local filesystem
func LoadOPMLFromFile(path string) ([]string, error) {
        file, err := os.Open(path) // #nosec G304 -- path is user-provided CLI argument, this is expected behavior
        if err != nil {
                return nil, NewFeedErrorWithCause(ErrorTypeSystem, fmt.Sprintf("failed to open OPML file: %s", path), err).
                        WithOperation("load_opml_file").
                        WithComponent("opml_loader")
        }
        defer func() {
                if closeErr := file.Close(); closeErr != nil {
                        // Note: In a production application, this would be logged
                        // For now, we silently ignore close errors to avoid overriding main errors
                        _ = closeErr
                }
        }()

        content, err := io.ReadAll(file)
        if err != nil {
                return nil, NewFeedErrorWithCause(ErrorTypeSystem, fmt.Sprintf("failed to read OPML file: %s", path), err).
                        WithOperation("load_opml_file").
                        WithComponent("opml_loader")
        }

        return ExtractFeedURLsFromOPML(content)
}

// LoadOPMLFromURL loads and parses an OPML file from a remote URL
func LoadOPMLFromURL(url string) ([]string, error) {
        // Use a reasonable timeout for OPML fetching
        client := &http.Client{
                Timeout: 30 * time.Second,
        }

        resp, err := client.Get(url)
        if err != nil {
                return nil, NewFeedErrorWithCause(ErrorTypeNetwork, fmt.Sprintf("failed to fetch OPML from URL: %s", url), err).
                        WithOperation("load_opml_url").
                        WithComponent("opml_loader")
        }
        defer func() {
                if closeErr := resp.Body.Close(); closeErr != nil {
                        // Note: In a production application, this would be logged
                        // For now, we silently ignore close errors to avoid overriding main errors
                        _ = closeErr
                }
        }()

        if resp.StatusCode != http.StatusOK {
                return nil, NewFeedError(ErrorTypeHTTP, fmt.Sprintf("HTTP %d when fetching OPML from: %s", resp.StatusCode, url)).
                        WithOperation("load_opml_url").
                        WithComponent("opml_loader").
                        WithHTTP(resp.StatusCode, resp.Header)
        }

        content, err := io.ReadAll(resp.Body)
        if err != nil {
                return nil, NewFeedErrorWithCause(ErrorTypeNetwork, fmt.Sprintf("failed to read OPML response from: %s", url), err).
                        WithOperation("load_opml_url").
                        WithComponent("opml_loader")
        }

        return ExtractFeedURLsFromOPML(content)
}

// LoadFeedURLsFromOPML loads feed URLs from either a local file or remote URL
func LoadFeedURLsFromOPML(opmlSource string) ([]string, error) {
        if opmlSource == "" {
                return nil, NewFeedError(ErrorTypeConfiguration, "OPML source cannot be empty").
                        WithOperation("load_feeds_from_opml").
                        WithComponent("opml_loader")
        }

        // Determine if it's a URL or file path
        if strings.HasPrefix(opmlSource, "http://") || strings.HasPrefix(opmlSource, "https://") {
                return LoadOPMLFromURL(opmlSource)
        }

        return LoadOPMLFromFile(opmlSource)
}

package model

import (
        "errors"
)

// ErrInvalidTransport is returned when an invalid transport type is specified.
var ErrInvalidTransport = errors.New("invalid transport")

// Transport represents the communication transport method for the MCP server
type Transport uint8

// Transport constants define the available transport types.
const (
        UndefinedTransport Transport = iota
        StdioTransport
        HTTPWithSSETransport
)

// ParseTransport converts a string to a Transport type
func ParseTransport(transport string) (Transport, error) {
        switch transport {
        case "stdio":
                return StdioTransport, nil
        case "http-with-sse":
                return HTTPWithSSETransport, nil
        default:
                return UndefinedTransport, ErrInvalidTransport
        }
}

// String returns the string representation of a Transport
func (t Transport) String() string {
        switch t {
        case StdioTransport:
                return "stdio"
        case HTTPWithSSETransport:
                return "http-with-sse"
        default:
                return "undefined"
        }
}

package model

import (
        "errors"
        "fmt"
        "net"
        "net/url"
        "strings"
)

// URL validation errors
var (
        ErrInvalidURL        = errors.New("invalid URL format")
        ErrUnsupportedScheme = errors.New("unsupported URL scheme - only HTTP and HTTPS are allowed")
        ErrPrivateIPBlocked  = errors.New("private IP addresses and localhost are blocked for security")
        ErrMissingHost       = errors.New("URL must have a valid host")
        ErrEmptyURL          = errors.New("URL cannot be empty")
)

// ValidateFeedURL validates a feed URL for security and format correctness.
// Performs comprehensive security checks including scheme validation, host verification,
// and optional private IP/localhost blocking to prevent SSRF attacks.
// Returns an error if the URL fails any security or format validation checks.
func ValidateFeedURL(rawURL string, allowPrivateIPs bool) error {
        if rawURL == "" {
                return ErrEmptyURL
        }

        // Parse the URL
        u, err := url.Parse(rawURL)
        if err != nil {
                return fmt.Errorf("%w: %w", ErrInvalidURL, err)
        }

        // Validate scheme
        if err := validateScheme(u.Scheme); err != nil {
                return err
        }

        // Validate host
        if u.Host == "" {
                return ErrMissingHost
        }

        // Check for private IPs if not allowed
        if !allowPrivateIPs {
                if err := validateHost(u.Host); err != nil {
                        return err
                }
        }

        return nil
}

// validateScheme ensures only HTTP and HTTPS schemes are allowed.
// Blocks potentially dangerous schemes like file://, ftp://, and data:// to prevent
// various attack vectors including local file inclusion and data exfiltration.
func validateScheme(scheme string) error {
        scheme = strings.ToLower(scheme)
        if scheme != "http" && scheme != "https" {
                return ErrUnsupportedScheme
        }
        return nil
}

// validateHost checks if the host resolves to private IP ranges or localhost.
// Performs DNS resolution and validates resolved IPs against private ranges (RFC 1918)
// and localhost patterns to prevent SSRF attacks against internal services.
// Allows temporarily unresolvable hosts to fail at HTTP request time.
func validateHost(host string) error {
        // Remove port if present
        hostname, _, err := net.SplitHostPort(host)
        if err != nil {
                // If SplitHostPort fails, assume no port and use the whole host
                hostname = host
        }

        // Check for localhost patterns
        if isLocalhost(hostname) {
                return ErrPrivateIPBlocked
        }

        // Try to resolve the hostname to IP addresses
        ips, err := net.LookupIP(hostname)
        if err != nil {
                // If we can't resolve, let the HTTP client handle it later
                // This avoids blocking valid URLs that might be temporarily unresolvable
                return nil
        }

        // Check if any resolved IP is private
        for _, ip := range ips {
                if isPrivateIP(ip) {
                        return ErrPrivateIPBlocked
                }
        }

        return nil
}

// isLocalhost checks for common localhost patterns
func isLocalhost(hostname string) bool {
        hostname = strings.ToLower(hostname)

        localhostPatterns := []string{
                "localhost",
                "127.0.0.1",
                "::1",
                "[::1]", // IPv6 with brackets
        }

        for _, pattern := range localhostPatterns {
                if hostname == pattern {
                        return true
                }
        }

        return strings.HasPrefix(hostname, "127.")
}

// isPrivateIP checks if an IP address is in a private range
//
//nolint:gocyclo // Function complexity is necessary for comprehensive private IP range validation (security requirement)
func isPrivateIP(ip net.IP) bool {
        // Check for IPv4 private ranges
        if ip4 := ip.To4(); ip4 != nil {
                // 10.0.0.0/8
                if ip4[0] == 10 {
                        return true
                }
                // 172.16.0.0/12
                if ip4[0] == 172 && ip4[1] >= 16 && ip4[1] <= 31 {
                        return true
                }
                // 192.168.0.0/16
                if ip4[0] == 192 && ip4[1] == 168 {
                        return true
                }
                // 169.254.0.0/16 (link-local)
                if ip4[0] == 169 && ip4[1] == 254 {
                        return true
                }
                // 127.0.0.0/8 (loopback)
                if ip4[0] == 127 {
                        return true
                }
        }

        // Check for IPv6 private ranges
        if ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() {
                return true
        }

        // Check for IPv6 unique local addresses (fc00::/7)
        if len(ip) == 16 && (ip[0]&0xfe) == 0xfc {
                return true
        }

        return false
}

// SanitizeFeedURLs validates a slice of feed URLs
func SanitizeFeedURLs(urls []string, allowPrivateIPs bool) error {
        if len(urls) == 0 {
                return errors.New("no feed URLs provided")
        }

        var invalidURLs []string
        for _, rawURL := range urls {
                if err := ValidateFeedURL(rawURL, allowPrivateIPs); err != nil {
                        invalidURLs = append(invalidURLs, fmt.Sprintf("%s: %v", rawURL, err))
                }
        }

        if len(invalidURLs) > 0 {
                return fmt.Errorf("invalid feed URLs:\n%s", strings.Join(invalidURLs, "\n"))
        }

        return nil
}

package model

import (
        "fmt"

        "github.com/alecthomas/kong"
)

// VersionFlag is a custom flag type for displaying version information.
type VersionFlag string

// Decode implements the kong.DecodeContext interface.
func (v VersionFlag) Decode(ctx *kong.DecodeContext) error { return nil }

// IsBool implements the kong.BoolMapper interface.
func (v VersionFlag) IsBool() bool { return true }

// BeforeApply implements the kong.BeforeApply interface to handle version display.
func (v VersionFlag) BeforeApply(app *kong.Kong, vars kong.Vars) error {
        fmt.Println(vars["version"])
        app.Exit(0)
        return nil
}

// Package performance provides utilities and benchmarks for MCP Resources performance testing
package performance

import (
        "context"
        "fmt"
        "runtime"
        "sync"
        "time"

        "github.com/mmcdole/gofeed"

        "github.com/richardwooding/feed-mcp/mcpserver"
        "github.com/richardwooding/feed-mcp/model"
)

// BenchmarkConfig holds configuration for performance benchmarks
type BenchmarkConfig struct {
        FeedCount       int           // Number of feeds to use in benchmarks
        ItemsPerFeed    int           // Number of items per feed
        ConcurrentUsers int           // Number of concurrent users to simulate
        Duration        time.Duration // How long to run the benchmark
}

// DefaultBenchmarkConfig returns a default benchmark configuration
func DefaultBenchmarkConfig() *BenchmarkConfig {
        return &BenchmarkConfig{
                FeedCount:       100,
                ItemsPerFeed:    50,
                ConcurrentUsers: 10,
                Duration:        30 * time.Second,
        }
}

// Metrics holds performance measurement results
type Metrics struct {
        TotalOperations  int64
        AverageLatency   time.Duration
        P95Latency       time.Duration
        P99Latency       time.Duration
        ThroughputPerSec float64
        ErrorRate        float64
        MemoryUsageMB    float64
        GoroutineCount   int
}

// ResourcePerformanceTester provides utilities for testing resource performance
type ResourcePerformanceTester struct {
        resourceManager *mcpserver.ResourceManager
        config          *BenchmarkConfig
}

// NewResourcePerformanceTester creates a new performance tester
func NewResourcePerformanceTester(config *BenchmarkConfig) *ResourcePerformanceTester {
        if config == nil {
                config = DefaultBenchmarkConfig()
        }

        // Create mock data for testing
        mockAllFeeds := createMockAllFeedsGetter(config.FeedCount)
        mockFeedGetter := createMockFeedAndItemsGetter(config.FeedCount, config.ItemsPerFeed)

        // Optimize cache config for performance testing
        cacheConfig := &mcpserver.ResourceCacheConfig{
                DefaultTTL:      10 * time.Minute,
                FeedListTTL:     5 * time.Minute,
                FeedItemsTTL:    10 * time.Minute,
                FeedMetadataTTL: 15 * time.Minute,
                MaxCost:         256 << 20, // 256MB
                NumCounters:     10000,
                BufferItems:     256,
        }

        rm := mcpserver.NewResourceManagerWithConfig(mockAllFeeds, mockFeedGetter, cacheConfig)

        return &ResourcePerformanceTester{
                resourceManager: rm,
                config:          config,
        }
}

// BenchmarkResourceListing measures resource listing performance
func (rpt *ResourcePerformanceTester) BenchmarkResourceListing(ctx context.Context) (*Metrics, error) {
        return rpt.runBenchmark(ctx, "ListResources", func(ctx context.Context) error {
                _, err := rpt.resourceManager.ListResources(ctx)
                return err
        })
}

// BenchmarkResourceReading measures resource reading performance with cache hits
func (rpt *ResourcePerformanceTester) BenchmarkResourceReading(ctx context.Context) (*Metrics, error) {
        // Pre-warm cache
        feedID := generateFeedID("https://example.com/feed1.xml")
        uri := fmt.Sprintf("feeds://feed/%s/items", feedID)
        _, _ = rpt.resourceManager.ReadResource(ctx, uri)

        return rpt.runBenchmark(ctx, "ReadResource", func(ctx context.Context) error {
                _, err := rpt.resourceManager.ReadResource(ctx, uri)
                return err
        })
}

// BenchmarkConcurrentAccess measures performance under concurrent load
func (rpt *ResourcePerformanceTester) BenchmarkConcurrentAccess(ctx context.Context) (*Metrics, error) {
        return rpt.runConcurrentBenchmark(ctx, "ConcurrentAccess", func(ctx context.Context, workerID int) error {
                // Mix of operations
                switch workerID % 4 {
                case 0:
                        _, err := rpt.resourceManager.ListResources(ctx)
                        return err
                case 1:
                        feedID := generateFeedID(fmt.Sprintf("https://example.com/feed%d.xml", workerID%rpt.config.FeedCount))
                        uri := fmt.Sprintf("feeds://feed/%s/items", feedID)
                        _, err := rpt.resourceManager.ReadResource(ctx, uri)
                        return err
                case 2:
                        sessionID := fmt.Sprintf("session-%d", workerID)
                        rpt.resourceManager.CreateSession(sessionID)
                        feedID := generateFeedID(fmt.Sprintf("https://example.com/feed%d.xml", workerID%rpt.config.FeedCount))
                        uri := fmt.Sprintf("feeds://feed/%s", feedID)
                        return rpt.resourceManager.Subscribe(sessionID, uri)
                case 3:
                        feedID := generateFeedID(fmt.Sprintf("https://example.com/feed%d.xml", workerID%rpt.config.FeedCount))
                        uri := fmt.Sprintf("feeds://feed/%s", feedID)
                        _ = rpt.resourceManager.GetSubscribedSessions(uri)
                        return nil
                }
                return nil
        })
}

// BenchmarkMemoryUsage measures memory usage patterns
func (rpt *ResourcePerformanceTester) BenchmarkMemoryUsage(ctx context.Context) (*Metrics, error) {
        var memStats runtime.MemStats
        runtime.ReadMemStats(&memStats)
        initialMemory := memStats.Alloc

        metrics, err := rpt.BenchmarkResourceListing(ctx)
        if err != nil {
                return nil, err
        }

        runtime.ReadMemStats(&memStats)
        finalMemory := memStats.Alloc

        metrics.MemoryUsageMB = float64(finalMemory-initialMemory) / (1024 * 1024)
        return metrics, nil
}

// runBenchmark executes a single-threaded benchmark
func (rpt *ResourcePerformanceTester) runBenchmark(ctx context.Context, name string, operation func(context.Context) error) (*Metrics, error) {
        var operations int64
        var totalLatency time.Duration
        var errors int64
        latencies := make([]time.Duration, 0, 1000)

        timeout := time.After(rpt.config.Duration)
        startTime := time.Now()

        for {
                select {
                case <-timeout:
                        goto done
                case <-ctx.Done():
                        return nil, ctx.Err()
                default:
                        opStart := time.Now()
                        err := operation(ctx)
                        latency := time.Since(opStart)

                        operations++
                        totalLatency += latency
                        latencies = append(latencies, latency)

                        if err != nil {
                                errors++
                        }

                        // Limit latency slice size to prevent memory issues
                        if len(latencies) > 10000 {
                                latencies = latencies[1000:]
                        }
                }
        }

done:
        duration := time.Since(startTime)

        if operations == 0 {
                return &Metrics{}, nil
        }

        // Calculate percentiles
        p95, p99 := calculatePercentiles(latencies)

        return &Metrics{
                TotalOperations:  operations,
                AverageLatency:   totalLatency / time.Duration(operations),
                P95Latency:       p95,
                P99Latency:       p99,
                ThroughputPerSec: float64(operations) / duration.Seconds(),
                ErrorRate:        float64(errors) / float64(operations),
                GoroutineCount:   runtime.NumGoroutine(),
        }, nil
}

// runConcurrentBenchmark executes a multi-threaded benchmark
func (rpt *ResourcePerformanceTester) runConcurrentBenchmark(ctx context.Context, name string, operation func(context.Context, int) error) (*Metrics, error) {
        var totalOperations int64
        var totalErrors int64
        var totalLatency time.Duration
        var mu sync.Mutex
        latencies := make([]time.Duration, 0, 1000)

        var wg sync.WaitGroup
        timeout := time.After(rpt.config.Duration)
        startTime := time.Now()

        // Start concurrent workers
        for i := 0; i < rpt.config.ConcurrentUsers; i++ {
                wg.Add(1)
                go func(workerID int) {
                        defer wg.Done()

                        var operations int64
                        var errors int64
                        var workerLatency time.Duration
                        workerLatencies := make([]time.Duration, 0, 100)

                        for {
                                select {
                                case <-timeout:
                                        // Aggregate worker results
                                        mu.Lock()
                                        totalOperations += operations
                                        totalErrors += errors
                                        totalLatency += workerLatency
                                        latencies = append(latencies, workerLatencies...)
                                        mu.Unlock()
                                        return
                                case <-ctx.Done():
                                        return
                                default:
                                        opStart := time.Now()
                                        err := operation(ctx, workerID)
                                        latency := time.Since(opStart)

                                        operations++
                                        workerLatency += latency
                                        workerLatencies = append(workerLatencies, latency)

                                        if err != nil {
                                                errors++
                                        }

                                        // Limit latency slice size
                                        if len(workerLatencies) > 1000 {
                                                workerLatencies = workerLatencies[100:]
                                        }
                                }
                        }
                }(i)
        }

        wg.Wait()
        duration := time.Since(startTime)

        if totalOperations == 0 {
                return &Metrics{}, nil
        }

        // Calculate percentiles
        p95, p99 := calculatePercentiles(latencies)

        return &Metrics{
                TotalOperations:  totalOperations,
                AverageLatency:   totalLatency / time.Duration(totalOperations),
                P95Latency:       p95,
                P99Latency:       p99,
                ThroughputPerSec: float64(totalOperations) / duration.Seconds(),
                ErrorRate:        float64(totalErrors) / float64(totalOperations),
                GoroutineCount:   runtime.NumGoroutine(),
        }, nil
}

// Helper functions

func calculatePercentiles(latencies []time.Duration) (p95, p99 time.Duration) {
        if len(latencies) == 0 {
                return 0, 0
        }

        // Simple percentile calculation (would use sort in production)
        total := len(latencies)
        p95Index := int(float64(total) * 0.95)
        p99Index := int(float64(total) * 0.99)

        if p95Index >= total {
                p95Index = total - 1
        }
        if p99Index >= total {
                p99Index = total - 1
        }

        // Find approximate percentiles (simplified for demo)
        var sum time.Duration
        for _, l := range latencies {
                sum += l
        }
        avg := sum / time.Duration(len(latencies))

        // Rough estimate based on average (in production, would properly sort and calculate)
        _ = p95Index                            // Use the calculated index (simplified for demo)
        _ = p99Index                            // Use the calculated index (simplified for demo)
        p95 = time.Duration(float64(avg) * 1.5) // Approximate P95
        p99 = time.Duration(float64(avg) * 2.0) // Approximate P99

        return p95, p99
}

func generateFeedID(url string) string {
        // Simple hash function for testing (matches the one in resources.go)
        hash := uint32(0)
        for _, c := range url {
                hash = hash*31 + uint32(c)
        }
        return fmt.Sprintf("%x", hash)
}

// Mock implementations for testing

func createMockAllFeedsGetter(count int) *mockAllFeedsGetter {
        feeds := make([]*model.FeedResult, count)
        for i := 0; i < count; i++ {
                feedID := generateFeedID(fmt.Sprintf("https://example.com/perf-feed%d.xml", i))
                feeds[i] = &model.FeedResult{
                        ID:        feedID,
                        Title:     fmt.Sprintf("Performance Feed %d", i),
                        PublicURL: fmt.Sprintf("https://example.com/perf-feed%d.xml", i),
                }
        }
        return &mockAllFeedsGetter{feeds: feeds}
}

func createMockFeedAndItemsGetter(feedCount, itemsPerFeed int) *mockFeedAndItemsGetter {
        feedsMap := make(map[string]*model.FeedAndItemsResult)

        for i := 0; i < feedCount; i++ {
                url := fmt.Sprintf("https://example.com/perf-feed%d.xml", i)
                feedID := generateFeedID(url)

                // Create gofeed.Item objects
                items := make([]*gofeed.Item, itemsPerFeed)
                for j := 0; j < itemsPerFeed; j++ {
                        items[j] = &gofeed.Item{
                                Title:       fmt.Sprintf("Performance Item %d-%d", i, j),
                                Description: fmt.Sprintf("Performance test item %d in feed %d", j, i),
                                Link:        fmt.Sprintf("https://example.com/perf-feed%d/item%d", i, j),
                                Published:   time.Now().Add(-time.Duration(j) * time.Hour).Format(time.RFC3339),
                                Authors:     []*gofeed.Person{{Name: fmt.Sprintf("Author %d", j%5)}},
                                Categories:  []string{fmt.Sprintf("perf-cat%d", j%3)},
                                GUID:        fmt.Sprintf("perf-guid-%d-%d", i, j),
                        }
                }

                feedsMap[feedID] = &model.FeedAndItemsResult{
                        ID:        feedID,
                        Title:     fmt.Sprintf("Performance Feed %d", i),
                        PublicURL: url,
                        Feed:      &model.Feed{Title: fmt.Sprintf("Performance Feed %d", i), Description: fmt.Sprintf("A performance test feed number %d", i)},
                        Items:     items,
                }
        }

        return &mockFeedAndItemsGetter{feeds: feedsMap}
}

// Mock types (these would typically be imported from the test files)
type mockAllFeedsGetter struct {
        feeds []*model.FeedResult
}

// GetAllFeeds implements the AllFeedsGetter interface for testing
func (m *mockAllFeedsGetter) GetAllFeeds(ctx context.Context) ([]*model.FeedResult, error) {
        return m.feeds, nil
}

type mockFeedAndItemsGetter struct {
        feeds map[string]*model.FeedAndItemsResult
}

// GetFeedAndItems implements the FeedAndItemsGetter interface for testing
func (m *mockFeedAndItemsGetter) GetFeedAndItems(ctx context.Context, feedID string) (*model.FeedAndItemsResult, error) {
        if feed, exists := m.feeds[feedID]; exists {
                return feed, nil
        }
        return nil, fmt.Errorf("feed not found: %s", feedID)
}

// Package store implements dynamic feed management functionality.
package store

import (
        "context"
        "fmt"
        "sync"
        "time"

        "github.com/sony/gobreaker"

        "github.com/richardwooding/feed-mcp/mcpserver"
        "github.com/richardwooding/feed-mcp/model"
)

// Feed status constants
const (
        statusActive = "active"
        statusError  = "error"
)

// feedCacheInfo holds the result of a feed cache check
type feedCacheInfo struct {
        ItemCount   int
        Title       string
        Status      string
        LastError   string
        LastFetched time.Time
        Found       bool
}

// DynamicFeedMetadata holds metadata for dynamically managed feeds
type DynamicFeedMetadata struct {
        Title       string               `json:"title,omitempty"`
        Category    string               `json:"category,omitempty"`
        Description string               `json:"description,omitempty"`
        AddedAt     time.Time            `json:"addedAt"`
        Source      mcpserver.FeedSource `json:"source"`
        Status      string               `json:"status"` // active, error, paused
        LastError   string               `json:"lastError,omitempty"`
        LastFetched time.Time            `json:"lastFetched,omitempty"`
}

// DynamicStore extends Store with dynamic feed management capabilities
type DynamicStore struct {
        *Store
        config            Config
        dynamicFeeds      map[string]string               // feedID -> URL for runtime feeds
        feedMetadata      map[string]*DynamicFeedMetadata // feedID -> metadata
        dynamicMutex      sync.RWMutex
        allowRuntimeFeeds bool
}

// NewDynamicStore creates a new dynamic feed store
func NewDynamicStore(config *Config, allowRuntimeFeeds bool) (*DynamicStore, error) {
        // If runtime feeds are allowed and no initial feeds are provided, create an empty config
        if allowRuntimeFeeds && len(config.Feeds) == 0 {
                // Create a config with an empty feed list
                tempConfig := *config
                tempConfig.Feeds = []string{}
                tempConfig.AllowEmptyFeeds = true

                baseStore, err := NewStore(&tempConfig)
                if err != nil {
                        return nil, err
                }

                ds := &DynamicStore{
                        Store:             baseStore,
                        config:            *config,
                        dynamicFeeds:      make(map[string]string),
                        feedMetadata:      make(map[string]*DynamicFeedMetadata),
                        allowRuntimeFeeds: allowRuntimeFeeds,
                }

                return ds, nil
        }

        // Normal path with initial feeds
        baseStore, err := NewStore(config)
        if err != nil {
                return nil, err
        }

        ds := &DynamicStore{
                Store:             baseStore,
                config:            *config,
                dynamicFeeds:      make(map[string]string),
                feedMetadata:      make(map[string]*DynamicFeedMetadata),
                allowRuntimeFeeds: allowRuntimeFeeds,
        }

        // Initialize metadata for startup feeds
        ds.initializeStartupFeedMetadata()

        return ds, nil
}

// checkFeedCache retrieves feed information from cache and returns status information
func (ds *DynamicStore) checkFeedCache(ctx context.Context, url string) feedCacheInfo {
        info := feedCacheInfo{
                Status:      statusActive,
                LastFetched: time.Now(),
                Found:       true,
        }

        feed, err := ds.feedCacheManager.Get(ctx, url)
        if err == nil && feed != nil {
                info.ItemCount = len(feed.Items)
                info.Title = feed.Title
                info.LastFetched = time.Now()
        } else {
                info.Status = statusError
                info.Found = false
                if err != nil {
                        info.LastError = err.Error()
                } else {
                        info.LastError = "failed to fetch feed: unknown error"
                }
        }

        return info
}

// initializeStartupFeedMetadata creates metadata entries for feeds loaded at startup
func (ds *DynamicStore) initializeStartupFeedMetadata() {
        ds.dynamicMutex.Lock()
        defer ds.dynamicMutex.Unlock()

        for feedID, url := range ds.feeds {
                // Determine source based on how feeds were loaded
                source := mcpserver.FeedSourceStartup
                if ds.config.OPML != "" {
                        source = mcpserver.FeedSourceOPML
                }

                ds.feedMetadata[feedID] = &DynamicFeedMetadata{
                        AddedAt: time.Now(), // Approximate startup time
                        Source:  source,
                        Status:  statusActive,
                }

                // Try to get feed title from cache
                cacheInfo := ds.checkFeedCache(context.Background(), url)
                if cacheInfo.Found {
                        ds.feedMetadata[feedID].Title = cacheInfo.Title
                        ds.feedMetadata[feedID].LastFetched = cacheInfo.LastFetched
                }
        }
}

// AddFeed implements DynamicFeedManager.AddFeed
func (ds *DynamicStore) AddFeed(ctx context.Context, config mcpserver.FeedConfig) (*mcpserver.ManagedFeedInfo, error) {
        if !ds.allowRuntimeFeeds {
                return nil, model.NewFeedError(model.ErrorTypeConfiguration, "runtime feed management is not enabled").
                        WithOperation("add_feed").
                        WithComponent("dynamic_store")
        }

        // Validate the URL
        if err := model.SanitizeFeedURLs([]string{config.URL}, ds.config.AllowPrivateIPs); err != nil {
                return nil, err
        }

        ds.dynamicMutex.Lock()
        defer ds.dynamicMutex.Unlock()

        // Check if feed already exists (ds.feeds contains all feeds including dynamic ones)
        for _, url := range ds.feeds {
                if url == config.URL {
                        return nil, model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("feed with URL %s already exists", config.URL)).
                                WithOperation("add_feed").
                                WithComponent("dynamic_store")
                }
        }

        // Generate feed ID
        feedID := model.GenerateFeedID(config.URL)

        // Add circuit breaker if enabled
        if ds.circuitBreakers != nil {
                settings := gobreaker.Settings{
                        Name:        fmt.Sprintf("feed-%s", config.URL),
                        MaxRequests: ds.config.CircuitBreakerMaxRequests,
                        Interval:    ds.config.CircuitBreakerInterval,
                        Timeout:     ds.config.CircuitBreakerTimeout,
                        ReadyToTrip: func(counts gobreaker.Counts) bool {
                                return counts.ConsecutiveFailures >= ds.config.CircuitBreakerFailureThreshold
                        },
                }
                ds.circuitBreakers[config.URL] = gobreaker.NewCircuitBreaker(settings)
        }

        // Add to dynamic feeds
        ds.dynamicFeeds[feedID] = config.URL
        ds.feeds[feedID] = config.URL

        // Create metadata
        metadata := &DynamicFeedMetadata{
                Title:       config.Title,
                Category:    config.Category,
                Description: config.Description,
                AddedAt:     time.Now(),
                Source:      mcpserver.FeedSourceRuntime,
                Status:      statusActive,
        }

        // Try to fetch feed initially to get title and validate
        cacheInfo := ds.checkFeedCache(ctx, config.URL)
        itemCount := cacheInfo.ItemCount
        if cacheInfo.Found {
                metadata.LastFetched = cacheInfo.LastFetched
                if metadata.Title == "" {
                        metadata.Title = cacheInfo.Title
                }
        } else {
                metadata.LastError = cacheInfo.LastError
                metadata.Status = cacheInfo.Status
        }

        ds.feedMetadata[feedID] = metadata

        return &mcpserver.ManagedFeedInfo{
                FeedID:      feedID,
                URL:         config.URL,
                Title:       metadata.Title,
                Category:    metadata.Category,
                Description: metadata.Description,
                Status:      metadata.Status,
                LastFetched: metadata.LastFetched,
                LastError:   metadata.LastError,
                ItemCount:   itemCount,
                AddedAt:     metadata.AddedAt,
                Source:      string(metadata.Source),
        }, nil
}

// RemoveFeed implements DynamicFeedManager.RemoveFeed
func (ds *DynamicStore) RemoveFeed(ctx context.Context, feedID string) (*mcpserver.RemovedFeedInfo, error) {
        if !ds.allowRuntimeFeeds {
                return nil, model.NewFeedError(model.ErrorTypeConfiguration, "runtime feed management is not enabled").
                        WithOperation("remove_feed").
                        WithComponent("dynamic_store")
        }

        ds.dynamicMutex.Lock()
        defer ds.dynamicMutex.Unlock()

        url, exists := ds.feeds[feedID]
        if !exists {
                return nil, model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("feed with ID %s not found", feedID)).
                        WithOperation("remove_feed").
                        WithComponent("dynamic_store")
        }

        metadata := ds.feedMetadata[feedID]

        // Don't allow removal of startup or OPML feeds
        if metadata != nil && metadata.Source != mcpserver.FeedSourceRuntime {
                return nil, model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("cannot remove %s feed %s", metadata.Source, feedID)).
                        WithOperation("remove_feed").
                        WithComponent("dynamic_store")
        }

        // Get item count before removal
        itemCount := 0
        if feed, err := ds.feedCacheManager.Get(ctx, url); err == nil && feed != nil {
                itemCount = len(feed.Items)
        }

        // Remove from maps
        delete(ds.feeds, feedID)
        delete(ds.dynamicFeeds, feedID)
        delete(ds.feedMetadata, feedID)

        // Remove circuit breaker
        if ds.circuitBreakers != nil {
                delete(ds.circuitBreakers, url)
        }

        // Clear from cache
        _ = ds.feedCacheManager.Delete(ctx, url) // Cache deletion errors are not critical

        title := ""
        if metadata != nil {
                title = metadata.Title
        }

        return &mcpserver.RemovedFeedInfo{
                FeedID:       feedID,
                URL:          url,
                Title:        title,
                ItemsRemoved: itemCount,
        }, nil
}

// RemoveFeedByURL implements DynamicFeedManager.RemoveFeedByURL
func (ds *DynamicStore) RemoveFeedByURL(ctx context.Context, url string) (*mcpserver.RemovedFeedInfo, error) {
        ds.dynamicMutex.RLock()
        var feedID string
        for id, feedURL := range ds.feeds {
                if feedURL == url {
                        feedID = id
                        break
                }
        }
        ds.dynamicMutex.RUnlock()

        if feedID == "" {
                return nil, model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("feed with URL %s not found", url)).
                        WithOperation("remove_feed_by_url").
                        WithComponent("dynamic_store")
        }

        return ds.RemoveFeed(ctx, feedID)
}

// ListManagedFeeds implements DynamicFeedManager.ListManagedFeeds
func (ds *DynamicStore) ListManagedFeeds(ctx context.Context) ([]mcpserver.ManagedFeedInfo, error) {
        ds.dynamicMutex.RLock()
        defer ds.dynamicMutex.RUnlock()

        feeds := make([]mcpserver.ManagedFeedInfo, 0, len(ds.feeds))

        for feedID, url := range ds.feeds {
                metadata := ds.feedMetadata[feedID]
                if metadata == nil {
                        // Fallback metadata for missing entries
                        metadata = &DynamicFeedMetadata{
                                AddedAt: time.Now(),
                                Source:  mcpserver.FeedSourceStartup,
                                Status:  "active",
                        }
                }

                // Get current item count and update status
                cacheInfo := ds.checkFeedCache(ctx, url)
                itemCount := cacheInfo.ItemCount
                var status string
                var lastError string
                var lastFetched time.Time

                if cacheInfo.Found {
                        status = cacheInfo.Status
                        lastError = ""
                        lastFetched = cacheInfo.LastFetched
                } else {
                        status = cacheInfo.Status
                        lastError = cacheInfo.LastError
                        lastFetched = metadata.LastFetched // Keep original if cache fetch failed
                }

                feeds = append(feeds, mcpserver.ManagedFeedInfo{
                        FeedID:      feedID,
                        URL:         url,
                        Title:       metadata.Title,
                        Category:    metadata.Category,
                        Description: metadata.Description,
                        Status:      status,
                        LastFetched: lastFetched,
                        LastError:   lastError,
                        ItemCount:   itemCount,
                        AddedAt:     metadata.AddedAt,
                        Source:      string(metadata.Source),
                })
        }

        return feeds, nil
}

// RefreshFeed implements DynamicFeedManager.RefreshFeed
func (ds *DynamicStore) RefreshFeed(ctx context.Context, feedID string) (*mcpserver.RefreshFeedInfo, error) {
        ds.dynamicMutex.RLock()
        url, exists := ds.feeds[feedID]
        ds.dynamicMutex.RUnlock()

        if !exists {
                return &mcpserver.RefreshFeedInfo{
                        FeedID: feedID,
                        Status: "not_found",
                }, nil
        }

        // Clear from cache to force refresh
        _ = ds.feedCacheManager.Delete(ctx, url) // Cache deletion errors are not critical

        // Get fresh content
        feed, err := ds.feedCacheManager.Get(ctx, url)

        refreshInfo := &mcpserver.RefreshFeedInfo{
                FeedID:      feedID,
                LastFetched: time.Now(),
        }

        if err != nil {
                refreshInfo.Status = "error"
                refreshInfo.Error = err.Error()

                // Update metadata
                ds.dynamicMutex.Lock()
                if metadata := ds.feedMetadata[feedID]; metadata != nil {
                        metadata.Status = statusError
                        metadata.LastError = err.Error()
                }
                ds.dynamicMutex.Unlock()
        } else {
                refreshInfo.Status = "refreshed"
                refreshInfo.ItemsAdded = len(feed.Items)

                // Update metadata
                ds.dynamicMutex.Lock()
                if metadata := ds.feedMetadata[feedID]; metadata != nil {
                        metadata.Status = statusActive
                        metadata.LastError = ""
                        metadata.LastFetched = time.Now()
                        if metadata.Title == "" {
                                metadata.Title = feed.Title
                        }
                }
                ds.dynamicMutex.Unlock()
        }

        return refreshInfo, nil
}

// UpdateFeedMetadata implements DynamicFeedManager.UpdateFeedMetadata
func (ds *DynamicStore) UpdateFeedMetadata(ctx context.Context, feedID string, metadata mcpserver.FeedMetadata) error {
        ds.dynamicMutex.Lock()
        defer ds.dynamicMutex.Unlock()

        feedMeta := ds.feedMetadata[feedID]
        if feedMeta == nil {
                return model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("feed with ID %s not found", feedID)).
                        WithOperation("update_feed_metadata").
                        WithComponent("dynamic_store")
        }

        // Update metadata fields
        if metadata.Title != "" {
                feedMeta.Title = metadata.Title
        }
        if metadata.Category != "" {
                feedMeta.Category = metadata.Category
        }
        if metadata.Description != "" {
                feedMeta.Description = metadata.Description
        }

        return nil
}

// PauseFeed implements DynamicFeedManager.PauseFeed
func (ds *DynamicStore) PauseFeed(ctx context.Context, feedID string) error {
        ds.dynamicMutex.Lock()
        defer ds.dynamicMutex.Unlock()

        metadata := ds.feedMetadata[feedID]
        if metadata == nil {
                return model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("feed with ID %s not found", feedID)).
                        WithOperation("pause_feed").
                        WithComponent("dynamic_store")
        }

        metadata.Status = "paused"
        return nil
}

// ResumeFeed implements DynamicFeedManager.ResumeFeed
func (ds *DynamicStore) ResumeFeed(ctx context.Context, feedID string) error {
        ds.dynamicMutex.Lock()
        defer ds.dynamicMutex.Unlock()

        metadata := ds.feedMetadata[feedID]
        if metadata == nil {
                return model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("feed with ID %s not found", feedID)).
                        WithOperation("resume_feed").
                        WithComponent("dynamic_store")
        }

        metadata.Status = statusActive
        return nil
}

// Package store implements feed management with caching, circuit breaking, and retry logic.
package store

import (
        "context"
        "errors"
        "fmt"
        "math"
        "math/rand"
        "net"
        "net/http"
        "strings"
        "sync"
        "time"

        "github.com/dgraph-io/ristretto/v2"
        "github.com/eko/gocache/lib/v4/cache"
        "github.com/eko/gocache/lib/v4/store"
        ristretto_store "github.com/eko/gocache/store/ristretto/v4"
        "github.com/mmcdole/gofeed"
        "github.com/sony/gobreaker"
        "golang.org/x/time/rate"

        "github.com/richardwooding/feed-mcp/model"
)

// HTTPPoolConfig holds HTTP connection pool configuration
type HTTPPoolConfig struct {
        MaxIdleConns        int
        MaxConnsPerHost     int
        MaxIdleConnsPerHost int
        IdleConnTimeout     time.Duration
}

// Config holds configuration settings for the feed store
type Config struct {
        HTTPClient                     *http.Client
        CircuitBreakerEnabled          *bool
        Feeds                          []string
        CircuitBreakerInterval         time.Duration
        RetryBaseDelay                 time.Duration
        BurstCapacity                  int
        ExpireAfter                    time.Duration
        RequestsPerSecond              float64
        Timeout                        time.Duration
        CircuitBreakerTimeout          time.Duration
        RetryMaxDelay                  time.Duration
        MaxIdleConns                   int
        MaxConnsPerHost                int
        MaxIdleConnsPerHost            int
        IdleConnTimeout                time.Duration
        RetryMaxAttempts               int
        CircuitBreakerMaxRequests      uint32
        CircuitBreakerFailureThreshold uint32
        RetryJitter                    bool
        OPML                           string // OPML file path for metadata source detection
        AllowPrivateIPs                bool   // Allow private IP addresses in URLs
        AllowEmptyFeeds                bool   // Allow creating store with no initial feeds (used by DynamicStore)
}

// RetryMetrics holds metrics for retry operations
type RetryMetrics struct {
        TotalAttempts    int64   // Total number of HTTP attempts made
        TotalRetries     int64   // Total number of retries (excluding initial attempts)
        SuccessfulFeeds  int64   // Number of feeds successfully fetched
        FailedFeeds      int64   // Number of feeds that failed after all retries
        RetrySuccessRate float64 // Percentage of feeds that succeeded after retrying
}

// Store manages feed fetching, caching, and retrieval with retry logic
type Store struct {
        feeds            map[string]string
        feedCacheManager *cache.LoadableCache[*gofeed.Feed]
        circuitBreakers  map[string]*gobreaker.CircuitBreaker
        retryMetrics     *RetryMetrics
        metricsMutex     sync.RWMutex
}

// RateLimitedTransport wraps an http.RoundTripper with rate limiting
type RateLimitedTransport struct {
        transport   http.RoundTripper
        rateLimiter *rate.Limiter
}

// RoundTrip implements the http.RoundTripper interface with rate limiting
func (r *RateLimitedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
        // Wait for rate limiter permission
        err := r.rateLimiter.Wait(req.Context())
        if err != nil {
                return nil, err
        }

        // Proceed with the actual request
        return r.transport.RoundTrip(req)
}

// NewRateLimitedHTTPClient creates an HTTP client with rate limiting and connection pooling
func NewRateLimitedHTTPClient(requestsPerSecond float64, burstCapacity int, poolConfig HTTPPoolConfig) *http.Client {
        limiter := rate.NewLimiter(rate.Limit(requestsPerSecond), burstCapacity)

        // Create a custom transport with connection pooling settings
        baseTransport := &http.Transport{
                MaxIdleConns:        poolConfig.MaxIdleConns,
                MaxConnsPerHost:     poolConfig.MaxConnsPerHost,
                MaxIdleConnsPerHost: poolConfig.MaxIdleConnsPerHost,
                IdleConnTimeout:     poolConfig.IdleConnTimeout,
                // Copy other default settings from http.DefaultTransport
                Proxy: http.ProxyFromEnvironment,
                DialContext: (&net.Dialer{
                        Timeout:   30 * time.Second,
                        KeepAlive: 30 * time.Second,
                }).DialContext,
                ForceAttemptHTTP2:     true,
                TLSHandshakeTimeout:   10 * time.Second,
                ExpectContinueTimeout: 1 * time.Second,
        }

        transport := &RateLimitedTransport{
                transport:   baseTransport,
                rateLimiter: limiter,
        }

        return &http.Client{
                Transport: transport,
                Timeout:   30 * time.Second, // Default timeout
        }
}

// isRetryableError determines if an error should trigger a retry attempt.
// Returns true for network errors (DNS, connection, timeout) and 5xx HTTP status codes.
// Returns false for context cancellation, 4xx client errors, and other non-transient failures.
func isRetryableError(err error) bool {
        if err == nil {
                return false
        }

        errStr := err.Error()

        // Context cancellation and timeout errors are not retryable
        if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
                return false
        }

        // DNS and network errors are retryable
        if strings.Contains(errStr, "no such host") ||
                strings.Contains(errStr, "connection refused") ||
                strings.Contains(errStr, "connection reset") ||
                strings.Contains(errStr, "network unreachable") ||
                strings.Contains(errStr, "timeout") ||
                strings.Contains(errStr, "i/o timeout") {
                return true
        }

        // HTTP status errors (gofeed uses "http error: XXX" format)
        if strings.Contains(errStr, "http error: 5") || strings.Contains(errStr, "status code 5") {
                return true // 5xx server errors are retryable
        }

        if strings.Contains(errStr, "http error: 4") || strings.Contains(errStr, "status code 4") {
                return false // 4xx client errors are not retryable
        }

        // Default to retryable for unknown network-related errors
        return true
}

// calculateRetryDelay calculates the delay for the next retry using exponential backoff.
// Uses formula: baseDelay * 2^(attempt-1), capped at maxDelay.
// Applies jitter (±50% random variance) when useJitter is true to prevent thundering herd.
func calculateRetryDelay(attempt int, baseDelay, maxDelay time.Duration, useJitter bool) time.Duration {
        if attempt <= 0 {
                return baseDelay
        }

        // Exponential backoff: baseDelay * 2^(attempt-1)
        delay := time.Duration(float64(baseDelay) * math.Pow(2, float64(attempt-1)))

        // Cap at maxDelay
        if delay > maxDelay {
                delay = maxDelay
        }

        // Add jitter to avoid thundering herd
        if useJitter && delay > 0 {
                jitterRange := delay / 2
                var jitter time.Duration
                if jitterRange > 0 {
                        jitter = time.Duration(rand.Int63n(int64(jitterRange)))
                } else {
                        jitter = 0
                }
                delay = delay - jitterRange/2 + jitter
                // Ensure delay is never negative
                if delay < 0 {
                        delay = 0
                }
        }

        return delay
}

// retryableFeedFetch performs feed fetching with retry logic and comprehensive metrics tracking.
// Attempts up to maxAttempts times for retryable errors, with exponential backoff delays.
// Updates retry metrics and integrates with circuit breaker patterns for fault tolerance.
//
//nolint:gocognit,gocyclo,gocritic // Function complexity is necessary for comprehensive retry logic with metrics and error handling
func retryableFeedFetch(ctx context.Context, url string, parser *gofeed.Parser, config Config, metrics *RetryMetrics, metricsMutex *sync.RWMutex) (*gofeed.Feed, error) {
        var lastErr error
        maxAttempts := config.RetryMaxAttempts
        if maxAttempts <= 0 {
                maxAttempts = 1 // At least one attempt
        }

        attemptCount := 0

        for attempt := 1; attempt <= maxAttempts; attempt++ {
                attemptCount++

                // Track total attempts
                if metrics != nil && metricsMutex != nil {
                        metricsMutex.Lock()
                        metrics.TotalAttempts++
                        if attempt > 1 {
                                metrics.TotalRetries++
                        }
                        metricsMutex.Unlock()
                }

                // Create timeout context for this attempt
                attemptCtx, cancel := context.WithTimeout(ctx, config.Timeout)

                feed, err := parser.ParseURLWithContext(url, attemptCtx)
                cancel()

                // Success case
                if err == nil {
                        // Track successful feed
                        if metrics != nil && metricsMutex != nil {
                                metricsMutex.Lock()
                                metrics.SuccessfulFeeds++
                                // Update success rate
                                totalFeeds := metrics.SuccessfulFeeds + metrics.FailedFeeds
                                if totalFeeds > 0 {
                                        metrics.RetrySuccessRate = float64(metrics.SuccessfulFeeds) / float64(totalFeeds) * 100
                                }
                                metricsMutex.Unlock()
                        }

                        // Debug log successful fetch
                        extra := map[string]interface{}{
                                "items_count": len(feed.Items),
                        }
                        msg := "Successfully fetched feed"
                        if attempt > 1 {
                                extra["attempt"] = attempt
                                extra["max_attempts"] = maxAttempts
                                msg = fmt.Sprintf("Successfully fetched feed after %d attempts", attempt)
                        }
                        model.DebugLogWithContext(
                                msg,
                                "feed_fetcher", "retryable_fetch", url,
                                extra,
                        )

                        return feed, nil
                }

                lastErr = err

                // Debug log the error
                model.DebugLogWithContext(
                        fmt.Sprintf("Feed fetch attempt %d failed", attempt),
                        "feed_fetcher", "retryable_fetch", url,
                        map[string]interface{}{
                                "attempt":      attempt,
                                "max_attempts": maxAttempts,
                                "error":        err.Error(),
                                "retryable":    isRetryableError(err),
                        },
                )

                // Don't retry on the last attempt or non-retryable errors
                if attempt >= maxAttempts || !isRetryableError(err) {
                        if !isRetryableError(err) {
                                model.DebugLogWithContext(
                                        "Error is not retryable, stopping retry attempts",
                                        "feed_fetcher", "retryable_fetch", url,
                                        map[string]interface{}{
                                                "attempt": attempt,
                                                "error":   err.Error(),
                                        },
                                )
                        }
                        break
                }

                // Calculate delay and sleep before next attempt
                delay := calculateRetryDelay(attempt, config.RetryBaseDelay, config.RetryMaxDelay, config.RetryJitter)

                model.DebugLogWithContext(
                        fmt.Sprintf("Retrying in %v", delay),
                        "feed_fetcher", "retryable_fetch", url,
                        map[string]interface{}{
                                "attempt":      attempt,
                                "next_attempt": attempt + 1,
                                "delay_ms":     delay.Milliseconds(),
                        },
                )

                select {
                case <-ctx.Done():
                        return nil, ctx.Err()
                case <-time.After(delay):
                        // Continue to next attempt
                }
        }

        // Track failed feed
        if metrics != nil && metricsMutex != nil {
                metricsMutex.Lock()
                metrics.FailedFeeds++
                // Update success rate
                totalFeeds := metrics.SuccessfulFeeds + metrics.FailedFeeds
                if totalFeeds > 0 {
                        metrics.RetrySuccessRate = float64(metrics.SuccessfulFeeds) / float64(totalFeeds) * 100
                }
                metricsMutex.Unlock()
        }

        // Create a comprehensive error with retry context
        return nil, model.CreateRetryError(lastErr, url, attemptCount, maxAttempts)
}

// NewStore creates a new feed store with the given configuration.
// Uses pointer to avoid copying large Config struct (192 bytes).
func NewStore(config *Config) (*Store, error) {
        if len(config.Feeds) == 0 && !config.AllowEmptyFeeds {
                return nil, model.NewFeedError(model.ErrorTypeConfiguration, "at least one feed must be specified").
                        WithOperation("create_store").
                        WithComponent("store_manager")
        }

        return newStoreInternal(*config)
}

// newStoreInternal contains the core store initialization logic
//
//nolint:gocognit,gocyclo,gocritic // Function complexity is necessary for comprehensive store initialization with caching, circuit breakers, and connection pooling
func newStoreInternal(config Config) (*Store, error) {
        if config.Timeout == 0 {
                config.Timeout = 30 * time.Second
        }

        if config.ExpireAfter == 0 {
                config.ExpireAfter = 1 * time.Hour
        }

        // Set default rate limiting values
        if config.RequestsPerSecond <= 0 {
                config.RequestsPerSecond = 2.0 // 2 requests per second by default
        }

        if config.BurstCapacity <= 0 {
                config.BurstCapacity = 5 // Allow burst of 5 requests by default
        }

        // Set default circuit breaker values - enabled by default
        if config.CircuitBreakerMaxRequests <= 0 {
                config.CircuitBreakerMaxRequests = 3 // Allow 3 half-open requests
        }
        if config.CircuitBreakerInterval <= 0 {
                config.CircuitBreakerInterval = 60 * time.Second // Check for recovery every 60s
        }
        if config.CircuitBreakerTimeout <= 0 {
                config.CircuitBreakerTimeout = 30 * time.Second // Open circuit for 30s before trying half-open
        }
        if config.CircuitBreakerFailureThreshold <= 0 {
                config.CircuitBreakerFailureThreshold = 3 // Open circuit after 3 consecutive failures
        }

        // Set default HTTP connection pool values
        if config.MaxIdleConns <= 0 {
                config.MaxIdleConns = 100 // Default to 100 idle connections total
        }
        if config.MaxConnsPerHost <= 0 {
                config.MaxConnsPerHost = 10 // Default to 10 connections per host
        }
        if config.MaxIdleConnsPerHost <= 0 {
                config.MaxIdleConnsPerHost = 5 // Default to 5 idle connections per host
        }
        if config.IdleConnTimeout <= 0 {
                config.IdleConnTimeout = 90 * time.Second // Default to 90 seconds idle timeout
        }

        // Set default retry values
        if config.RetryMaxAttempts <= 0 {
                config.RetryMaxAttempts = 3 // Default to 3 retry attempts
        }
        if config.RetryBaseDelay <= 0 {
                config.RetryBaseDelay = 1 * time.Second // Default to 1 second base delay
        }
        if config.RetryMaxDelay <= 0 {
                config.RetryMaxDelay = 30 * time.Second // Default to 30 seconds max delay
        }
        // RetryJitter defaults to true (handled by CLI flag default: "true")

        // Create rate-limited HTTP client with connection pooling if not provided
        if config.HTTPClient == nil {
                poolConfig := HTTPPoolConfig{
                        MaxIdleConns:        config.MaxIdleConns,
                        MaxConnsPerHost:     config.MaxConnsPerHost,
                        MaxIdleConnsPerHost: config.MaxIdleConnsPerHost,
                        IdleConnTimeout:     config.IdleConnTimeout,
                }
                config.HTTPClient = NewRateLimitedHTTPClient(config.RequestsPerSecond, config.BurstCapacity, poolConfig)
        }

        ristrettoCache, err := ristretto.NewCache[string, *gofeed.Feed](&ristretto.Config[string, *gofeed.Feed]{
                NumCounters: 1000,
                MaxCost:     100,
                BufferItems: 64,
        })
        if err != nil {
                return nil, err
        }

        ristrettoStore := ristretto_store.NewRistretto(ristrettoCache)

        // Initialize circuit breakers map - enabled by default unless explicitly disabled
        var circuitBreakers map[string]*gobreaker.CircuitBreaker
        circuitBreakerEnabled := config.CircuitBreakerEnabled == nil || *config.CircuitBreakerEnabled

        if circuitBreakerEnabled {
                circuitBreakers = make(map[string]*gobreaker.CircuitBreaker)
                for _, feedURL := range config.Feeds {
                        settings := gobreaker.Settings{
                                Name:        fmt.Sprintf("feed-%s", feedURL),
                                MaxRequests: config.CircuitBreakerMaxRequests,
                                Interval:    config.CircuitBreakerInterval,
                                Timeout:     config.CircuitBreakerTimeout,
                                ReadyToTrip: func(counts gobreaker.Counts) bool {
                                        return counts.ConsecutiveFailures >= config.CircuitBreakerFailureThreshold
                                },
                        }
                        circuitBreakers[feedURL] = gobreaker.NewCircuitBreaker(settings)
                }
        }

        // Create the store first
        s := &Store{
                feeds:           make(map[string]string, len(config.Feeds)),
                circuitBreakers: circuitBreakers,
                retryMetrics:    &RetryMetrics{},
                metricsMutex:    sync.RWMutex{},
        }

        loadFunction := func(ctx context.Context, key any) (*gofeed.Feed, []store.Option, error) {
                if url, ok := key.(string); ok {
                        // Create parser with HTTP client
                        fp := gofeed.NewParser()
                        if config.HTTPClient != nil {
                                fp.Client = config.HTTPClient
                        }

                        // Use circuit breaker if enabled
                        if circuitBreakerEnabled {
                                if cb, exists := circuitBreakers[url]; exists {
                                        result, err := cb.Execute(func() (interface{}, error) {
                                                return retryableFeedFetch(ctx, url, fp, config, s.retryMetrics, &s.metricsMutex)
                                        })
                                        if err != nil {
                                                // Check if this is a circuit breaker error
                                                if errors.Is(err, gobreaker.ErrOpenState) {
                                                        return nil, nil, model.CreateCircuitBreakerError(url, "open")
                                                }
                                                if errors.Is(err, gobreaker.ErrTooManyRequests) {
                                                        return nil, nil, model.CreateCircuitBreakerError(url, "half-open")
                                                }
                                                // Return the original error (likely from retryableFeedFetch)
                                                return nil, nil, err
                                        }
                                        if feed, ok := result.(*gofeed.Feed); ok {
                                                return feed, []store.Option{store.WithExpiration(config.ExpireAfter)}, nil
                                        }
                                        return nil, nil, model.NewFeedError(model.ErrorTypeSystem, "unexpected result type from circuit breaker").
                                                WithURL(url).
                                                WithOperation("load_feed").
                                                WithComponent("circuit_breaker")
                                }
                        }

                        // Fallback to direct retryable parsing if circuit breaker not enabled or URL not found
                        feed, err := retryableFeedFetch(ctx, url, fp, config, s.retryMetrics, &s.metricsMutex)
                        if err != nil {
                                return nil, nil, err
                        }
                        return feed, []store.Option{store.WithExpiration(config.ExpireAfter)}, nil
                } else {
                        return nil, nil, model.NewFeedError(model.ErrorTypeSystem, "invalid key type for cache loader").
                                WithOperation("load_feed").
                                WithComponent("cache_manager")
                }
        }

        cacheManager := cache.NewLoadable[*gofeed.Feed](
                loadFunction,
                cache.New[*gofeed.Feed](ristrettoStore),
        )
        s.feedCacheManager = cacheManager

        feeds := make(map[string]string, len(config.Feeds))
        var feedsMutex sync.Mutex
        wg := sync.WaitGroup{}
        for _, feedURL := range config.Feeds {
                wg.Add(1)
                go func(url string) {
                        defer wg.Done()
                        id := model.GenerateFeedID(url)
                        feedsMutex.Lock()
                        feeds[id] = url
                        feedsMutex.Unlock()
                        _, _ = cacheManager.Get(context.Background(), url)
                }(feedURL)
        }
        wg.Wait()

        s.feeds = feeds
        return s, nil
}

// GetAllFeeds returns all configured feeds with their current status
func (s *Store) GetAllFeeds(ctx context.Context) ([]*model.FeedResult, error) {
        results := make([]*model.FeedResult, len(s.feeds))
        wg := &sync.WaitGroup{}
        idx := 0
        for id, url := range s.feeds {
                wg.Add(1)
                go func(idx int, id string, url string) {
                        defer wg.Done()
                        feed, err := s.feedCacheManager.Get(ctx, url)

                        result := &model.FeedResult{
                                ID:        id,
                                PublicURL: url,
                        }

                        // Check circuit breaker state
                        if s.circuitBreakers != nil {
                                if cb, exists := s.circuitBreakers[url]; exists {
                                        result.CircuitBreakerOpen = cb.State() == gobreaker.StateOpen
                                }
                        }

                        if err != nil {
                                result.FetchError = err.Error()
                        } else {
                                result.Title = feed.Title
                                result.Feed = model.FromGoFeed(feed)
                        }

                        results[idx] = result
                }(idx, id, url)
                idx++
        }
        wg.Wait()
        return results, nil
}

// GetFeedAndItems returns a specific feed with all its items
func (s *Store) GetFeedAndItems(ctx context.Context, id string) (*model.FeedAndItemsResult, error) {
        if url, exists := s.feeds[id]; exists {
                feed, err := s.feedCacheManager.Get(ctx, url)

                result := &model.FeedAndItemsResult{
                        ID:        id,
                        PublicURL: url,
                }

                // Check circuit breaker state
                if s.circuitBreakers != nil {
                        if cb, exists := s.circuitBreakers[url]; exists {
                                result.CircuitBreakerOpen = cb.State() == gobreaker.StateOpen
                        }
                }

                if err != nil {
                        result.FetchError = err.Error()
                        return result, nil
                }

                result.Title = feed.Title
                result.Feed = model.FromGoFeed(feed)
                result.Items = feed.Items

                return result, nil
        }
        return nil, model.NewFeedError(model.ErrorTypeValidation, fmt.Sprintf("feed with ID %s not found", id)).
                WithOperation("get_feed_and_items").
                WithComponent("feed_store")
}

// GetRetryMetrics returns a copy of the current retry metrics
func (s *Store) GetRetryMetrics() RetryMetrics {
        s.metricsMutex.RLock()
        defer s.metricsMutex.RUnlock()
        return *s.retryMetrics
}

// Package version provides version information for the feed-mcp server.
package version

import (
        "runtime"
        "runtime/debug"
        "strings"
)

// Constants for repeated string values
const (
        unknownValue = "unknown"
        devVersion   = "dev"
)

// These variables can be set at build time using -ldflags
var (
        // Version is the version of the binary, set at build time
        Version = "dev"
        // GitCommit is the git commit hash, set at build time
        GitCommit = unknownValue
        // BuildDate is the build date, set at build time
        BuildDate = unknownValue
)

// Info contains version information
type Info struct {
        Version   string
        GitCommit string
        BuildDate string
        GoVersion string
}

// Get returns version information
func Get() Info {
        info := Info{
                Version:   Version,
                GitCommit: GitCommit,
                BuildDate: BuildDate,
                GoVersion: runtime.Version(),
        }

        // Try to get version from build info if not set at build time
        if info.Version == devVersion {
                updateBuildInfo(&info)
        }

        // Clean version string (remove 'v' prefix if present)
        info.Version = strings.TrimPrefix(info.Version, "v")

        return info
}

// updateBuildInfo updates version info from build metadata
func updateBuildInfo(info *Info) {
        buildInfo, ok := debug.ReadBuildInfo()
        if !ok {
                return
        }

        // Look for version in VCS info
        for _, setting := range buildInfo.Settings {
                switch setting.Key {
                case "vcs.revision":
                        updateGitCommit(info, setting.Value)
                case "vcs.time":
                        updateBuildDate(info, setting.Value)
                }
        }
}

// updateGitCommit updates git commit if not already set
func updateGitCommit(info *Info, value string) {
        if info.GitCommit != unknownValue {
                return
        }
        // Use short commit hash
        if len(value) > 7 {
                info.GitCommit = value[:7]
        } else {
                info.GitCommit = value
        }
}

// updateBuildDate updates build date if not already set
func updateBuildDate(info *Info, value string) {
        if info.BuildDate == unknownValue {
                info.BuildDate = value
        }
}

// GetVersion returns just the version string
func GetVersion() string {
        return Get().Version
}

// GetFullVersion returns a full version string with commit info
func GetFullVersion() string {
        info := Get()
        if info.GitCommit != unknownValue {
                return info.Version + "-" + info.GitCommit
        }
        return info.Version
}