1 files changed, 126 insertions, 14 deletions

diff --git a/src/dbx/mintages.go b/src/dbx/mintages.go
index d78e59c..9b98bd6 100644
--- a/src/dbx/mintages.go
+++ b/src/dbx/mintages.go
@@ -5,9 +5,14 @@ import (
 	"slices"
 )
 
-type MintageData struct {
-	Standard      []MSRow
-	Commemorative []MCRow
+type CountryMintageData struct {
+	Standard      []MSCountryRow
+	Commemorative []MCCountryRow
+}
+
+type YearMintageData struct {
+	Standard      []MSYearRow
+	Commemorative []MCYearRow
 }
 
 type msRowInternal struct {
@@ -31,14 +36,14 @@ type mcRowInternal struct {
 	Reference sql.Null[string]
 }
 
-type MSRow struct {
+type MSCountryRow struct {
 	Year       int
 	Mintmark   string
 	Mintages   [ndenoms]int
 	References []string
 }
 
-type MCRow struct {
+type MCCountryRow struct {
 	Year      int
 	Name      string
 	Number    int
@@ -47,6 +52,22 @@ type MCRow struct {
 	Reference string
 }
 
+type MSYearRow struct {
+	Country    string
+	Mintmark   string
+	Mintages   [ndenoms]int
+	References []string
+}
+
+type MCYearRow struct {
+	Country  string
+	Name string
+	Number    int
+	Mintmark string
+	Mintage   int
+	Reference string
+}
+
 type MintageType int
 
 /* DO NOT REORDER! */
@@ -73,15 +94,106 @@ func NewMintageType(s string) MintageType {
 	case "proof":
 		return TypeProof
 	}
-	/* TODO: Handle this */
-	panic("TODO")
+	/* We can get here if the user sends a request manually, so just
+	   fallback to this */
+	return TypeCirc
+}
+
+func GetMintagesByYear(year int, typ MintageType) (YearMintageData, error) {
+	var (
+		zero YearMintageData
+		xs   []MSYearRow
+		ys   []MCYearRow
+	)
+
+	rs, err := db.Queryx(`
+		SELECT * FROM mintages_s
+		WHERE year = ? AND type = ?
+		ORDER BY country, mintmark, denomination
+	`, year, typ)
+	if err != nil {
+		return zero, err
+	}
+
+	for rs.Next() {
+		var x msRowInternal
+		if err = rs.StructScan(&x); err != nil {
+			return zero, err
+		}
+
+	loop:
+		msr := MSYearRow{
+			Country:    x.Country,
+			Mintmark:   sqlOr(x.Mintmark, ""),
+			References: make([]string, 0, ndenoms),
+		}
+		for i := range msr.Mintages {
+			msr.Mintages[i] = MintageUnknown
+		}
+		msr.Mintages[denomToIdx(x.Denomination)] =
+			sqlOr(x.Mintage, MintageUnknown)
+		if x.Reference.Valid {
+			msr.References = append(msr.References, x.Reference.V)
+		}
+
+		for rs.Next() {
+			var y msRowInternal
+			if err = rs.StructScan(&y); err != nil {
+				return zero, err
+			}
+
+			if x.Country != y.Country || x.Mintmark != y.Mintmark {
+				x = y
+				xs = append(xs, msr)
+				goto loop
+			}
+
+			msr.Mintages[denomToIdx(y.Denomination)] =
+				sqlOr(y.Mintage, MintageUnknown)
+			if y.Reference.Valid {
+				msr.References = append(msr.References, y.Reference.V)
+			}
+		}
+
+		xs = append(xs, msr)
+	}
+
+	if err = rs.Err(); err != nil {
+		return zero, err
+	}
+
+	rs, err = db.Queryx(`
+	   	SELECT * FROM mintages_c
+ 	   	WHERE year = ? AND type = ?
+	   	ORDER BY country, mintmark, number
+	`, year, typ)
+	if err != nil {
+		return zero, err
+	}
+
+	for rs.Next() {
+		var y mcRowInternal
+		if err = rs.StructScan(&y); err != nil {
+			return zero, err
+		}
+		ys = append(ys, MCYearRow{
+			Country:   y.Country,
+			Name:      y.Name,
+			Number:    y.Number,
+			Mintmark:  sqlOr(y.Mintmark, ""),
+			Mintage:   sqlOr(y.Mintage, MintageUnknown),
+			Reference: sqlOr(y.Reference, ""),
+		})
+	}
+
+	return YearMintageData{xs, ys}, nil
 }
 
-func GetMintages(country string, typ MintageType) (MintageData, error) {
+func GetMintagesByCountry(country string, typ MintageType) (CountryMintageData, error) {
 	var (
-		zero MintageData
-		xs   []MSRow
-		ys   []MCRow
+		zero CountryMintageData
+		xs   []MSCountryRow
+		ys   []MCCountryRow
 	)
 
 	rs, err := db.Queryx(`
@@ -100,7 +212,7 @@ func GetMintages(country string, typ MintageType) (MintageData, error) {
 		}
 
 	loop:
-		msr := MSRow{
+		msr := MSCountryRow{
 			Year:       x.Year,
 			Mintmark:   sqlOr(x.Mintmark, ""),
 			References: make([]string, 0, ndenoms),
@@ -154,7 +266,7 @@ func GetMintages(country string, typ MintageType) (MintageData, error) {
 		if err = rs.StructScan(&y); err != nil {
 			return zero, err
 		}
-		ys = append(ys, MCRow{
+		ys = append(ys, MCCountryRow{
 			Year:      y.Year,
 			Name:      y.Name,
 			Number:    y.Number,
@@ -164,7 +276,7 @@ func GetMintages(country string, typ MintageType) (MintageData, error) {
 		})
 	}
 
-	return MintageData{xs, ys}, rs.Err()
+	return CountryMintageData{xs, ys}, rs.Err()
 }
 
 func sqlOr[T any](v sql.Null[T], dflt T) T {