loader.go

package pageseo

import (
	"context"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"mime"
	"net/http"
	"sync"

	"golang.org/x/sync/singleflight"
)

// Skip is a sentinel error that indicates a page resource
// should not be validated.
var Skip = errors.New("do not validate this resource")

// Loader fetches the resource from a given location.
// Implementations should handle caching and other
// performance optimizations.
//
// Loader should return [Skip] if a resource
// should not be validated without raising an error
// or a warning.
type Loader interface {
	Load(context.Context, string) ([]byte, string, error)
}

type skipAllLoader struct{}

var skipAllLoadingSingleton Loader = skipAllLoader{}

func (skipAllLoader) Load(context.Context, string) ([]byte, string, error) {
	return nil, "", Skip
}

type Resource struct {
	URL         string
	ContentType string
	Content     []byte
	Error       error
}

type fsLoader struct {
	fs.FS
}

func NewFS(fs fs.FS) Loader {
	if fs == nil {
		panic("nil file system")
	}
	return fsLoader{
		FS: fs,
	}
}

func (fs fsLoader) Load(_ context.Context, url string) ([]byte, string, error) {
	r, err := fs.FS.Open(url)
	if err != nil {
		return nil, "", fmt.Errorf("unable to open <%s>: %w", url, err)
	}
	data, err := io.ReadAll(r)
	if err != nil {
		return nil, "", fmt.Errorf("unable to load <%s>: %w", url, err)
	}
	ct, _, err := mime.ParseMediaType(http.DetectContentType(data))
	if err != nil {
		return nil, "", fmt.Errorf("unable to parse media type: %w", err)
	}
	return data, ct, nil
}

type semaphoreLoader struct {
	Loaders chan Loader
}

func NewSemaphore(loaders ...Loader) Loader {
	total := len(loaders)
	switch total {
	case 1:
		if loaders[0] == nil {
			panic("nil loader in the semaphore")
		}
		return loaders[0]
	case 0:
		panic("no semaphore loaders")
	}
	stack := make(chan Loader, total)
	for _, loader := range loaders {
		if loader == nil {
			panic("nil loader in the semaphore")
		}
		stack <- loader
	}

	return semaphoreLoader{
		Loaders: stack,
	}
}

func (s semaphoreLoader) Load(ctx context.Context, url string) (data []byte, contentType string, err error) {
	select {
	case <-ctx.Done():
		return nil, "", ctx.Err()
	case loader := <-s.Loaders:
		data, contentType, err = loader.Load(ctx, url)
		s.Loaders <- loader
		return
	}
}

type hotSwapLoader struct {
	Cursor    int
	Preloaded []Resource
	Loader    Loader
}

func NewHotSwap(ctx context.Context, loader Loader, URLs []string) Loader {
	resources := make([]Resource, len(URLs))
	wg := sync.WaitGroup{}
	for i, url := range URLs {
		wg.Add(1)
		go func(ctx context.Context, i int, url string) {
			data, contentType, err := loader.Load(ctx, url)
			resources[i] = Resource{
				URL:         url,
				ContentType: contentType,
				Content:     data,
				Error:       err,
			}
			wg.Done()
		}(ctx, i, url)
	}
	wg.Wait()
	return hotSwapLoader{
		Loader:    loader,
		Cursor:    0,
		Preloaded: resources,
	}
}

func (h hotSwapLoader) Load(ctx context.Context, URL string) ([]byte, string, error) {
	var i int

	// search forward from cursor
	for i = h.Cursor; i < len(h.Preloaded); i++ {
		r := h.Preloaded[i]
		if r.URL == URL {
			h.Cursor = i + 1 // next time begin iteration from same point
			return r.Content, r.ContentType, r.Error
		}
	}

	// search backward from cursor
	for i = h.Cursor - 1; i >= 0; i-- {
		r := h.Preloaded[i]
		if r.URL == URL {
			return r.Content, r.ContentType, r.Error
		}
	}

	// fallback on loader
	return h.Loader.Load(ctx, URL)
}

type singleFlightLoader struct {
	Loader
	*singleflight.Group
}

func NewSingleFlightLoader(loader Loader) Loader {
	if loader == nil {
		panic("nil loader")
	}
	return &singleFlightLoader{
		Loader: loader,
		Group:  &singleflight.Group{},
	}
}

func (l *singleFlightLoader) Load(ctx context.Context, URL string) ([]byte, string, error) {
	result, err, _ := l.Group.Do(URL, func() (any, error) {
		data, ct, err := l.Loader.Load(ctx, URL)
		return Resource{
			URL:         URL,
			ContentType: ct,
			Content:     data,
		}, err
	})
	r := result.(Resource)
	return r.Content, r.ContentType, err
}

type loaderHTTP struct {
	*http.Client
	Headers http.Header
}

func NewHTTPClient(client *http.Client, headers http.Header) Loader {
	if client == nil {
		panic("nil HTTP client")
	}
	return loaderHTTP{
		Client:  client,
		Headers: headers,
	}
}

func (web loaderHTTP) Load(ctx context.Context, url string) (data []byte, contentType string, err error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return nil, "", fmt.Errorf("unable to open <%s>: %w", url, err)
	}
	for key, values := range web.Headers {
		for _, value := range values {
			req.Header.Set(key, value)
		}
	}
	resp, err := web.Client.Do(req)
	if err != nil {
		return nil, "", fmt.Errorf("unable to load <%s>: %w", url, err)
	}
	defer func() {
		err = errors.Join(err, resp.Body.Close())
	}()

	data, err = io.ReadAll(resp.Body)
	if err != nil {
		return nil, "", fmt.Errorf("unable to load <%s>: %w", url, err)
	}
	contentTypeRaw := resp.Header.Get(`Content-Type`)
	contentType, _, err = mime.ParseMediaType(contentTypeRaw)
	if err != nil {
		return nil, "", fmt.Errorf("unable to parse header <Content-Type> <%s>: %w", contentTypeRaw, err)
	}
	if resp.StatusCode < 200 || resp.StatusCode > 299 {
		err = fmt.Errorf("HTTP %d error: %s", resp.StatusCode, http.StatusText(resp.StatusCode))
	}
	// if contentType == "" {
	// 	contentType = "application/octet-stream"
	// }
	return data, contentType, err
}