1 files changed, 91 insertions, 52 deletions

diff --git a/src/http.go b/src/http.go
index 6feb865..fce82ba 100644
--- a/src/http.go
+++ b/src/http.go
@@ -11,11 +11,13 @@ import (
 	"slices"
 	"strconv"
 	"strings"
+	"time"
 
 	. "git.thomasvoss.com/euro-cash.eu/pkg/try"
 
 	"git.thomasvoss.com/euro-cash.eu/src/dbx"
 	"git.thomasvoss.com/euro-cash.eu/src/email"
+	"git.thomasvoss.com/euro-cash.eu/src/i18n"
 )
 
 type middleware = func(http.Handler) http.Handler
@@ -34,7 +36,12 @@ func Run(port int) {
 	mux.Handle("GET /favicon.ico", fs)
 	mux.Handle("GET /fonts/", fs)
 	mux.Handle("GET /storage/", fs)
-	mux.Handle("GET /style.min.css", fs)
+	if Debugp {
+		mux.Handle("GET /style.css", fs)
+		mux.Handle("GET /style-2.css", fs)
+	} else {
+		mux.Handle("GET /style.min.css", fs)
+	}
 	mux.Handle("GET /coins/designs", mwareC(final))
 	mux.Handle("GET /coins/mintages", mwareM(final))
 	mux.Handle("GET /collecting/crh", mwareC(final))
@@ -57,7 +64,10 @@ func chain(xs ...middleware) middleware {
 
 func firstHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		ctx := context.WithValue(r.Context(), "td", &templateData{})
+		ctx := context.WithValue(r.Context(), "td", &templateData{
+			Debugp:   Debugp,
+			Printers: i18n.Printers,
+		})
 		next.ServeHTTP(w, r.WithContext(ctx))
 	})
 }
@@ -81,33 +91,37 @@ func finalHandler(w http.ResponseWriter, r *http.Request) {
 	   original page they came from. */
 	if path == "/language" {
 		http.SetCookie(w, &http.Cookie{
-			Name:  "redirect",
-			Value: cmp.Or(r.Referer(), "/"),
+			Name:    "redirect",
+			Value:   cmp.Or(r.Referer(), "/"),
+			Expires: time.Now().Add(24 * time.Hour),
 		})
 	}
 
 	data := r.Context().Value("td").(*templateData)
-	t.Execute(w, data)
+	if err := t.Execute(w, data); err != nil {
+		log.Println(err)
+	}
 }
 
 func i18nHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		var p, pZero Printer
+		var p, pZero i18n.Printer
 
 		if c, err := r.Cookie("locale"); err == nil {
-			p = printers[strings.ToLower(c.Value)]
+			p = i18n.Printers[c.Value]
 		}
 
 		td := r.Context().Value("td").(*templateData)
-		td.Printer = cmp.Or(p, defaultPrinter)
 
 		if p == pZero {
+			td.Printer = bestFitLanguage(r.Header.Get("Accept-Language"))
 			http.SetCookie(w, &http.Cookie{
 				Name:  "redirect",
 				Value: r.URL.Path,
 			})
 			templates["/language"].Execute(w, td)
 		} else {
+			td.Printer = p
 			next.ServeHTTP(w, r)
 		}
 	})
@@ -124,36 +138,61 @@ func countryHandler(next http.Handler) http.Handler {
 func mintageHandler(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		td := r.Context().Value("td").(*templateData)
-		td.Code = strings.ToLower(r.FormValue("code"))
-		if !slices.ContainsFunc(td.Countries, func(c country) bool {
-			return c.Code == td.Code
-		}) {
-			td.Code = td.Countries[0].Code
-		}
 
-		td.Type = strings.ToLower(r.FormValue("type"))
+		td.Type = r.FormValue("type")
 		switch td.Type {
 		case "circ", "nifc", "proof":
 		default:
 			td.Type = "circ"
 		}
 
-		var err error
-		td.Mintages, err = dbx.GetMintages(td.Code)
-		if err != nil {
-			throwError(http.StatusInternalServerError, err, w, r)
-			return
+		td.FilterBy = r.FormValue("filter-by")
+		switch td.FilterBy {
+		case "country", "year":
+		default:
+			td.FilterBy = "country"
+		}
+
+		mt := dbx.NewMintageType(td.Type)
+
+		switch td.FilterBy {
+		case "country":
+			td.Code = r.FormValue("country")
+			if !slices.ContainsFunc(td.Countries, func(c country) bool {
+				return c.Code == td.Code
+			}) {
+				td.Code = td.Countries[0].Code
+			}
+
+			m, err := dbx.GetMintagesByCountry(td.Code, mt)
+			if err != nil {
+				throwError(http.StatusInternalServerError, err, w, r)
+				return
+			}
+			td.CountryMintages = makeCountryMintageTable(m, td.Printer)
+		case "year":
+			var err error
+			td.Year, err = strconv.Atoi(r.FormValue("year"))
+			if err != nil || td.Year < 1999 {
+				td.Year = 1999
+			}
+			m, err := dbx.GetMintagesByYear(td.Year, mt)
+			if err != nil {
+				throwError(http.StatusInternalServerError, err, w, r)
+				return
+			}
+			td.YearMintages = makeYearMintageTable(m, td.Printer)
 		}
 
-		processMintages(&td.Mintages, td.Type)
 		next.ServeHTTP(w, r)
 	})
 }
 
 func setUserLanguage(w http.ResponseWriter, r *http.Request) {
 	loc := r.FormValue("locale")
-	_, ok := printers[strings.ToLower(loc)]
+	_, ok := i18n.Printers[loc]
 	if !ok {
+		/* TODO: Make this page pretty? */
 		w.WriteHeader(http.StatusUnprocessableEntity)
 		fmt.Fprintf(w, "Locale ‘%s’ is invalid or unsupported", loc)
 		return
@@ -177,11 +216,7 @@ func setUserLanguage(w http.ResponseWriter, r *http.Request) {
 
 func throwError(status int, err error, w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(status)
-	go func() {
-		if err := email.ServerError(err); err != nil {
-			log.Println(err)
-		}
-	}()
+	go email.Send("Server Error", err.Error())
 	errorTmpl.Execute(w, struct {
 		Code int
 		Msg  string
@@ -191,34 +226,38 @@ func throwError(status int, err error, w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-func processMintages(md *dbx.MintageData, typeStr string) {
-	var typ int
-	switch typeStr {
-	case "nifc":
-		typ = dbx.TypeNifc
-	case "proof":
-		typ = dbx.TypeProof
-	default:
-		typ = dbx.TypeCirc
+func bestFitLanguage(qry string) i18n.Printer {
+	type option struct {
+		bcp     string
+		quality float64
 	}
+	var xs []option
 
-	md.Standard = slices.DeleteFunc(md.Standard,
-		func(x dbx.MSRow) bool { return x.Type != typ })
-	md.Commemorative = slices.DeleteFunc(md.Commemorative,
-		func(x dbx.MCRow) bool { return x.Type != typ })
-	slices.SortFunc(md.Standard, func(x, y dbx.MSRow) int {
-		if x.Year != y.Year {
-			return x.Year - y.Year
+	for subqry := range strings.SplitSeq(qry, ",") {
+		var o option
+		subqry = strings.TrimSpace(subqry)
+		parts := strings.Split(subqry, ";")
+		o.bcp = strings.ToLower(parts[0])
+		if len(parts) == 1 {
+			o.quality = 1
+		} else {
+			n, err := fmt.Sscanf(parts[1], "q=%f", &o.quality)
+			if n != 1 || err != nil {
+				/* Malformed query string; just give up */
+				return i18n.DefaultPrinter
+			}
 		}
-		return strings.Compare(x.Mintmark, y.Mintmark)
+		xs = append(xs, o)
+	}
+
+	slices.SortFunc(xs, func(x, y option) int {
+		return cmp.Compare(y.quality, x.quality)
 	})
-	slices.SortFunc(md.Commemorative, func(x, y dbx.MCRow) int {
-		if x.Year != y.Year {
-			return x.Year - y.Year
-		}
-		if x.Number != y.Number {
-			return x.Number - y.Number
+
+	for _, x := range xs {
+		if p, ok := i18n.Printers[x.bcp]; ok {
+			return p
 		}
-		return strings.Compare(x.Mintmark, y.Mintmark)
-	})
+	}
+	return i18n.DefaultPrinter
 }