main.go

package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"os"
	"sort"
	"sync"
	"time"

	"github.com/ejholmes/kiterss/internal/config"
	"github.com/mmcdole/gofeed"
	"github.com/spf13/cobra"
	_ "modernc.org/sqlite"
)

// Version is set at build time via ldflags.
var Version = "dev"

type Item struct {
	ID          string    `json:"id"`
	Title       string    `json:"title"`
	Link        string    `json:"link"`
	Date        string    `json:"date"`
	DateParsed  time.Time `json:"-"` // Used for sorting, not serialized
	Description string    `json:"description,omitempty"`
	Content     string    `json:"content,omitempty"`
	Source      string    `json:"source"`
}

// FeedFetcher abstracts feed fetching for testability.
type FeedFetcher interface {
	Fetch(url string) (*gofeed.Feed, error)
}

// HTTPFeedFetcher fetches feeds over HTTP.
type HTTPFeedFetcher struct {
	parser *gofeed.Parser
}

func NewHTTPFeedFetcher() *HTTPFeedFetcher {
	return &HTTPFeedFetcher{parser: gofeed.NewParser()}
}

func (f *HTTPFeedFetcher) Fetch(url string) (*gofeed.Feed, error) {
	return f.parser.ParseURL(url)
}

// KiteRSS holds dependencies for the application.
type KiteRSS struct {
	DB      *sql.DB
	Fetcher FeedFetcher
	Out     io.Writer
	ErrOut  io.Writer
}

func main() {
	if err := config.EnsureDirs(); err != nil {
		log.Fatal(err)
	}

	configPath, err := config.ConfigPath()
	if err != nil {
		log.Fatal(err)
	}

	dbPath, err := config.DBPath()
	if err != nil {
		log.Fatal(err)
	}

	db, err := sql.Open("sqlite", dbPath)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	if _, err := db.Exec("CREATE TABLE IF NOT EXISTS read_items (id TEXT PRIMARY KEY)"); err != nil {
		log.Fatal(err)
	}

	app := &KiteRSS{
		DB:      db,
		Fetcher: NewHTTPFeedFetcher(),
		Out:     os.Stdout,
		ErrOut:  os.Stderr,
	}

	rootCmd := &cobra.Command{
		Use:   "kiterss",
		Short: "A simple CLI RSS reader",
	}

	listCmd := &cobra.Command{
		Use:   "list",
		Short: "List unread items",
		Run: func(cmd *cobra.Command, args []string) {
			app.List(configPath)
		},
	}

	readCmd := &cobra.Command{
		Use:   "read <id>...",
		Short: "Mark items as read",
		Args:  cobra.MinimumNArgs(1),
		Run: func(cmd *cobra.Command, args []string) {
			if err := app.MarkRead(args); err != nil {
				log.Fatal(err)
			}
			fmt.Fprintf(app.Out, "Marked %d items as read.\n", len(args))
		},
	}

	versionCmd := &cobra.Command{
		Use:   "version",
		Short: "Print the version",
		Run: func(cmd *cobra.Command, args []string) {
			fmt.Println(Version)
		},
	}

	rootCmd.AddCommand(listCmd, readCmd, versionCmd)

	if err := rootCmd.Execute(); err != nil {
		os.Exit(1)
	}
}

// List fetches all feeds and returns unread items.
func (k *KiteRSS) List(configPath string) {
	cfg, err := config.Parse(configPath)
	if err != nil {
		log.Fatal(err)
	}
	items := k.ListItems(cfg.URLs)
	enc := json.NewEncoder(k.Out)
	enc.SetIndent("", "  ")
	enc.Encode(items)
}

// ListItems fetches feeds from the given URLs and returns unread items.
func (k *KiteRSS) ListItems(urls []string) []Item {
	allItems := []Item{}
	var mu sync.Mutex
	var wg sync.WaitGroup

	for _, url := range urls {
		wg.Add(1)
		go func(url string) {
			defer wg.Done()
			feed, err := k.Fetcher.Fetch(url)
			if err != nil {
				fmt.Fprintf(k.ErrOut, "Error parsing %s: %v\n", url, err)
				return
			}
			for _, item := range feed.Items {
				id := item.GUID
				if id == "" {
					id = item.Link
				}
				if !k.isRead(id) {
					var dateParsed time.Time
					if item.PublishedParsed != nil {
						dateParsed = *item.PublishedParsed
					}
					mu.Lock()
					allItems = append(allItems, Item{
						ID:         id,
						Title:      item.Title,
						Link:       item.Link,
						Date:       item.Published,
						DateParsed: dateParsed,
						Source:     url,
					})
					mu.Unlock()
				}
			}
		}(url)
	}
	wg.Wait()

	// Sort by date, newest first
	sort.Slice(allItems, func(i, j int) bool {
		return allItems[i].DateParsed.After(allItems[j].DateParsed)
	})

	return allItems
}

func (k *KiteRSS) isRead(id string) bool {
	var exists bool
	_ = k.DB.QueryRow("SELECT EXISTS(SELECT 1 FROM read_items WHERE id = ?)", id).Scan(&exists)
	return exists
}

// MarkRead marks the given IDs as read in the database.
func (k *KiteRSS) MarkRead(ids []string) error {
	stmt, err := k.DB.Prepare("INSERT OR IGNORE INTO read_items (id) VALUES (?)")
	if err != nil {
		return err
	}
	defer stmt.Close()

	for _, id := range ids {
		if _, err := stmt.Exec(id); err != nil {
			return err
		}
	}
	return nil
}