package main

import (
	"html/template"
	"log"
	"net/http"

	"spitfire-store/spm"
)

func last(s []string) string {
	if len(s) == 0 {
		return ""
	}
	return s[len(s)-1]
}

var storeTemplate = template.Must(template.New("store.html").Funcs(template.FuncMap{
	"last": last,
}).ParseFiles("templates/store.html"))
var indexTemplate = template.Must(template.ParseFiles("templates/index.html"))

// indexHandler renders the main search page.
func indexHandler(w http.ResponseWriter, r *http.Request) {
	indexTemplate.Execute(w, nil)
}

// searchHandler uses spm.SearchPackages with the given query & filter,
// converts results into a slice of maps for the template, and renders them.
func searchHandler(w http.ResponseWriter, r *http.Request) {
	query := r.FormValue("q")
	filter := r.FormValue("filter")

	if query == "" {
		http.Redirect(w, r, "/", http.StatusFound)
		return
	}

	log.Printf("Search query=%s, filter=%s", query, filter)

	// Update local SPM index first
	if err := spm.UpdateIndex(); err != nil {
		http.Error(w, "Failed to update local index", http.StatusInternalServerError)
		log.Printf("spm.UpdateIndex error: %v", err)
		return
	}

	// Call our unified search. Ensure spm.SearchPackages handles
	// "addon", "theme", "layout", "bundle", "config", "all", etc.
	results, err := spm.SearchPackages(query, filter)
	if err != nil {
		http.Error(w, "Search error", http.StatusInternalServerError)
		log.Printf("spm.SearchPackages error: %v", err)
		return
	}

	log.Printf("Total results for query=%q, filter=%q: %d", query, filter, len(results))

	// Convert each result into a map for the template.
	// For Mozilla addons, e.Type might be "addon" or "theme".
	// For SPM, e.Type might be "layout", "bundle", "config", etc.
	var items []map[string]interface{}
	for _, e := range results {
		item := map[string]interface{}{
			"type":        e.Type,
			"name":        e.Name,
			"release":     e.Release,
			"os":          e.OS,
			"arch":        e.Arch,
			"downloadURL": e.DownloadURL,
			"icon":        e.Icon,
			"url":         e.URL,
			"screenshots": e.Screenshots,
		}
		items = append(items, item)
	}

	// Render the store template with items
	if err := storeTemplate.Execute(w, items); err != nil {
		log.Printf("Error executing template: %v", err)
	}
}

// installHandler for AMO add-ons (unchanged)
func installHandler(w http.ResponseWriter, r *http.Request) {
	slug := r.URL.Query().Get("slug")
	if slug == "" {
		http.Error(w, "Missing add-on slug", http.StatusBadRequest)
		return
	}
	addon, err := fetchAddonDetails(slug)
	if err != nil {
		http.Error(w, "Failed to fetch add-on details", http.StatusInternalServerError)
		log.Printf("Error fetching details for slug '%s': %v", slug, err)
		return
	}
	var xpiURL string
	if len(addon.CurrentVersion.Files) > 0 {
		xpiURL = addon.CurrentVersion.Files[0].URL
	} else if addon.CurrentVersion.File != nil {
		xpiURL = addon.CurrentVersion.File.URL
	} else {
		http.Redirect(w, r, addon.URL, http.StatusFound)
		return
	}
	http.Redirect(w, r, xpiURL, http.StatusFound)
}