package main

import (
	"embed"
	"encoding/json"
	"html/template"
	"log/slog"
	"mime"
	"net/http"
	"os"
	"path/filepath"
	"strings"
)

//go:embed templates/*.html static/*
var appFS embed.FS

type App struct {
	Log       *slog.Logger
	Templates *template.Template
	BaseURL   string
	Cache     *feedCache
	Images    *imageCache
	renderSem chan struct{}
}

type templateItem struct {
	Title         string
	Link          string
	Author        string
	FormattedDate string
}

type feedRef struct {
	Name string
	URL  string
}

type indexPageData struct {
	BaseURL         string
	Items           []templateItem
	FeedURLs        []feedRef
	Error           string
	MetaTitle       string
	MetaDescription string
	CanonicalURL    string
	OGImage         string
}

func (a *App) routes() *http.ServeMux {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /", a.indexHandler)
	mux.HandleFunc("GET /privacy", a.privacyHandler)
	mux.HandleFunc("GET /og.png", a.ogImageHandler)
	mux.HandleFunc("GET /api/resolve", a.resolveHandler)
	mux.HandleFunc("GET /static/", embeddedHandler(appFS, "static"))
	return mux
}

// limitInFlight caps concurrent in-flight requests. Under a traffic spike,
// excess requests get an immediate 503 rather than piling up goroutines and
// outbound connections that would exhaust file descriptors. Static asset
// requests are cheap (served from memory) and bypass the limiter.
func limitInFlight(next http.Handler, max int) http.Handler {
	sem := make(chan struct{}, max)
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if strings.HasPrefix(r.URL.Path, "/static/") {
			next.ServeHTTP(w, r)
			return
		}
		select {
		case sem <- struct{}{}:
			defer func() { <-sem }()
			next.ServeHTTP(w, r)
		default:
			http.Error(w, "server busy", http.StatusServiceUnavailable)
		}
	})
}

// embeddedHandler serves files from an embed.FS under the given URL prefix.
func embeddedHandler(fs embed.FS, prefix string) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		name := strings.TrimPrefix(r.URL.Path, "/"+prefix+"/")
		path := filepath.ToSlash(filepath.Join(prefix, name))
		data, err := fs.ReadFile(path)
		if err != nil {
			http.NotFound(w, r)
			return
		}
		if ct := mime.TypeByExtension(filepath.Ext(path)); ct != "" {
			w.Header().Set("Content-Type", ct)
		}
		_, _ = w.Write(data)
	}
}

// render executes a named template into w. Errors are logged and surfaced as HTTP 500.
func render(t *template.Template, w http.ResponseWriter, name string, data any, log *slog.Logger) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	if err := t.ExecuteTemplate(w, name, data); err != nil {
		if log != nil {
			log.Error("template render failed", "name", name, "err", err)
		}
		http.Error(w, "template error", http.StatusInternalServerError)
	}
}

// writeJSON writes data as JSON with the given status code.
func writeJSON(w http.ResponseWriter, status int, data any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(data)
}

// writeError writes a JSON error response of the form {"error": msg}.
func writeError(w http.ResponseWriter, status int, msg string) {
	writeJSON(w, status, map[string]any{"error": msg})
}

// getenv returns the trimmed value of key or fallback when unset/blank.
func getenv(key, fallback string) string {
	if v := strings.TrimSpace(os.Getenv(key)); v != "" {
		return v
	}
	return fallback
}

// loadDotEnv reads KEY=VALUE pairs from a .env file in the working directory
// and sets them as environment variables, without overriding vars already set.
func loadDotEnv(path string) {
	data, err := os.ReadFile(path)
	if err != nil {
		return
	}
	for line := range strings.SplitSeq(string(data), "\n") {
		line = strings.TrimSpace(line)
		if line == "" || strings.HasPrefix(line, "#") {
			continue
		}
		key, value, ok := strings.Cut(line, "=")
		if !ok {
			continue
		}
		key = strings.TrimSpace(key)
		value = strings.TrimSpace(value)
		value = strings.Trim(value, `"'`)
		if key == "" {
			continue
		}
		if _, exists := os.LookupEnv(key); !exists {
			os.Setenv(key, value)
		}
	}
}