package main

import (

	"context"

	"fmt"

	"net/http"

	"net/url"

	"strings"

	"sync"

	"time"

)

const maxFeedURLs = 20

func (a *App) privacyHandler(w http.ResponseWriter, r *http.Request) {

	render(a.Templates, w, "privacy.html", nil, a.Log)

}

func (a *App) indexHandler(w http.ResponseWriter, r *http.Request) {

	data := indexPageData{

		BaseURL:         a.BaseURL,

		MetaTitle:       "Feeds",

		MetaDescription: "An introduction to RSS",

		CanonicalURL:    a.BaseURL,

		OGImage:         a.BaseURL + "/static/og.png",

	}

	urls := feedURLsFromRequest(r)

	if len(urls) == 0 {

		render(a.Templates, w, "index.html", data, a.Log)

		return

	}

	data.CanonicalURL = a.BaseURL + r.URL.RequestURI()

	data.OGImage = a.BaseURL + "/og.png?" + r.URL.RawQuery

	ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)

	defer cancel()

	items, titles := previewURLs(ctx, urls, 0, a.Cache, a.Log)

	for _, item := range items {

		data.Items = append(data.Items, templateItem{Title: item.Title, Link: item.Link, Author: item.Author, FormattedDate: formatDate(item.Published)})

	}

	if len(data.Items) == 0 {

		data.Error = "No items could be loaded from these feeds"

	}

	for _, u := range urls {

		name := titles[u]

		if name == "" {

			name = hostName(u)

		}

		data.FeedURLs = append(data.FeedURLs, feedRef{Name: name, URL: u})

	}

	data.MetaTitle, data.MetaDescription = feedMeta(urls, titles, len(data.Items))

	render(a.Templates, w, "index.html", data, a.Log)

}

// feedURLsFromRequest extracts and normalizes the feed URLs from the "url" or

// "urls" query param, capped at maxFeedURLs.

func feedURLsFromRequest(r *http.Request) []string {

	query := r.URL.Query().Get("url")

	if query == "" {

		query = r.URL.Query().Get("urls")

	}

	urls := splitAndTrim(query)

	if len(urls) > maxFeedURLs {

		urls = urls[:maxFeedURLs]

	}

	return urls

}

// feedMeta builds an og:title and og:description from the shared feed URLs,

// their resolved titles (falling back to the URL host), and the item count.

func feedMeta(urls []string, titles map[string]string, itemCount int) (title, description string) {

	names := make([]string, 0, len(urls))

	for _, u := range urls {

		name := titles[u]

		if name == "" {

			name = hostName(u)

		}

		if name != "" {

			names = append(names, name)

		}

	}

	switch {

	case len(names) == 0:

		title = "Feeds"

	case len(names) == 1:

		title = names[0]

	default:

		title = fmt.Sprintf("%s +%d more", names[0], len(names)-1)

	}

	feedWord := "feed"

	if len(urls) != 1 {

		feedWord = "feeds"

	}

	postWord := "post"

	if itemCount != 1 {

		postWord = "posts"

	}

	description = fmt.Sprintf("%d %s from %d %s", itemCount, postWord, len(urls), feedWord)

	return title, description

}

// hostName returns the host of a URL with a leading "www." stripped.

func hostName(raw string) string {

	if !strings.Contains(raw, "://") {

		raw = "https://" + raw

	}

	u, err := url.Parse(raw)

	if err != nil {

		return ""

	}

	return strings.TrimPrefix(u.Host, "www.")

}

type resolvedFeed struct {

	URL     string `json:"url"`

	Title   string `json:"title"`

	Favicon string `json:"favicon,omitempty"`

}

// faviconFor discovers the favicon for a fetched feed, falling back to the

// feed URL's origin when the feed doesn't declare a site link.

func faviconFor(ctx context.Context, res *FetchResult, feedURL string) string {

	site := res.SiteURL

	if site == "" {

		if u, err := url.Parse(feedURL); err == nil && u.Host != "" {

			site = u.Scheme + "://" + u.Host

		}

	}

	if site == "" {

		return ""

	}

	return discoverFavicon(ctx, site)

}

func (a *App) resolveHandler(w http.ResponseWriter, r *http.Request) {

	raw := strings.TrimSpace(r.URL.Query().Get("url"))

	if raw == "" {

		writeError(w, http.StatusBadRequest, "url parameter is required")

		return

	}

	if !strings.Contains(raw, "://") {

		raw = "https://" + raw

	}

	ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)

	defer cancel()

	// If the input parses as a feed, use it directly.

	if res, err := fetchFeed(ctx, raw, "", ""); err == nil {

		writeJSON(w, http.StatusOK, map[string]any{"feeds": []resolvedFeed{{URL: raw, Title: res.Title, Favicon: faviconFor(ctx, res, raw)}}})

		return

	}

	// Otherwise treat it as a site URL and discover feeds.

	candidates, err := discoverFeeds(ctx, raw)

	if err != nil {

		writeError(w, http.StatusUnprocessableEntity, "no feed found at this URL")

		return

	}

	if len(candidates) > 3 {

		candidates = candidates[:3]

	}

	var wg sync.WaitGroup

	var mu sync.Mutex

	found := map[string]resolvedFeed{}

	for _, candidate := range candidates {

		wg.Add(1)

		go func() {

			defer wg.Done()

			res, err := fetchFeed(ctx, candidate, "", "")

			if err != nil {

				a.Log.Warn("resolve candidate failed", "url", candidate, "err", err)

				return

			}

			favicon := faviconFor(ctx, res, candidate)

			mu.Lock()

			found[candidate] = resolvedFeed{URL: candidate, Title: res.Title, Favicon: favicon}

			mu.Unlock()

		}()

	}

	wg.Wait()

	feeds := make([]resolvedFeed, 0, len(found))

	for _, candidate := range candidates {

		if f, ok := found[candidate]; ok {

			feeds = append(feeds, f)

		}

	}

	if len(feeds) == 0 {

		writeError(w, http.StatusUnprocessableEntity, "no feed found at this URL")

		return

	}

	writeJSON(w, http.StatusOK, map[string]any{"feeds": feeds})

}