package main

import (

	"container/list"

	"context"

	"net/http"

	"sync"

	"time"

	"golang.org/x/sync/singleflight"

)

// feedCache is an LRU + TTL cache of fetched feed results, keyed by feed URL.

// It keeps crawler-triggered requests (page + OG image) fast after the first

// fetch warms the entry. A singleflight group collapses concurrent misses for

// the same URL into a single upstream fetch, and the bounded LRU keeps the

// entry set from growing without limit under a stream of distinct URLs.

type feedCache struct {

	mu      sync.Mutex

	ttl     time.Duration

	max     int

	ll      *list.List // front = most recently used

	entries map[string]*list.Element

	sf      singleflight.Group

}

type feedCacheEntry struct {

	key     string

	res     *FetchResult

	etag    string

	lm      string

	expires time.Time

}

func newFeedCache(ttl time.Duration, max int) *feedCache {

	return &feedCache{

		ttl:     ttl,

		max:     max,

		ll:      list.New(),

		entries: map[string]*list.Element{},

	}

}

// fetch returns a cached result when fresh, otherwise fetches and stores it.

// Concurrent misses for the same URL share one fetch via singleflight.

func (c *feedCache) fetch(ctx context.Context, feedURL string) (*FetchResult, error) {

	if res, ok := c.lookup(feedURL); ok {

		return res, nil

	}

	v, err, _ := c.sf.Do(feedURL, func() (any, error) {

		// Another goroutine may have filled the entry while we queued.

		if res, ok := c.lookup(feedURL); ok {

			return res, nil

		}

		// Reuse any stored validators so an unchanged feed comes back as a

		// cheap 304 instead of a full download + parse.

		etag, lm, prev := c.validators(feedURL)

		res, err := fetchFeed(ctx, feedURL, etag, lm)

		if err != nil {

			return nil, err

		}

		if res.Status == http.StatusNotModified && prev != nil {

			res = prev

		}

		c.store(feedURL, res)

		return res, nil

	})

	if err != nil {

		return nil, err

	}

	return v.(*FetchResult), nil

}

// lookup returns a fresh (unexpired) cached result and marks it recently used.

func (c *feedCache) lookup(feedURL string) (*FetchResult, bool) {

	c.mu.Lock()

	defer c.mu.Unlock()

	el, ok := c.entries[feedURL]

	if !ok {

		return nil, false

	}

	e := el.Value.(*feedCacheEntry)

	if time.Now().After(e.expires) {

		return nil, false

	}

	c.ll.MoveToFront(el)

	return e.res, true

}

// validators returns stored conditional-GET headers and the last parsed result

// for a URL, even when the entry has expired, so a refetch can revalidate.

func (c *feedCache) validators(feedURL string) (etag, lm string, prev *FetchResult) {

	c.mu.Lock()

	defer c.mu.Unlock()

	if el, ok := c.entries[feedURL]; ok {

		e := el.Value.(*feedCacheEntry)

		return e.etag, e.lm, e.res

	}

	return "", "", nil

}

func (c *feedCache) store(feedURL string, res *FetchResult) {

	c.mu.Lock()

	defer c.mu.Unlock()

	expires := time.Now().Add(c.ttl)

	if el, ok := c.entries[feedURL]; ok {

		e := el.Value.(*feedCacheEntry)

		e.res, e.etag, e.lm, e.expires = res, res.ETag, res.LastModified, expires

		c.ll.MoveToFront(el)

		return

	}

	el := c.ll.PushFront(&feedCacheEntry{

		key:     feedURL,

		res:     res,

		etag:    res.ETag,

		lm:      res.LastModified,

		expires: expires,

	})

	c.entries[feedURL] = el

	for c.ll.Len() > c.max {

		oldest := c.ll.Back()

		if oldest == nil {

			break

		}

		c.ll.Remove(oldest)

		delete(c.entries, oldest.Value.(*feedCacheEntry).key)

	}

}

// imageCache is an LRU + TTL cache of rendered PNG bytes, keyed by the shared

// URL set. It bounds memory (max entries) and lets repeated shares of the same

// link skip the CPU/allocation cost of re-rendering.

type imageCache struct {

	mu      sync.Mutex

	ttl     time.Duration

	max     int

	ll      *list.List // front = most recently used

	entries map[string]*list.Element

	sf      singleflight.Group

}

type imageEntry struct {

	key     string

	png     []byte

	expires time.Time

}

func newImageCache(ttl time.Duration, max int) *imageCache {

	return &imageCache{

		ttl:     ttl,

		max:     max,

		ll:      list.New(),

		entries: map[string]*list.Element{},

	}

}

func (c *imageCache) get(key string) ([]byte, bool) {

	c.mu.Lock()

	defer c.mu.Unlock()

	el, ok := c.entries[key]

	if !ok {

		return nil, false

	}

	ent := el.Value.(*imageEntry)

	if time.Now().After(ent.expires) {

		c.ll.Remove(el)

		delete(c.entries, key)

		return nil, false

	}

	c.ll.MoveToFront(el)

	return ent.png, true

}

// getOrRender returns a cached PNG or renders one via render, collapsing

// concurrent requests for the same key into a single render so duplicate

// crawler hits don't each pay the CPU/allocation cost.

func (c *imageCache) getOrRender(key string, render func() ([]byte, error)) ([]byte, error) {

	if png, ok := c.get(key); ok {

		return png, nil

	}

	v, err, _ := c.sf.Do(key, func() (any, error) {

		if png, ok := c.get(key); ok {

			return png, nil

		}

		png, err := render()

		if err != nil {

			return nil, err

		}

		c.set(key, png)

		return png, nil

	})

	if err != nil {

		return nil, err

	}

	return v.([]byte), nil

}

func (c *imageCache) set(key string, png []byte) {

	c.mu.Lock()

	defer c.mu.Unlock()

	if el, ok := c.entries[key]; ok {

		ent := el.Value.(*imageEntry)

		ent.png = png

		ent.expires = time.Now().Add(c.ttl)

		c.ll.MoveToFront(el)

		return

	}

	el := c.ll.PushFront(&imageEntry{key: key, png: png, expires: time.Now().Add(c.ttl)})

	c.entries[key] = el

	for c.ll.Len() > c.max {

		oldest := c.ll.Back()

		if oldest == nil {

			break

		}

		c.ll.Remove(oldest)

		delete(c.entries, oldest.Value.(*imageEntry).key)

	}

}