namegen/handlers.go

package main

import (
	"encoding/json"
	"log"
	"math/rand"
	"net/http"
	"strconv"
	"strings"

	"golang.org/x/text/cases"
	"golang.org/x/text/language"

	"namegen/generators"
)

var elfArrays *generators.ElfArrays
var dwarfArrays *generators.DwarfArrays
var arakocraArrays *generators.ArakocraArrays
var bugbearArrays *generators.BugbearArrays
var changelingArrays *generators.ChangelingArrays
var titleCaser = cases.Title(language.English)
var dragonbornArrays *generators.DragonbornArrays
var duergarArrays *generators.DuergarArrays
var eladrinArrays *generators.EladrinArrays
var fairyArrays *generators.FairyArrays
var genasiArrays *generators.GenasiArrays
var githyankiArrays *generators.GithyankiArrays
var githzeraiArrays *generators.GithzeraiArrays
var gnomeArrays *generators.GnomeArrays
var goblinArrays *generators.GoblinArrays
var goliathArrays *generators.GoliathArrays
var grungArrays *generators.GrungArrays
var halfElfArrays *generators.HalfElfArrays
var halfOrcArrays *generators.HalfOrcArrays
var halflingArrays *generators.HalflingArrays
var harengonArrays *generators.HarengonArrays
var leoninArrays *generators.LeoninArrays
var humanArrays *generators.HumanArrays
var koboldArrays *generators.KoboldArrays
var kenkuArrays *generators.KenkuArrays
var kalashtarArrays *generators.KalashtarArrays
var hobgoblinArrays *generators.HobgoblinArrays
var lizardfolkArrays *generators.LizardfolkArrays
var locathahArrays *generators.LocathahArrays
var loxodonArrays *generators.LoxodonArrays
var minotaurArrays *generators.MinotaurArrays
var orcArrays *generators.OrcArrays
var satyrArrays *generators.SatyrArrays
var shadarKaiArrays *generators.ShadarKaiArrays
var shardmindArrays *generators.ShardmindArrays
var shifterArrays *generators.ShifterArrays
var simicHybridArrays *generators.SimicHybridArrays
var tabaxiArrays *generators.TabaxiArrays
var tieflingArrays *generators.TieflingArrays
var tortleArrays *generators.TortleArrays
var tritonArrays *generators.TritonArrays
var vedalkenArrays *generators.VedalkenArrays
var verdanArrays *generators.VerdanArrays
var warforgedArrays *generators.WarforgedArrays
var wildenArrays *generators.WildenArrays
var yuantiArrays *generators.YuanTiArrays
var modernEnglishArrays *generators.ModernEnglishArrays
var modernPortugueseEUArrays *generators.ModernPortugueseEUArrays

func init() {
	var err error
	elfArrays, err = generators.LoadElfArrays("data/elf.json")
	if err != nil {
		log.Fatalf("Failed to load elf arrays: %v", err)
	}
	dwarfArrays, err = generators.LoadDwarfArrays("data/dwarf.json")
	if err != nil {
		log.Fatalf("Failed to load dwarf arrays: %v", err)
	}
	arakocraArrays, err = generators.LoadArakocraArrays("data/arakocra.json")
	if err != nil {
		log.Fatalf("Failed to load arakocra arrays: %v", err)
	}
	bugbearArrays, err = generators.LoadBugbearArrays("data/bugbear.json")
	if err != nil {
		log.Fatalf("Failed to load bugbear arrays: %v", err)
	}
	changelingArrays, err = generators.LoadChangelingArrays("data/changeling.json")
	if err != nil {
		log.Fatalf("Failed to load changeling arrays: %v", err)
	}
	// Load Aasimar data
	if err := generators.LoadAasimarData("data/aasimar.json"); err != nil {
		log.Fatalf("Failed to load aasimar arrays: %v", err)
	}
	// Load Centaur data
	if err := generators.LoadCentaurData("data/centaur.json"); err != nil {
		log.Fatalf("Failed to load centaur arrays: %v", err)
	}
	// Load Deep Gnome data
	if err := generators.LoadDeepGnomeData("data/deep_gnome.json"); err != nil {
		log.Fatalf("Failed to load deep gnome arrays: %v", err)
	}
	// Load Deva data
	if err := generators.LoadDevaData("data/deva.json"); err != nil {
		log.Fatalf("Failed to load deva arrays: %v", err)
	}
	// Load Dragonborn data
	dragonbornArrays, err = generators.LoadDragonbornArrays("data/dragonborn.json")
	if err != nil {
		log.Fatalf("Failed to load dragonborn arrays: %v", err)
	}
	// Load Drow data
	if err := generators.LoadDrowData("data/drow.json"); err != nil {
		log.Fatalf("Failed to load drow arrays: %v", err)
	}
	// Load Duergar data
	duergarArrays, err = generators.LoadDuergarArrays("data/duergar.json")
	if err != nil {
		log.Fatalf("Failed to load duergar arrays: %v", err)
	}
	// Load Eladrin data
	eladrinArrays, err = generators.LoadEladrinArrays("data/eladrin.json")
	if err != nil {
		log.Fatalf("Failed to load eladrin arrays: %v", err)
	}
	// Load Fairy data
	fa, err := generators.LoadFairyArrays("data/fairy.json")
	if err != nil {
		log.Fatalf("Failed to load fairy arrays: %v", err)
	}
	fairyArrays = &fa
	// Load Genasi data
	ga, err := generators.LoadGenasiArrays("data/genasi.json")
	if err != nil {
		log.Fatalf("Failed to load genasi arrays: %v", err)
	}
	genasiArrays = &ga
	// Load Githyanki data
	gaGith, err := generators.LoadGithyankiArrays("data/githyanki.json")
	if err != nil {
		log.Fatalf("Failed to load githyanki arrays: %v", err)
	}
	githyankiArrays = &gaGith
	// Load Githzerai data
	gz, err := generators.LoadGithzeraiArrays("data/githzerai.json")
	if err != nil {
		log.Fatalf("Failed to load githzerai arrays: %v", err)
	}
	githzeraiArrays = &gz
	// Load Gnome data
	gn, err := generators.LoadGnomeArrays("data/gnome.json")
	if err != nil {
		log.Fatalf("Failed to load gnome arrays: %v", err)
	}
	gnomeArrays = &gn
	// Load Goblin data
	gb, err := generators.LoadGoblinArrays("data/goblin.json")
	if err != nil {
		log.Fatalf("Failed to load goblin arrays: %v", err)
	}
	goblinArrays = &gb
	// Load Goliath data
	gol, err := generators.LoadGoliathArrays("data/goliath.json")
	if err != nil {
		log.Fatalf("Failed to load goliath arrays: %v", err)
	}
	goliathArrays = &gol
	// Load Grung data
	gr, err := generators.LoadGrungArrays("data/grung.json")
	if err != nil {
		log.Fatalf("Failed to load grung arrays: %v", err)
	}
	grungArrays = &gr
	// Load Half-Elf data
	halfElf, err := generators.LoadHalfElfArrays("data/half-elf.json")
	if err != nil {
		log.Fatalf("Failed to load half-elf arrays: %v", err)
	}
	halfElfArrays = &halfElf
	// Load Half-Orc data
	halfOrc, err := generators.LoadHalfOrcArrays("data/half-orc.json")
	if err != nil {
		log.Fatalf("Failed to load half-orc arrays: %v", err)
	}
	halfOrcArrays = &halfOrc
	// Load Halfling data
	halfling, err := generators.LoadHalflingArrays("data/halfling.json")
	if err != nil {
		log.Fatalf("Failed to load halfling arrays: %v", err)
	}
	halflingArrays = &halfling
	// Load Harengon data
	harengon, err := generators.LoadHarengonArrays("data/harengon.json")
	if err != nil {
		log.Fatalf("Failed to load harengon arrays: %v", err)
	}
	harengonArrays = &harengon
	// Load Leonin data
	leonin, err := generators.LoadLeoninArrays("data/leonin.json")
	if err != nil {
		log.Fatalf("Failed to load leonin arrays: %v", err)
	}
	leoninArrays = &leonin
	// Load Human data
	human, err := generators.LoadHumanArrays("data/human.json")
	if err != nil {
		log.Fatalf("Failed to load human arrays: %v", err)
	}
	humanArrays = &human
	// Load Kobold data
	kobold, err := generators.LoadKoboldArrays("data/kobold.json")
	if err != nil {
		log.Fatalf("Failed to load kobold arrays: %v", err)
	}
	koboldArrays = &kobold
	// Load Kenku data
	kenku, err := generators.LoadKenkuArrays("data/kenku.json")
	if err != nil {
		log.Fatalf("Failed to load kenku arrays: %v", err)
	}
	kenkuArrays = &kenku
	// Load Kalashtar data
	kalashtar, err := generators.LoadKalashtarArrays("data/kalashtar.json")
	if err != nil {
		log.Fatalf("Failed to load kalashtar arrays: %v", err)
	}
	kalashtarArrays = &kalashtar
	// Load Hobgoblin data
	hobgoblin, err := generators.LoadHobgoblinArrays("data/hobgoblin.json")
	if err != nil {
		log.Fatalf("Failed to load hobgoblin arrays: %v", err)
	}
	hobgoblinArrays = &hobgoblin
	// Load Lizardfolk data
	lizardfolk, err := generators.LoadLizardfolkArrays("data/lizardfolk.json")
	if err != nil {
		log.Fatalf("Failed to load lizardfolk arrays: %v", err)
	}
	lizardfolkArrays = &lizardfolk
	// Load Locathah data
	locathah, err := generators.LoadLocathahArrays("data/locathah.json")
	if err != nil {
		log.Fatalf("Failed to load locathah arrays: %v", err)
	}
	locathahArrays = &locathah
	// Load Loxodon data
	loxodon, err := generators.LoadLoxodonArrays("data/loxodon.json")
	if err != nil {
		log.Fatalf("Failed to load loxodon arrays: %v", err)
	}
	loxodonArrays = &loxodon
	// Load Minotaur data
	minotaur, err := generators.LoadMinotaurArrays("data/minotaur.json")
	if err != nil {
		log.Fatalf("Failed to load minotaur arrays: %v", err)
	}
	minotaurArrays = &minotaur
	// Load Orc data
	orc, err := generators.LoadOrcArrays("data/orc.json")
	if err != nil {
		log.Fatalf("Failed to load orc arrays: %v", err)
	}
	orcArrays = &orc
	// Load Satyr data
	satyr, err := generators.LoadSatyrArrays("data/satyr.json")
	if err != nil {
		log.Fatalf("Failed to load satyr arrays: %v", err)
	}
	satyrArrays = &satyr
	// Load Shadar-Kai data
	shadarKai, err := generators.LoadShadarKaiArrays("data/shadar-kai.json")
	if err != nil {
		log.Fatalf("Failed to load shadar-kai arrays: %v", err)
	}
	shadarKaiArrays = &shadarKai
	// Load Shardmind data
	shardmind, err := generators.LoadShardmindArrays("data/shardmind.json")
	if err != nil {
		log.Fatalf("Failed to load shardmind arrays: %v", err)
	}
	shardmindArrays = &shardmind
	// Load Shifter data
	shifter, err := generators.LoadShifterArrays("data/shifter.json")
	if err != nil {
		log.Fatalf("Failed to load shifter arrays: %v", err)
	}
	shifterArrays = &shifter
	// Load Simic Hybrid data
	simicHybrid, err := generators.LoadSimicHybridArrays("data/simic_hybrid.json")
	if err != nil {
		log.Fatalf("Failed to load simic hybrid arrays: %v", err)
	}
	simicHybridArrays = &simicHybrid
	// Load Tabaxi data
	tabaxi, err := generators.LoadTabaxiArrays("data/tabaxi.json")
	if err != nil {
		log.Fatalf("Failed to load tabaxi arrays: %v", err)
	}
	tabaxiArrays = &tabaxi
	// Load Tiefling data
	tiefling, err := generators.LoadTieflingArrays("data/tiefling.json")
	if err != nil {
		log.Fatalf("Failed to load tiefling arrays: %v", err)
	}
	tieflingArrays = &tiefling
	// Load Tortle data
	tortle, err := generators.LoadTortleArrays("data/tortle.json")
	if err != nil {
		log.Fatalf("Failed to load tortle arrays: %v", err)
	}
	tortleArrays = &tortle
	// Load Triton data
	triton, err := generators.LoadTritonArrays("data/triton.json")
	if err != nil {
		log.Fatalf("Failed to load triton arrays: %v", err)
	}
	tritonArrays = &triton
	// Load Vedalken data
	vedalken, err := generators.LoadVedalkenArrays("data/vedalken.json")
	if err != nil {
		log.Fatalf("Failed to load vedalken arrays: %v", err)
	}
	vedalkenArrays = &vedalken
	// Load Verdan data
	verdan, err := generators.LoadVerdanArrays("data/verdan.json")
	if err != nil {
		log.Fatalf("Failed to load verdan arrays: %v", err)
	}
	verdanArrays = &verdan
	// Load Warforged data
	warforged, err := generators.LoadWarforgedArrays("data/warforged.json")
	if err != nil {
		log.Fatalf("Failed to load warforged arrays: %v", err)
	}
	warforgedArrays = &warforged
	// Load Wilden data
	wilden, err := generators.LoadWildenArrays("data/wilden.json")
	if err != nil {
		log.Fatalf("Failed to load wilden arrays: %v", err)
	}
	wildenArrays = &wilden
	// Load Yuan-Ti data
	yuanti, err := generators.LoadYuanTiArrays("data/yuan-ti.json")
	if err != nil {
		log.Fatalf("Failed to load yuan-ti arrays: %v", err)
	}
	yuantiArrays = &yuanti
	// Load Modern English data
	modernEnglish, err := generators.LoadModernEnglishArrays("data/modern-english.json")
	if err != nil {
		log.Fatalf("Failed to load modern english arrays: %v", err)
	}
	modernEnglishArrays = &modernEnglish
	// Load Modern Portuguese (EU) data
	modernPortugueseEU, err := generators.LoadModernPortugueseEUArrays("data/modern-portuguese.json")
	if err != nil {
		log.Fatalf("Failed to load modern portuguese (EU) arrays: %v", err)
	}
	modernPortugueseEUArrays = &modernPortugueseEU
}

// gender: male, female, child, or 0/1/2
func parseGender(param string) int {
	switch strings.ToLower(param) {
	case "male", "0":
		return 0
	case "female", "1":
		return 1
	case "child", "2":
		return 2
	default:
		if g, err := strconv.Atoi(param); err == nil {
			return g
		}
	}
	return 0
}

func getGender(r *http.Request) string {
	genderParam := r.URL.Query().Get("gender")
	if strings.ToLower(genderParam) == "female" || parseGender(genderParam) == 1 {
		return "female"
	}
	return "male"
}

// gender: 0=male, 1=female, 2=child (if supported)
func ElfNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	var names []string
	for i := 0; i < 10; i++ {
		var nMs, baseName string
		if gender == "child" || parseGender(r.URL.Query().Get("gender")) == 2 {
			nMs = generators.ElfNameChild(elfArrays, CheckSwear)
			for nMs == "" {
				nMs = generators.ElfNameChild(elfArrays, CheckSwear)
			}
		} else {
			if i < 5 {
				rnd := rand.Intn(len(elfArrays.Nm12))
				rnd2 := rand.Intn(len(elfArrays.Nm13))
				for elfArrays.Nm12[rnd] == elfArrays.Nm13[rnd2] {
					rnd2 = rand.Intn(len(elfArrays.Nm13))
				}
				nMs = elfArrays.Nm12[rnd] + elfArrays.Nm13[rnd2]
			} else {
				nMs = generators.ElfNameSur(elfArrays, CheckSwear)
				for nMs == "" {
					nMs = generators.ElfNameSur(elfArrays, CheckSwear)
				}
			}
			baseName = nMs
			if gender == "female" {
				nMs = generators.ElfNameFem(elfArrays, CheckSwear)
				for nMs == "" {
					nMs = generators.ElfNameFem(elfArrays, CheckSwear)
				}
			} else {
				nMs = generators.ElfNameMas(elfArrays, CheckSwear)
				for nMs == "" {
					nMs = generators.ElfNameMas(elfArrays, CheckSwear)
				}
			}
			nMs = nMs + " " + baseName
		}
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func DwarfNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	var names []string
	for i := 0; i < 10; i++ {
		var nMs, baseName string
		if i < 5 {
			rnd := rand.Intn(len(dwarfArrays.Nm12))
			rnd2 := rand.Intn(len(dwarfArrays.Nm13))
			for dwarfArrays.Nm12[rnd] == dwarfArrays.Nm13[rnd2] {
				rnd2 = rand.Intn(len(dwarfArrays.Nm13))
			}
			nMs = dwarfArrays.Nm12[rnd] + dwarfArrays.Nm13[rnd2]
		} else {
			nMs = generators.DwarfNameSur(dwarfArrays, CheckSwear)
			for nMs == "" {
				nMs = generators.DwarfNameSur(dwarfArrays, CheckSwear)
			}
		}
		baseName = nMs
		if gender == "female" {
			nMs = generators.DwarfNameFem(dwarfArrays, CheckSwear)
			for nMs == "" {
				nMs = generators.DwarfNameFem(dwarfArrays, CheckSwear)
			}
		} else {
			nMs = generators.DwarfNameMas(dwarfArrays, CheckSwear)
			for nMs == "" {
				nMs = generators.DwarfNameMas(dwarfArrays, CheckSwear)
			}
		}
		nMs = nMs + " " + baseName
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func ArakocraNamesHandler(w http.ResponseWriter, r *http.Request) {
	var names []string
	for i := 0; i < 10; i++ {
		nMs := generators.ArakocraNameMas(arakocraArrays, CheckSwear, i)
		for nMs == "" {
			nMs = generators.ArakocraNameMas(arakocraArrays, CheckSwear, i)
		}
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /aasimar-names?gender=male|female|0|1
func AasimarNamesHandler(w http.ResponseWriter, r *http.Request) {
	genderParam := r.URL.Query().Get("gender")
	gender := "male"
	if parseGender(genderParam) == 1 {
		gender = "female"
	}
	var names []string
	for i := 0; i < 10; i++ {
		nMs := generators.GenerateAasimarName(gender)
		for nMs == "" {
			nMs = generators.GenerateAasimarName(gender)
		}
		if CheckSwear(nMs) {
			nMs = generators.GenerateAasimarName(gender)
		}
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func BugbearNamesHandler(w http.ResponseWriter, r *http.Request) {
	var names []string
	for i := 0; i < 10; i++ {
		nMs := generators.BugbearNameMas(bugbearArrays, CheckSwear)
		for nMs == "" {
			nMs = generators.BugbearNameMas(bugbearArrays, CheckSwear)
		}
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /centaur-names?gender=male|female|0|1
func CentaurNamesHandler(w http.ResponseWriter, r *http.Request) {
	genderParam := r.URL.Query().Get("gender")
	gender := "male"
	if parseGender(genderParam) == 1 {
		gender = "female"
	}
	var names []string
	for i := 0; i < 10; i++ {
		nMs := generators.GenerateCentaurName(gender)
		for nMs == "" {
			nMs = generators.GenerateCentaurName(gender)
		}
		if CheckSwear(nMs) {
			nMs = generators.GenerateCentaurName(gender)
		}
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func ChangelingNamesHandler(w http.ResponseWriter, r *http.Request) {
	var names []string
	for i := 0; i < 10; i++ {
		nMs := generators.ChangelingNameMas(changelingArrays, CheckSwear)
		for nMs == "" {
			nMs = generators.ChangelingNameMas(changelingArrays, CheckSwear)
		}
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /deep-gnome-names?gender=male|female|0|1
func DeepGnomeNamesHandler(w http.ResponseWriter, r *http.Request) {
	genderParam := r.URL.Query().Get("gender")
	gender := "male"
	if parseGender(genderParam) == 1 {
		gender = "female"
	}
	var names []string
	for i := 0; i < 10; i++ {
		nMs := generators.GenerateDeepGnomeName(gender)
		for nMs == "" {
			nMs = generators.GenerateDeepGnomeName(gender)
		}
		if CheckSwear(nMs) {
			nMs = generators.GenerateDeepGnomeName(gender)
		}
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /deva-names?gender=male|female|0|1
func DevaNamesHandler(w http.ResponseWriter, r *http.Request) {
	genderParam := r.URL.Query().Get("gender")
	gender := "male"
	if parseGender(genderParam) == 1 {
		gender = "female"
	}
	var names []string
	for i := 0; i < 10; i++ {
		nMs := generators.GenerateDevaName(gender)
		for nMs == "" {
			nMs = generators.GenerateDevaName(gender)
		}
		if CheckSwear(nMs) {
			nMs = generators.GenerateDevaName(gender)
		}
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /dragonborn-names?gender=male|female|surname|0|1|2
func DragonbornNamesHandler(w http.ResponseWriter, r *http.Request) {
	genderParam := r.URL.Query().Get("gender")
	gender := "male"
	if parseGender(genderParam) == 1 {
		gender = "female"
	} else if strings.ToLower(genderParam) == "surname" || parseGender(genderParam) == 2 {
		gender = "surname"
	}
	var names []string
	for i := 0; i < 10; i++ {
		var nMs string
		switch gender {
		case "female":
			nMs = generators.DragonbornNameFem(dragonbornArrays, CheckSwear)
			for nMs == "" {
				nMs = generators.DragonbornNameFem(dragonbornArrays, CheckSwear)
			}
		case "surname":
			nMs = generators.DragonbornNameSur(dragonbornArrays, CheckSwear)
			for nMs == "" {
				nMs = generators.DragonbornNameSur(dragonbornArrays, CheckSwear)
			}
		default:
			nMs = generators.DragonbornNameMas(dragonbornArrays, CheckSwear)
			for nMs == "" {
				nMs = generators.DragonbornNameMas(dragonbornArrays, CheckSwear)
			}
		}
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /drow-names?gender=male|female|surname|0|1|2&surname=true
func DrowNamesHandler(w http.ResponseWriter, r *http.Request) {
	genderParam := r.URL.Query().Get("gender")
	gender := genderParam
	if gender == "" {
		gender = "male"
	}
	var names []string
	for i := 0; i < 10; i++ {
		first := generators.DrowName(gender, "false")
		surname := generators.DrowSurname()
		fullName := titleCaser.String(first + " " + surname)
		for CheckSwear(fullName) {
			first = generators.DrowName(gender, "false")
			surname = generators.DrowSurname()
			fullName = titleCaser.String(first + " " + surname)
		}
		names = append(names, fullName)
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func DuergarNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	var names []string
	for i := 0; i < 10; i++ {
		fullName := generators.DuergarNameFull(duergarArrays, gender, CheckSwear)
		for fullName == "" {
			fullName = generators.DuergarNameFull(duergarArrays, gender, CheckSwear)
		}
		names = append(names, titleCaser.String(fullName))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func EladrinNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	var names []string
	for i := 0; i < 10; i++ {
		var nMs string
		if gender == "female" {
			nMs = generators.EladrinNameFem(eladrinArrays, CheckSwear)
			for nMs == "" {
				nMs = generators.EladrinNameFem(eladrinArrays, CheckSwear)
			}
		} else {
			nMs = generators.EladrinNameMas(eladrinArrays, CheckSwear)
			for nMs == "" {
				nMs = generators.EladrinNameMas(eladrinArrays, CheckSwear)
			}
		}
		names = append(names, titleCaser.String(nMs))
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func FairyNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateFairyNames(*fairyArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func GenasiNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateGenasiNames(*genasiArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func GithyankiNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateGithyankiNames(githyankiArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func GithzeraiNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateGithzeraiNames(githzeraiArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func GnomeNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateGnomeNames(gnomeArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func GoblinNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateGoblinNames(goblinArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func GoliathNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateGoliathNames(goliathArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

func GrungNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateGrungNames(grungArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /half-elf-names?gender=male|female|0|1
func HalfElfNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateHalfElfNames(halfElfArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /half-orc-names?gender=male|female|0|1
func HalfOrcNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateHalfOrcNames(halfOrcArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /halfling-names?gender=male|female|0|1
func HalflingNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateHalflingNames(halflingArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /harengon-names?gender=male|female|0|1
func HarengonNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateHarengonNames(harengonArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /hobgoblin-names
func HobgoblinNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateHobgoblinNames(hobgoblinArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /human-names?gender=male|female|0|1
func HumanNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateHumanNames(humanArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /kalashtar-names?gender=male|female|0|1
func KalashtarNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateKalashtarNames(kalashtarArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /kenku-names
func KenkuNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateKenkuNames(kenkuArrays)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /kobold-names
func KoboldNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateKoboldNames(koboldArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /leonin-names?gender=male|female|0|1
func LeoninNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateLeoninNames(leoninArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /lizardfolk-names?gender=male|female|0|1
func LizardfolkNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateLizardfolkNames(lizardfolkArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /locathah-names
func LocathahNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateLocathahNames(locathahArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /loxodon-names?gender=male|female|0|1
func LoxodonNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateLoxodonNames(loxodonArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /minotaur-names?gender=male|female|0|1
func MinotaurNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateMinotaurNames(minotaurArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /orc-names?gender=male|female|0|1
func OrcNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateOrcNames(orcArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /satyr-names?gender=male|female|child|0|1|2
func SatyrNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateSatyrNames(satyrArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /shadar-kai-names?gender=male|female|0|1
func ShadarKaiNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateShadarKaiNames(shadarKaiArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /shardmind-names
func ShardmindNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateShardmindNames(shardmindArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /shifter-names?gender=male|female|0|1
func ShifterNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateShifterNames(shifterArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /simic-hybrid-names?gender=male|female|0|1
func SimicHybridNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateSimicHybridNames(simicHybridArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /tabaxi-names?gender=male|female|0|1
func TabaxiNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateTabaxiNames(tabaxiArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /tiefling-names?gender=male|female|virtue|0|1|2
func TieflingNamesHandler(w http.ResponseWriter, r *http.Request) {
	genderParam := r.URL.Query().Get("gender")
	gender := "male"
	if genderParam == "female" || parseGender(genderParam) == 1 {
		gender = "female"
	} else if genderParam == "virtue" || parseGender(genderParam) == 2 {
		gender = "virtue"
	}
	names := generators.GenerateTieflingNames(tieflingArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /tortle-names
func TortleNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateTortleNames(tortleArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /triton-names?gender=male|female|0|1
func TritonNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateTritonNames(tritonArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /vedalken-names?gender=male|female|0|1
func VedalkenNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateVedalkenNames(vedalkenArrays, gender, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /verdan-names
func VerdanNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateVerdanNames(verdanArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /warforged-names
func WarforgedNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateWarforgedNames(warforgedArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /wilden-names
func WildenNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	names := generators.GenerateWildenNames(wildenArrays, CheckSwear, gender)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /yuan-ti-names
func YuanTiNamesHandler(w http.ResponseWriter, r *http.Request) {
	names := generators.GenerateYuanTiNames(yuantiArrays, CheckSwear)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /modern/english?type=0|1|2
func ModernEnglishNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	typeInt := 0
	switch gender {
	case "female":
		typeInt = 1
	case "unisex":
		typeInt = 2
	}
	names := generators.GenerateModernEnglishNames(modernEnglishArrays, CheckSwear, typeInt)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}

// /modern/portuguese-eu?type=0|1|2
func ModernPortugueseNamesHandler(w http.ResponseWriter, r *http.Request) {
	gender := getGender(r)
	typeInt := 0
	switch gender {
	case "female":
		typeInt = 1
	case "unisex":
		typeInt = 2
	}
	names := generators.GenerateModernPortugueseEUNames(modernPortugueseEUArrays, CheckSwear, typeInt)
	for i := range names {
		names[i] = titleCaser.String(names[i])
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string][]string{"names": names})
}