// Package main m2.go
package main

import (
	"bufio"
	"bytes"
	"encoding/base64"
	"errors"
	"fmt"
	htmpl "html/template"
//htmpl	"github.com/gofiber/template/html/v2"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"runtime"
	"sort"
	"strconv"
	"strings"
	"sync"
	ttmpl "text/template"
	"time"
	"unicode"

	"github.com/alecthomas/chroma/quick"

	"github.com/bitfield/script"
	"github.com/gofiber/fiber/v2"
	"github.com/gofiber/fiber/v2/middleware/logger"

	cc "github.com/ivanpirog/coloredcobra"
	"github.com/spf13/cobra"
)


func main() {
	Execute()
}

var snipcartapikey string
var wasmExecLocation = runtime.GOROOT() + "/misc/wasm/wasm_exec.js"

func init() {

	rootCmd.CompletionOptions.DisableDefaultCmd = true
	rootCmd.AddCommand(
		runCmd,
	)
	var helpflag bool
	rootCmd.SetUsageTemplate(help)
	rootCmd.PersistentFlags().BoolVarP(&helpflag, "help", "h", false, "help for "+rootCmd.Use)
	rootCmd.SetHelpCommand(&cobra.Command{Hidden: true})
	rootCmd.PersistentFlags().MarkHidden("help") //nolint

}

var rootCmd = &cobra.Command{
	Use:   "m2",
	Short: "magnetosphere.net website (re-)implementation",
	Long: `
	┌┬┐┌─┐┌─┐┌┐┌┌─┐┌┬┐┌─┐┌─┐┌─┐┬ ┬┌─┐┬─┐┌─┐ ┌┐┌┌─┐┌┬┐
	│││├─┤│ ┬│││├┤  │ │ │└─┐├─┘├─┤├┤ ├┬┘├┤  │││├┤  │
	┴ ┴┴ ┴└─┘┘└┘└─┘ ┴ └─┘└─┘┴  ┴ ┴└─┘┴└─└─┘o┘└┘└─┘ ┴
	`,
}

// Execute executes the root cli command
func Execute() {
	cc.Init(&cc.Config{
		RootCmd:         rootCmd,
		Headings:        cc.HiBlue + cc.Bold,
		Commands:        cc.HiBlue + cc.Bold,
		CmdShortDescr:   cc.HiBlue,
		Example:         cc.HiBlue + cc.Italic,
		ExecName:        cc.HiBlue + cc.Bold,
		Flags:           cc.HiBlue + cc.Bold,
		FlagsDescr:      cc.HiBlue,
		NoExtraNewlines: true,
		NoBottomNewline: true,
	})
	if err := rootCmd.Execute(); err != nil {
		log.Fatal("Failed to execute command: ", err)
	}
}

var webPort int
var kill bool

func init() {
	defaultport, err := strconv.Atoi(os.Getenv("WEBPORT"))
	if err != nil {
		defaultport = 8080
	}

	runCmd.Flags().StringVarP(&snipcartapikey, "apikey", "a", os.Getenv("SNIPCARTAPIKEY"), "snipcart public api key - env SNIPCARTAPIKEY="+os.Getenv("SNIPCARTAPIKEY"))
	runCmd.Flags().IntVarP(&webPort, "port", "p", defaultport, "port to serve on - env WEBPORT="+os.Getenv("WEBPORT"))
	runCmd.Flags().BoolVarP(&kill, "kill", "k", false, "kill any process already running on the specified port")
}

var runCmd = &cobra.Command{
	Use:   "run",
	Short: "run the web application",
	Run: func(_ *cobra.Command, _ []string) {
		if kill {
			_, err := script.Exec(fmt.Sprintf(`%s "lsof -ti tcp:%d | xargs kill -9"`, shcmd, webPort)).Stdout()
			if err != nil {
				fmt.Println("Error killing previous instance: ", err)
			}
		}
		fileInfo, err := os.Stat("products.csv")
		if err != nil {
			fmt.Println("Error getting file info:", err)
			return
		}
		lastModTime = fileInfo.ModTime()
		readCSV()
		go func() {
			for {
				fileInfo, err := os.Stat("products.csv")
				if err != nil {
					fmt.Println("Error getting file info:", err)
				}

				currentModTime := fileInfo.ModTime()
				if currentModTime != lastModTime {
					fmt.Println("CSV file has been modified!")
					readCSV()
					lastModTime = currentModTime
				}

				time.Sleep(1 * time.Second)
			}
		}()
		server()
	},
}

var cWasm []byte
var lastModTime time.Time
var htmlPageTemplateData htmlTemplateData
var tmpl *htmpl.Template

func server() {
	wg := new(sync.WaitGroup)
	wg.Add(1)
	htmlPageTemplateData = htmlTemplateData{
		Title:          "magnetosphere electronic surplus",
		MetaDesc:       "We have the technology (◕‿◕) electronic surplus for sale",
		KeyWords:       "magnetosphere, electronic, surplus",
		Heading:        htmpl.HTML("<h1 style='margin: 0; padding: 0; background: black;'>magnetosphere electronic surplus</h1> <span style='text-align: center;'>we have the technology</span>"),
		SnipcartDiv:    htmpl.HTML("<div hidden id='snipcart' data-api-key='" + snipcartapikey + "' data-config-modal-style='side' style='display: none;'></div>"),
		SnipcartCart:   htmpl.HTML("<a title='shopping cart' href='/cart'><span style='color:red; text-decoration-line: underline;' class='snipcart-checkout'>cart:<span class='snipcart-items-count'></span> <span class='snipcart-total-price'></span></span></a>"),
		Gocanvas:       htmpl.HTML("<div id='gocanvas-container'><canvas id='gocanvas'></canvas></div>"),
		WasmBinary:     "b.wasm",
		WasmExecPath:   wasmExecLocation,
		Cats:           getcats(),
		LenAllProducts: len(allproducts),
		LogoImage:      htmpl.HTML("<img id=logo src='/img/logo.jpg' alt='welcome to magnetosphere' style='display: block; margin-left: auto; margin-right: auto; width: 70%;'>"),
		Page:           "front",
	}
	htmlPageTemplateData.CatsCounts, htmlPageTemplateData.Cats, htmlPageTemplateData.SubCatsCounts, htmlPageTemplateData.SubCatsByCat = getcategories()
	var err1 error
	tmpl, err1 = htmpl.New("index").Funcs(htmpl.FuncMap{"replace": replace, "mul": mul, "div": div, "safeHTML": safeHTML, "add": add, "sub": sub, "toFloat": toFloat, "equalsIgnoreCase": equalsIgnoreCase, "getsubcats": getsubcats, "escapesubcat": escapesubcat, "sortsubcats": sortsubcats, "repeat": repeat,}).Parse(htmlMainPageTemplate)
	if err1 != nil {
		fmt.Println("Error parsing index template:", err1)
	}
	_, err1 = tmpl.New("head").Parse(htmlHeadTemplate)
	if err1 != nil {
		fmt.Println("Error parsing head template:", err1)
	}
	_, err1 = tmpl.New("header").Parse(htmlHeaderTemplate)
	if err1 != nil {
		fmt.Println("Error parsing head template:", err1)
	}

	r := fiber.New(fiber.Config{
    ErrorHandler: func(c *fiber.Ctx, err error) error {
        code := fiber.StatusInternalServerError
        var e *fiber.Error
        if errors.As(err, &e) {
            code = e.Code
        }
        c.SendStatus(code)
        return nil
    },
})
	r.Use(logger.New(logger.Config{
		Done:          nil,
	    Format:        "${time} | ${status} | ${latency} | ${ip} | ${ips} | ${method} | ${path}\n",
	    TimeFormat: "2006-01-02 15:04:05",
}))

r.Use(func(c *fiber.Ctx) error {
	if !c.Context().IsGet()  && !c.Context().IsHead() {
		c.SendStatus(fiber.StatusNotImplemented)
		return nil
	}
    return c.Next()
})
/*
r.All("/test", func(c *fiber.Ctx) error {
	status := fiber.StatusOK
	c.Set(fiber.HeaderContentType, fiber.MIMETextHTMLCharsetUTF8)
	if c.Context().IsHead() {
		c.SendStatus(status)
		return nil
	}
	re, err := script.File("test.html").Bytes()
	if err != nil {
		fmt.Printf("Error on script.File(\"test.html\").Bytes(): %v", err)
		c.SendStatus(fiber.StatusNotFound)
		return err
	}
	c.Status(status).Write(re)
	return nil
})
r.All("/test1", func(c *fiber.Ctx) error {
	c.Set(fiber.HeaderContentType, fiber.MIMETextHTMLCharsetUTF8)
	if c.Context().IsHead() {
		c.SendStatus(fiber.StatusOK)
		return nil
	}
	c.Status(fiber.StatusOK).Write([]byte(`<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <style>
    #toggleButton {
      display: none;
    }

    #menu {
      display: none;
    }

    #toggleButton:checked + #menu {
      display: block;
    }

    label {
      background-color: #3498db;
      color: #fff;
      padding: 10px;
      cursor: pointer;
      border-radius: 4px;
    }
  </style>
</head>
<body>

  <input type="checkbox" id="toggleButton">
  <label for="toggleButton">Toggle Menu</label>

  <ul id="menu">
    <li><a href="#">Link 1</a></li>
    <li><a href="#">Link 2</a></li>
    <li><a href="#">Link 3</a></li>
  </ul>

</body>
</html>
`))
return nil
})

*/
	r.All("/m", func(c *fiber.Ctx) error {
		c.Set(fiber.HeaderContentType, fiber.MIMETextHTMLCharsetUTF8)
		if c.Context().IsHead() {
			c.SendStatus(fiber.StatusOK)
			return nil
		}
 		c.Status(fiber.StatusOK).Write([]byte(`<!DOCTYPE html><html><head><meta name='viewport' content='initial-scale=1'></head><body style='background-color:black;color:white;'><audio controls><source src="https://magnetosphere.net/music" type="audio/mpeg"><source src="https://magnetosphere.net/music" type="audio/ogg"><source src="https://magnetosphere.net/music" type="audio/wav">Your browser does not support the audio element.</audio></body></html>`))
		return nil
	})
	_, err := script.File(wasmExecLocation).Bytes()
	if err != nil {
		fmt.Printf("Error reading %s: %v\n", wasmExecLocation, err)
	} else { //the wasm exec must be present or none of the webassembly stuff will work ; provided by the golang installaton
		r.All("/wasm_exec.js", func(c *fiber.Ctx) error {
			wasmExecData, err := script.File(wasmExecLocation).Bytes()
			if err != nil {
				fmt.Printf("Error reading %s: %v\n", wasmExecLocation, err)
				c.SendStatus(fiber.StatusNotFound)
				return err
			}
			if c.Context().IsHead() {
				c.SendStatus(fiber.StatusOK)
				return nil
			}
			c.Status(fiber.StatusOK).Write(wasmExecData)
			return nil
		})
		r.All("/b.wasm", func(c *fiber.Ctx) error {
			compilecmd := `bash -c 'GOOS=js GOARCH=wasm go build -o /dev/stdout b.go'`
			data, err := script.Exec(compilecmd).Bytes()
			if err != nil {
				script.Exec(compilecmd).Stdout()
				c.SendStatus(fiber.StatusNotFound)
				return err
			}
			if c.Context().IsHead() {
				c.SendStatus(fiber.StatusOK)
				return nil
			}
			c.Set("Content-Type", "application/wasm")
			c.Status(fiber.StatusOK).Send(data)
			return nil
		})
		r.All("/c.wasm", func(c *fiber.Ctx) error {
			c.Set("Content-Type", "application/wasm")
			if c.Context().IsHead() {
				c.SendStatus(fiber.StatusOK)
				return nil
			}
			c.Status(fiber.StatusOK).Send(cWasm)
			return nil
		})
	}

	r.All("/m2.go", func(c *fiber.Ctx) error {
		return	serveSyntaxHighlighted(c)
	})
	r.All("/b.go", func(c *fiber.Ctx) error {
		return serveSyntaxHighlighted(c)
	})
	r.All("/stl.go", func(c *fiber.Ctx) error {
		return serveSyntaxHighlighted(c)
	})
	r.All("/m2.sh", func(c *fiber.Ctx) error {
		return serveSyntaxHighlighted(c)
	})
	r.Static("/tuicss.min.js", "./tuicss.min.js")
	r.Static("/tuicss.min.css", "./tuicss.min.css")
	r.Static("/tuicss.js", "./tuicss.js")
	r.Static("/tuicss.css", "./tuicss.css")
	r.Static("/images", "../../vinibiavatti1/TuiCss/dist/images")
	r.Static("/fonts", "../../vinibiavatti1/TuiCss/dist/fonts")
	r.Static("/font", "./font")
	var staticFiles = []string{"logo", "mobilelogo"}
	for _, file := range staticFiles {
		f := file
		fExt := filepath.Ext(f)
		r.All("/"+file, func(c *fiber.Ctx) error {

			switch fExt {
			case "":
				c.Set("Content-Type", "text/html;charset=utf-8")
				f += ".html"
			case ".css":
				c.Set("Content-Type", "text/css;charset=utf-8")
			case ".js":
				c.Set("Content-Type", "application/javascript;charset=utf-8")
			default:
				c.Set("Content-Type", "text/plain;charset=utf-8")
			}
			data, err := script.File(f).Bytes()
			if err != nil {
				c.SendStatus(fiber.StatusNotFound)
				fmt.Printf("Could not read file: %s\nError: %v\n", f, err)
				return err
			}
			c.Status(fiber.StatusOK).Write(data)
			return nil
		})
	}

	r.Static("/logo.png", "./logo.png")
	r.Static("/logo.html", "./logo.html")
	r.Static("/mobilelogo.html", "./mobilelogo.html")
	r.Static("/logolarge.html", "./logolarge.html")
	r.Static("/favicon.ico", "./img/favicon.ico")
	r.All("/robots.txt", func(c *fiber.Ctx) error {
		c.Set("Content-Type", "text/html;charset=utf-8")
		c.Status(fiber.StatusOK).Write([]byte(fmt.Sprintf("User-Agent: *\n\nSitemap: https://%s/sitemap", c.OriginalURL())))
		return nil
	})
	r.Static("/img", "./img")
	r.All("/stl/:filename", func(c *fiber.Ctx) error {
		stlfile, err := script.File("img/stl/" + c.Params("filename")).Bytes()
		if err != nil {
			c.SendStatus(fiber.StatusNotFound)
			return err
		}
		c.Write(stlfile)
		return nil
	})
	r.All("/stl/base64/:filename", func(c *fiber.Ctx) error {
		stlfile, err := script.File("img/stl/" + c.Params("filename")).Bytes()
		if err != nil {
			c.SendStatus(fiber.StatusNotFound)
			return err
		}
		base64Data := base64.StdEncoding.EncodeToString(stlfile)
		c.Status(fiber.StatusOK).Write([]byte("data:model/stl;base64,"+base64Data))
		return nil
	})

	r.All("/site.webmanifest", func(c *fiber.Ctx) error {
		c.JSON([]byte(`{"name":"","short_name":"","icons":[{"src":"/img/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/img/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}`))
		return nil
	})
	r.All("/sitemap", func(c *fiber.Ctx) error {
		c.XML(generateSitemapXML())
		return nil
	})
	r.All("/sitemap.xml", func(c *fiber.Ctx) error {
		c.XML(generateSitemapXML())
		return nil
	})

	r.All("/coffee", func(c *fiber.Ctx) error {
		c.SendStatus(fiber.StatusTeapot)
		return nil
	})

	r.All("/clock", func(c *fiber.Ctx) error {
		res1, _ := script.File("clock.html").Bytes()
		c.Set("Content-Type", "text/html;charset=utf-8")
		c.Status(fiber.StatusOK).Write([]byte(res1))
		return nil
	})

	r.All("/", func(c *fiber.Ctx) error {
		tmpl0, err1 := tmpl.Clone()
		if err1 != nil {
			fmt.Println("Error cloning template:", err1)
		}
		_, err1 = tmpl0.New("this").Parse(htmlFrontPageTemplate)
		if err1 != nil {
			fmt.Println("Error parsing Front Page template:", err1)
		}
		tmpl := tmpl0
		fmt.Println(c.Get("User-Agent"))
		c.Set("Content-Type", "text/html;charset=utf-8")
		htmlPageTemplateData1 := htmlPageTemplateData
		htmlPageTemplateData1.Canonical = "https://" + string(c.Request().Host()) + c.OriginalURL()
		htmlPageTemplateData1.Mobile = strings.Contains(strings.ToLower(c.Get("User-Agent")), "mobile")
		htmlPageTemplateData1.CatsCounts, htmlPageTemplateData1.Cats, htmlPageTemplateData1.SubCatsCounts, htmlPageTemplateData1.SubCatsByCat = getcategories()
		htmlPageTemplateData1.AboutHTML = htmpl.HTML(scriptFile("about.html"))
		htmlPageTemplateData1.LinksHTML = htmpl.HTML(scriptFile("links.html"))
		htmlPageTemplateData1.PolicyHTML = htmpl.HTML(scriptFile("policy.html"))
		htmlPageTemplateData1.LenAllProducts = len(allproducts)

		tmplData := map[string]interface{}{
			"Page":  htmlPageTemplateData1,
			"Prods": allproducts,
		}
		var result bytes.Buffer
		err = tmpl.Execute(&result, tmplData)
		if err != nil {
			fmt.Println("error: ", err)
			c.SendStatus(fiber.StatusInternalServerError)
			return err
		}
		c.Status(fiber.StatusOK).Write(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(result.Bytes(), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1))
		return nil
	})

	r.All("/p/:partno", func(c *fiber.Ctx) error {
		tmpl0, err1 := tmpl.Clone()
		if err1 != nil {
			fmt.Println("Error cloning template:", err1)
		}
		_, err1 = tmpl0.New("this").Parse(htmlProductPageTemplate)
		if err1 != nil {
			fmt.Println("Error parsing product page template:", err1)
		}
		tmpl := tmpl0
		c.Set("Content-Type", "text/html;charset=utf-8")
		for _, prod := range allproducts {
			if prod.Partno == c.Params("partno") {
				var result bytes.Buffer
				htmlPageTemplateData1 := htmlPageTemplateData
				htmlPageTemplateData1.Canonical = "https://" + string(c.Request().Host()) + c.OriginalURL()
				htmlPageTemplateData1.Title = fmt.Sprintf("%s | magnetosphere electronic surplus", prod.Name)
				htmlPageTemplateData1.Mobile = strings.Contains(strings.ToLower(c.Get("User-Agent")), "mobile")
				htmlPageTemplateData1.Page = "product"
				htmlPageTemplateData1.WasmBinary = func() string {
					if prod.Packagetype == "" {
						//fmt.Println("package type is empty")
						return ""
					}
					if !isAllUpperCase(prod.Packagetype) {
						//fmt.Println("package type is not all uppercase")
						return ""
					}
					var err error
					if _, err = os.Stat("./img/stl/" + prod.Packagetype + ".stl"); os.IsNotExist(err) {
						fmt.Printf("STL file not found for package: %s.stl\n%v", prod.Packagetype, err)
						return ""
					}
					cWasm, err = script.Exec(fmt.Sprintf(`bash -c 'GOOS=js GOARCH=wasm go build -ldflags="-X main.stlFileName=%s.stl" -o /dev/stdout stl.go'`, prod.Packagetype)).Bytes()
					if err != nil {
						fmt.Printf("Could not compile or read wasm file:\n%s\n%s\n%v\n", fmt.Sprintf(`bash -c 'GOOS=js GOARCH=wasm go build -ldflags="-X main.stlFileName=%s.stl" -o /dev/stdout stl.go'`, prod.Packagetype), string(cWasm), err)
						return ""
					}
					return "c.wasm"
				}()
				tmplData := map[string]interface{}{
					"Prod":  prod,
					"Page":  htmlPageTemplateData1,
					"Prods": allproducts,
				}
				err = tmpl.Execute(&result, tmplData)
				if err != nil {
					fmt.Println("error: ", err)
					c.Status(fiber.StatusInternalServerError).Write(result.Bytes())
					return err
				}
				c.Status(fiber.StatusOK).Write(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(result.Bytes(), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1))
				return nil
			}
		}
		fmt.Printf("product %s does not match any existing product\n", c.Params("partno"))
		c.Redirect("/cat", fiber.StatusMovedPermanently)
		return nil
	})
	r.All("/post/:partno", handlecat)
	r.All("/p", handlecat)
	r.All("/cat", handlecat)
	r.All("/cat/:cat", handlecat)
	r.All("/cat/:cat/:subcat", handlecat)
	r.All("/cart", func(c *fiber.Ctx) error {
		tmpl0, err1 := tmpl.Clone()
		if err1 != nil {
			fmt.Println("Error cloning template:", err1)
		}
		_, err1 = tmpl0.New("this").Parse(htmlCartPageTemplate)
		if err1 != nil {
			fmt.Println("Error parsing cart page template:", err1)
		}

		tmpl := tmpl0
		htmlPageTemplateData1 := htmlPageTemplateData
		htmlPageTemplateData1.Canonical = "https://" + string(c.Request().Host()) + c.OriginalURL()
		htmlPageTemplateData1.Title = "Cart | magnetosphere electronic surplus"
		htmlPageTemplateData1.Mobile = strings.Contains(strings.ToLower(c.Get("User-Agent")), "mobile")
		htmlPageTemplateData1.WasmBinary = ""
		htmlPageTemplateData1.Page = "cart"
		tmplData := map[string]interface{}{
			"Page": htmlPageTemplateData1,
		}
		var result bytes.Buffer
		err = tmpl.Execute(&result, tmplData)
		if err != nil {
			fmt.Println("error: ", err)
			c.Status(fiber.StatusInternalServerError).Write(result.Bytes())
			return err
		}
		c.Status(fiber.StatusOK).Write(result.Bytes())
		return nil
	})

	go func() {
		err := r.Listen(fmt.Sprintf(":%d", webPort))
		if err != nil {
			fmt.Println("Error serving http: ", err)
		}
		wg.Done()
	}()
	wg.Wait()
}

func scriptFile(a string) string {
	re, err := script.File(a).String()
	if err != nil {
		fmt.Printf("Error on script.File(%s).String(): %v", a, err)
	}
	return re
}

func isAllUpperCase(s string) bool {
	for _, char := range s {
		if unicode.IsLetter(char) && !unicode.IsUpper(char) {
			return false
		}
	}
	return true
}

func serveSyntaxHighlighted(c *fiber.Ctx) error {

	c.Set("Content-Type", "text/html;charset=utf-8")
	data, err := script.File(strings.TrimLeft(c.OriginalURL(), "/")).String()
	if err != nil {
		fmt.Println("error in function serveSyntaxHighlighted ; error on script.File: ", err)
		c.SendStatus(fiber.StatusNotFound)
		return err
	}
	lang := strings.TrimLeft(filepath.Ext(strings.TrimLeft(c.OriginalURL(), "/")), ".")
	if lang == "sh" {
		lang = "bash"
	}
	var buf bytes.Buffer
	err = quick.Highlight(&buf, data, lang, "html", "monokai")
	if err != nil {
		fmt.Println("error in function serveSyntaxHighlighted ; error on quick.Highlight: ", err)
		c.SendStatus(fiber.StatusInternalServerError)
		return err
	}
	if c.Context().IsHead() {
		c.SendStatus(fiber.StatusOK)
		return nil
	}
	c.Status(fiber.StatusOK).Write(buf.Bytes())
	return nil
}


func cathtmlfunc(c *fiber.Ctx) error {
	tmpl0, err1 := tmpl.Clone()
	if err1 != nil {
		fmt.Println("Error cloning template:", err1)
	}
	_, err1 = tmpl0.New("this").Parse(htmlCategoryPageTemplate)
	if err1 != nil {
		fmt.Println("Error parsing Category page template:", err1)
	}

	tmpl := tmpl0
	var tmplData map[string]interface{}
	var result bytes.Buffer
	var categoryproducts Products
	c.Set("Content-Type", "text/html;charset=utf-8")
	htmlPageTemplateData1 := htmlPageTemplateData
	htmlPageTemplateData1.Title = fmt.Sprintf("%s | magnetosphere electronic surplus", func() string {
		var str string
		if c.Params("partno") != "" {
			return "No product matching partno.: "+c.Params("partno")+" | Showing All Products"
		}
		if c.Params("cat") == "" {
			return "All Products"
		} else {
			str = fmt.Sprintf("Category: %s", c.Params("cat"))
		}
		if c.Params("subcat") != "" {
			str += fmt.Sprintf("; Subcategory: %s", c.Params("subcat"))
		}
		return str
	}())
	htmlPageTemplateData1.Canonical = "https://" + string(c.Request().Host()) + c.OriginalURL()
	htmlPageTemplateData1.Mobile = strings.Contains(strings.ToLower(c.Get("User-Agent")), "mobile")
	htmlPageTemplateData1.Page = "category"
	htmlPageTemplateData1.WasmBinary = ""
	htmlPageTemplateData1.CatsCounts, htmlPageTemplateData1.Cats, htmlPageTemplateData1.SubCatsCounts, htmlPageTemplateData1.SubCatsByCat = getcategories()
	if c.Params("cat") == "" && c.Params("subcat") == "" {
		tmplData = map[string]interface{}{
			"Products":    allproducts,
			"Page":        htmlPageTemplateData1,
			"Category":    c.Params("cat"),
			"Subcategory": c.Params("subcat"),
			"Prods":       allproducts,
			"Product":    c.Params("partno"),
		}
	} else {

		for _, prod := range allproducts {
			if prod.Category == c.Params("cat") && (c.Params("subcat") == "" || escapesubcat(prod.Subcategory) == c.Params("subcat")) {
				categoryproducts = append(categoryproducts, prod)
			}
		}
		tmplData = map[string]interface{}{
			"Products":    categoryproducts,
			"Page":        htmlPageTemplateData1,
			"Category":    c.Params("cat"),
			"Subcategory": c.Params("subcat"),
			"Prods":       allproducts,
		}
	}
	err := tmpl.Execute(&result, tmplData)
	if err != nil {
		fmt.Println("error: ", err)
		c.SendStatus(fiber.StatusInternalServerError)
		return err
	}
	c.Status(fiber.StatusOK).Write(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(bytes.Replace(result.Bytes(), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1), []byte("\n\n"), []byte("\n"), -1))
	return nil
}

func parseFloat(s string) float64 {
	if s == "" {
		return 0.0
	}
	value, err := strconv.ParseFloat(strings.TrimSpace(s), 64)
	if err != nil {
		fmt.Printf(`Error on strconv.ParseFloat(strings.TrimSpace(%s), 64): %v`, s, err)
	}
	return value
}

const shcmd = `/usr/bin/bash -c`

func getcats() (cats []string) {
	var catsMap = make(map[string]int)
	for _, prod := range allproducts {
		catsMap[prod.Category]++
	}
	for cat := range catsMap {
		cats = append(cats, cat)
	}
	return cats
}
func contains(slice []string, str string) bool {
	for _, s := range slice {
		if s == str {
			return true
		}
	}
	return false
}
func getcategories() (map[string]int, []string, map[string]map[string]int, map[string][]string) {
    categoryCounts := make(map[string]int)
    subcategoryCounts := make(map[string]map[string]int)
    subcategoriesByCategory := make(map[string][]string)

    for _, prod := range allproducts {
        if prod.Category != "" {
            categoryCounts[prod.Category]++
            if prod.Subcategory != "" {
                if subcategoryCounts[prod.Category] == nil {
                    subcategoryCounts[prod.Category] = make(map[string]int)
                }
                subcategoryCounts[prod.Category][prod.Subcategory]++
                if !contains(subcategoriesByCategory[prod.Category], prod.Subcategory) {
                    subcategoriesByCategory[prod.Category] = append(subcategoriesByCategory[prod.Category], prod.Subcategory)
                }
            }
        }
    }

    var sortableCategories []struct {
        Name  string
        Count int
    }
    for cat, count := range categoryCounts {
        sortableCategories = append(sortableCategories, struct {
            Name  string
            Count int
        }{Name: cat, Count: count})
    }
    sort.Slice(sortableCategories, func(i, j int) bool {
        return sortableCategories[i].Count > sortableCategories[j].Count
    })
    var sortedCategories []string
    for _, cat := range sortableCategories {
        sortedCategories = append(sortedCategories, cat.Name)
        var sortableSubcategories []struct {
            Name  string
            Count int
        }
        for subcat, count := range subcategoryCounts[cat.Name] {
            sortableSubcategories = append(sortableSubcategories, struct{ Name string; Count int }{Name: subcat, Count: count})
        }
        sort.Slice(sortableSubcategories, func(i, j int) bool {
            return sortableSubcategories[i].Count > sortableSubcategories[j].Count
        })
        var sortedSubcategories []string
        for _, subcat := range sortableSubcategories {
            sortedSubcategories = append(sortedSubcategories, subcat.Name)
        }
        subcategoriesByCategory[cat.Name] = sortedSubcategories
    }
    return categoryCounts, sortedCategories, subcategoryCounts, subcategoriesByCategory
}

var subcats []string

func getsubcats(cat string) (subcats []string) {
	var subcatsMap = make(map[string]int)
	for _, prod := range allproducts {
		if cat == "" || cat == prod.Category {
			if prod.Subcategory != "" {
				subcat := strings.Replace(prod.Subcategory, "¼", "quarter-", -1)
				subcat = strings.Replace(subcat, "½", "half-", -1)
				subcat = strings.Replace(subcat, "1/16", "sixteenth-", -1)
				subcat = strings.Replace(subcat, "%", "-pct", -1)
				subcat = strings.Replace(subcat, "  ", " ", -1)
				subcat = strings.Replace(subcat, " ", "-", -1)
				subcat = strings.Replace(subcat, "--", "-", -1)
				subcat = strings.Replace(subcat, "watt1", "watt-1", -1)
				subcat = strings.Replace(subcat, "watt5", "watt-5", -1)
				subcatsMap[subcat]++
			}
		}
	}
	for subcat := range subcatsMap {
		subcats = append(subcats, subcat)
	}
	return subcats
}
func escapesubcat(subcat string) (escapedsubcat string) {
	escapedsubcat = strings.Replace(subcat, "¼", "quarter-", -1)
	escapedsubcat = strings.Replace(escapedsubcat, "½", "half-", -1)
	escapedsubcat = strings.Replace(escapedsubcat, "1/16", "sixteenth-", -1)
	escapedsubcat = strings.Replace(escapedsubcat, "%", "-pct", -1)
	escapedsubcat = strings.Replace(escapedsubcat, "  ", " ", -1)
	escapedsubcat = strings.Replace(escapedsubcat, " ", "-", -1)
	escapedsubcat = strings.Replace(escapedsubcat, "--", "-", -1)
	escapedsubcat = strings.Replace(escapedsubcat, "watt1", "watt-1", -1)
	escapedsubcat = strings.Replace(escapedsubcat, "watt5", "watt-5", -1)
	return escapedsubcat
}

func handlecat(c *fiber.Ctx) error {
	if c.Params("cat") == "" && c.Params("subcat") == "" {
		cathtmlfunc(c)
		return nil
	}
	var catexists bool
	var subcatexists bool
	catexists = false
	for _, cat := range getcats() {
		if cat == c.Params("cat") {
			catexists = true
			break
		}
	}
	subcatexists = false
	if c.Params("subcat") != "" {
		for _, subcat := range getsubcats("") {
			if escapesubcat(subcat) == c.Params("subcat") {
				subcatexists = true
				break
			}
		}
	}
	if c.Params("subcat") != "" && !subcatexists {
		fmt.Printf("subcategory %s does not match any existing subcategory\n", c.Params("subcat"))
		c.Redirect("/cat/"+c.Params("cat"),http.StatusMovedPermanently)
		return nil
	}
	if !catexists {
		fmt.Printf("category %s does not match any existing category\n", c.Params("cat"))
		c.Redirect("/cat", http.StatusMovedPermanently )
		return nil
	}
	if catexists || (catexists && subcatexists) {
		cathtmlfunc(c)
		return nil
	}
	c.SendStatus(fiber.StatusNotFound)
	return nil
}

func getCatsAndSubcats(data []byte) ([]string, map[string][]string) {
	lines := strings.Split(string(data), "\n")
	categoryCounts := make(map[string]int)
	subcategoryMap := make(map[string][]string)
	for _, line := range lines {
		fields := strings.Split(line, ",")
		if len(fields) >= 14 && fields[3] == "TRUE" {
			category := fields[13]
			categoryCounts[category]++
			subcategory := fields[14]
			if len(subcategory) > 0 {
				subcategoryMap[category] = append(subcategoryMap[category], subcategory)
			}
		}
	}
	var cats []string
	for cat := range categoryCounts {
		cats = append(cats, cat)
	}
	sort.Strings(cats)
	return cats, subcategoryMap
}

const xmlSitemapTemplate = `{{$update := .Update}}{{$cats := .Cats}}{{$subcatsbycat := .SubCatsByCat}}{{$products := .Products}}<?xml version='1.0' encoding='UTF-8'?>
<urlset xmlns='http://www.sitemaps.org/schemas/sitemap/0.9'>
<url><loc>https://magnetosphere.net/</loc><lastmod>{{$update}}</lastmod><changefreq>daily</changefreq><priority>0.8</priority></url>
<url><loc>https://magnetosphere.net/cat</loc><lastmod>{{$update}}</lastmod><changefreq>daily</changefreq><priority>0.8</priority></url>
{{range $cat := $cats}}<url><loc>https://magnetosphere.net/cat/{{$cat}}</loc><lastmod>$update</lastmod><changefreq>daily</changefreq><priority>0.8</priority></url>{{end}}
{{range $cat := $cats}}{{range $subcat := getsubcats $cat}}<url><loc>https://magnetosphere.net/cat/{{$cat}}/{{$subcat}}</loc><lastmod>{{$update}}</lastmod><changefreq>daily</changefreq><priority>0.8</priority></url>{{end}}{{end}}
{{range .Products}}<url><loc>https://magnetosphere.net/p/{{.Partno}}</loc><lastmod>{{$update}}</lastmod><changefreq>daily</changefreq><priority>0.8</priority></url>{{end}}
</urlset>
`

type xmlTemplateData struct {
	Cats         []string
	SubCatsByCat map[string][]string
	Products     Products
	Update       string
}

func generateSitemapXML() string {
	xmlSitemapTemplateData := xmlTemplateData{
		Products: allproducts,
		Update:   time.Now().Format("2006-01-02"),
	}
	_, xmlSitemapTemplateData.Cats, _, xmlSitemapTemplateData.SubCatsByCat = getcategories()
	var err1 error
	xtmpl, err1 := ttmpl.New("index").Funcs(ttmpl.FuncMap{"getsubcats": getsubcats}).Parse(xmlSitemapTemplate)
	if err1 != nil {
		fmt.Println("Error parsing index template:", err1)
	}
	var result bytes.Buffer
	err1 = xtmpl.Execute(&result, xmlSitemapTemplateData)
	if err1 != nil {
		fmt.Println("error: ", err1)
	}
	return result.String()
}

func toFloat(s string) float64 {
	if s == "" {
		return 0.0
	}
	f, err := strconv.ParseFloat(s, 64)
	if err != nil {
		return 0.0
	}
	return f
}

const help = "\r\n" +
	"  {{if .HasAvailableSubCommands}}{{end}} {{if gt (len .Aliases) 0}}\r\n\r\n" +
	"{{.NameAndAliases}}{{end}}{{if .HasAvailableSubCommands}}\r\n\r\n" +
	"Available Commands:{{range .Commands}}{{if (or .IsAvailableCommand)}}\r\n  " +
	"{{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}}\r\n\r\n" +
	"Flags:\r\n" +
	"{{.LocalFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasAvailableInheritedFlags}}\r\n\r\n" +
	"Global Flags:\r\n" +
	"{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}\r\n\r\n"

type htmlTemplateData struct {
	Title          string
	MetaDesc       string
	Canonical      string
	KeyWords       string
	Style          htmpl.HTML
	Heading        htmpl.HTML
	SnipcartCart   htmpl.HTML
	SnipcartDiv    htmpl.HTML
	Cats           []string
	CatsCounts     map[string]int
	SubCatsCounts  map[string]map[string]int
	SubCatsByCat   map[string][]string
	LenAllProducts int
	Mobile         bool
	Gocanvas       htmpl.HTML
	WasmBinary     string
	WasmExecPath   string
	LogoImage      htmpl.HTML
	Message        htmpl.HTML
	Page           string
	AboutHTML      htmpl.HTML
	LinksHTML      htmpl.HTML
	PolicyHTML     htmpl.HTML
}

const htmlHeadTemplate = `<head>
<base  href='https://magnetosphere.net/'>
<meta charset='UTF-8'>
<meta name='viewport' content='width=device-width, initial-scale=1.0, maximum-scale=4.9,'>
<link rel='apple-touch-icon' sizes='180x180' href='/img/apple-touch-icon.png'>
<link rel='icon' type='image/png' sizes='32x32' href='/img/favicon-32x32.png'>
<link rel='icon' type='image/png' sizes='16x16' href='/img/favicon-16x16.png'>
<link rel='manifest' href='/site.webmanifest'>
<link rel='canonical' href='{{.Page.Canonical}}'>
<link rel='stylesheet' href='/tuicss.min.css'>
<title title='{{.Page.Title}}'>{{.Page.Title}}</title>
{{ if ne .Page.KeyWords ""}}<meta name='keywords' content='{{.Page.KeyWords}}'>{{end}}
{{if ne .Page.Page "product"}}{{ if ne .Page.MetaDesc ""}}<meta name='description' content='{{.Page.MetaDesc}}'>{{end}}{{else}}{{$p := .Prod }}<meta name='description' content='{{$p.Name}}{{if ne $p.Subcategory ""}} subcategory: {{$p.Subcategory}};{{end}} category: {{$p.Category}}{{if ne $p.Packagetype ""}} package: {{$p.Packagetype}};{{end}}{{if ne $p.Mfgname ""}} manufacturer: {{$p.Mfgname}};{{end}} {{if ne $p.Materials ""}} material: {{$p.Materials}};{{end}}{{if ne $p.Mfgpartno ""}} MPN: {{$p.Mfgpartno}};{{end}} price: ${{$p.Price}}; {{$p.Quantity}} in stock; condition: {{$p.Condition}} at Magnetosphere.'>{{end}}
{{if eq .Page.Page "product"}}{{$p := .Prod }}<script title='schema.org data for this product page' type='application/ld+json'>
{
"@context" : "http://schema.org",
"@type" : "Product",
"name" : "{{$p.Name}}",
"image" : "https://magnetosphere.net/img/{{$p.Category}}/{{$p.Image1}}",
"sku": "{{$p.Partno}}",
{{if ne $p.Mfgpartno ""}}"mpn": "{{$p.Mfgpartno}}",{{end}}
"description" : "{{$p.Name}}",
"productID" : "{{$p.Partno}}",
{{if ne $p.Mfgname ""}}"brand": {
"@type": "Brand",
"name": "{{$p.Mfgname}}"
},{{end}}
"offers" : {
"@type" : "Offer",
"priceCurrency": "USD",
"url" : "https://magnetosphere.net/p/{{$p.Partno}}",
"price" : "{{$p.Price}}",
{{if ne .Condition "used"}}"itemCondition": "https://schema.org/NewCondition",{{else}}"itemCondition": "https://schema.org/UsedCondition",{{end}}
"availability" : "https://schema.org/InStock",
"seller": {
"@type": "Organization",
"name": "magnetosphere.net",
"url": "https://magnetosphere.net"
},
"ShippingDetails": {
"@type": "OfferShippingDetails",
{{if and (ne $p.WeightOz "0") (ne $p.WeightOz "0.0") (ne $p.WeightOz "")}}"weight": {
"@type": "QuantitativeValue",
"value": {{$p.WeightOz}},
"unitCode": "oz"
},{{end}}
"shippingRate": {
"@type": "MonetaryAmount",
"value": 5.00,
"currency": "USD"
},
"deliveryTime": {
"@type": "ShippingDeliveryTime",
"businessDays": {
"@type": "OpeningHoursSpecification",
"dayOfWeek": [
"https://schema.org/Monday",
"https://schema.org/Tuesday",
"https://schema.org/Wednesday",
"https://schema.org/Thursday",
"https://schema.org/Friday"
]
},
"cutoffTime": "12:00:15Z",
"handlingTime": {
"@type": "QuantitativeValue",
"minValue": 1,
"maxValue": 2,
"unitCode": "d"
},
"transitTime": {
"@type": "QuantitativeValue",
"minValue": 1,
"maxValue": 10,
"unitCode": "d"
}
}
}
}
}
</script>{{end}}
<style title='css styling for magnetosphere.net'>
@font-face {
    font-family: 'mononokiregular';
    src: url(data:application/font-woff2;charset=utf-8;base64,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) format('woff2'),
         url(data:application/font-woff;charset=utf-8;base64,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) format('woff'),
         url('font/mononoki-regular-webfont.ttf') format('truetype');
    font-weight: normal;
    font-style: normal;
}

@font-face {
    font-family: 'mononokibold';
    src: url(data:application/font-woff2;charset=utf-8;base64,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) format('woff2'),
         url(data:application/font-woff;charset=utf-8;base64,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) format('woff'),
         url('font/mononoki-bold-webfont.ttf') format('truetype');
    font-weight: normal;
    font-style: normal;
}

body {
	font-family:mononokiregular;
}
pre {
	font-family:mononokiregular;
	font-size:10pt;
}
.af_line {
	color: gray;
	text-decoration: none;
}
.column {
	float: left;
	width: 30%;
	padding: 10px;
}
.row:after {
	content: '';
	display: table;
	clear: both;
}
#gocanvas-container {
	position: absolute;
	top: 0;
	height: 100%;
	width: 90%;
	overflow-x: hidden;
	overflow-y: hidden;
	pointer-events: none;
	z-index: 3;
}
#gocanvas {
	max-width: 100vw;
	max-height: 100vh;
}
header {
	position: fixed;
	top: 0;
	width: 100%;
	padding: 0;
	margin: 0;
}
footer {
	position: fixed;
	bottom: 0;
	width: 100%;
	padding: 0;
	margin: 0;
}
main {
	text-align: center;
	padding-top: 10px;
	padding-bottom: 10px;
	padding-left: 10px;
	padding-right: 10px;
}
a {
	color: cyan;
    background-color: black;
}
a:hover {
  color: green;
}
a:visited {
  color: gray;
}
a:active {
  color: gray;
}
a:active:hover {
  color: green;
}
a:visited:hover {
  color: green;
}
a.cur {
	color: orange;
	background-color: white;
}
.nv {
	background-color: white;
	color:black;
	font-family: mononokibold;
}
li {
 background-color: black;
}
.tab-folder > .tab-content:target ~ .tab-content:last-child, .tab-folder > .tab-content {
display: none;
}
.tab-folder > :last-child, .tab-folder > .tab-content:target {
display: block;
}
.tab-folder1 > .tab-content1:target ~ .tab-content1:last-child, .tab-folder1 > .tab-content1 {
display: none;
}
.tab-folder1 > :last-child, .tab-folder1 > .tab-content1:target {
display: block;
}
details summary {
  cursor: pointer;
}
details > summary {
  list-style: none;
  cursor: pointer;
}
details > summary::-webkit-details-marker {
    display: none;
}
details {
  position: relative;
}
details ul {
  display: block;
  list-style: none;
  padding: 0;
  border: 2px solid black;
  width: 100px;
  z-index: 0;
  position: absolute;
  background: black;
  color: white;
}
{{if eq .Page.Page "front"}}.a {
	color:#0000ee;
	background-color:#000000;
}
.b {
	text-decoration:blink;
	color:#e5e5e5;
	background-color:#e5e5e5;
}
.c {
	text-decoration:blink;
	color:#e5e5e5;
	background-color:#000000;
}
.d {
	font-weight:bold;
	color:#7f7f7f;
	background-color:#e5e5e5;
}
.e {
	color:#00cd00;
	background-color:#000000;
}
.f {
	color:#cd0000;
	background-color:#000000;
}
.g {
	text-decoration:blink;
	color:#00cdcd;
	background-color:#000000;
}
.h {
	font-weight:bold;
	color:#ffffff;
	background-color:#e5e5e5;
}
.i {
	text-decoration:blink;
	color:#000000;
	background-color:#000000;
}
.j {
	text-decoration:blink;
	color:#cdcd00;
	background-color:#000000;
}
.k {
	text-decoration:blink;
	color:#cd00cd;
	background-color:#000000;
}{{end}}
</style>
<script title='snipcart script'>
window.SnipcartSettings = {
	publicApiKey: "ZjMxZTEwMzEtMzFhZS00YjQyLTgxNDMtMTM4ZjVlZmFlMDY1NjM3MjkzMjU0MTU5NTQyMzU0",
	loadStrategy: "on-user-interaction",
	modalStyle: "side",
};
(()=>{var a,d;(d=(a=window.SnipcartSettings).version)!=null||(a.version="3.0");var s,S;(S=(s=window.SnipcartSettings).currency)!=null||(s.currency="usd");var l,p;(p=(l=window.SnipcartSettings).timeoutDuration)!=null||(l.timeoutDuration=2750);var w,u;(u=(w=window.SnipcartSettings).domain)!=null||(w.domain="cdn.snipcart.com");var m,g;(g=(m=window.SnipcartSettings).protocol)!=null||(m.protocol="https");var y=window.SnipcartSettings.version.includes("v3.0.0-ci")||window.SnipcartSettings.version!="3.0"&&window.SnipcartSettings.version.localeCompare("3.4.0",void 0,{numeric:!0,sensitivity:"base"})===-1,f=["focus","mouseover","touchmove","scroll","keydown"];window.LoadSnipcart=o;document.readyState==="loading"?document.addEventListener("DOMContentLoaded",r):r();function r(){window.SnipcartSettings.loadStrategy?window.SnipcartSettings.loadStrategy==="on-user-interaction"&&(f.forEach(t=>document.addEventListener(t,o)),setTimeout(o,window.SnipcartSettings.timeoutDuration)):o()}var c=!1;function o(){if(c)return;c=!0;let t=document.getElementsByTagName("head")[0],e=document.querySelector("#snipcart"),i=document.querySelector(` + "`" + ` src[src^="${window.SnipcartSettings.protocol}://${window.SnipcartSettings.domain}"][src$="snipcart.js"]` + "`" + `),n=document.querySelector(` + "`" + `link[href^="${window.SnipcartSettings.protocol}://${window.SnipcartSettings.domain}"][href$="snipcart.css"]` + "`" + `);e||(e=document.createElement("div"),e.id="snipcart",e.setAttribute("hidden","true"),document.body.appendChild(e)),h(e),i||(i=document.createElement("script"),i.src=` + "`" + `${window.SnipcartSettings.protocol}://${window.SnipcartSettings.domain}/themes/v${window.SnipcartSettings.version}/default/snipcart.js` + "`" + `,i.async=!0,t.appendChild(i)),n||(n=document.createElement("link"),n.rel="stylesheet",n.type="text/css",n.href=` + "`" + `${window.SnipcartSettings.protocol}://${window.SnipcartSettings.domain}/themes/v${window.SnipcartSettings.version}/default/snipcart.css` + "`" + `,t.prepend(n)),f.forEach(v=>document.removeEventListener(v,o))}function h(t){!y||(t.dataset.apiKey=window.SnipcartSettings.publicApiKey,window.SnipcartSettings.addProductBehavior&&(t.dataset.configAddProductBehavior=window.SnipcartSettings.addProductBehavior),window.SnipcartSettings.modalStyle&&(t.dataset.configModalStyle=window.SnipcartSettings.modalStyle),window.SnipcartSettings.currency&&(t.dataset.currency=window.SnipcartSettings.currency),window.SnipcartSettings.templatesUrl&&(t.dataset.templatesUrl=window.SnipcartSettings.templatesUrl))}})();
</script>{{ if ne .Page.WasmBinary ""}}

<script title='runtime.GOROOT() + "/misc/wasm/wasm_exec.js" = {{.Page.WasmExecPath}}' src="/wasm_exec.js"></script>
<script title='bolier-plate script to launch webassembly'>
if (!WebAssembly.instantiateStreaming) {
		WebAssembly.instantiateStreaming = async (resp, importObject) => {
				const source = await (await resp).arrayBuffer();
				return await WebAssembly.instantiate(source, importObject);
		};
}
const go = new Go();
let mod, inst;
WebAssembly.instantiateStreaming(fetch("/{{.Page.WasmBinary}}"), go.importObject).then((result) => {
		mod = result.module;
		inst = result.instance;
		run().then((result) => {
				console.log("Ran WASM: ", result)
		}, (failure) => {
				console.log("Failed to run WASM: ", failure)
		})
});
async function run() {
		await go.run(inst);
		inst = await WebAssembly.instantiate(mod, go.importObject);
}
</script>{{end}}</head>
`
const htmlHeaderTemplate = `{{ $page := .Page }}{{$lenall := $page.LenAllProducts}}{{$thiscat := .Category}}{{$cats := $page.Cats}}{{ $catsLen := len $cats }}{{$catscounts := $page.CatsCounts}}{{$thissubcat := .Subcategory}}{{ $lenallString := printf "%d" $lenall }}{{ $lenlenallString := len $lenallString }}<header><nav class='absolute' style='white-space: nowrap;'><ul id='menu' style='background-color: black;'><li class='tui-dropdown' style='background-color: black;'>
<details><summary title='drop down menu'>Categories</summary><ul>
<li class='tui-dropdown' style='display: flex; font-size:10pt;'>├──{{$lenall}}&nbsp;<a style='color: cyan; background-color: black;' onmouseover='this.style.color="green"' onmouseout='this.style.color="cyan"' onmousedown='this.style.color="gray"' onmouseup='this.style.color="green"' title='All Products' href='/cat'>All Products</a></li>
{{range $catindex, $cat := $cats}}{{$catcount := index $page.CatsCounts $cat}}{{$catcountString := printf "%d" $catcount }}{{ $lencatcountString := len $catcountString }}{{$diff := sub $lenlenallString $lencatcountString}}{{$padding := repeat "─" $diff}}
<details {{if eq $cat $thiscat}}open{{end}}><summary><li style='display: flex; font-size:10pt; align-items: center;' {{if or (ne $cat $thiscat) (ne $thissubcat "")}}{{else}}class='nv'{{end}}>{{if eq (add $catindex 1) $catsLen}}└{{else}}├{{end}}─{{if index $page.SubCatsByCat $cat}}┬{{else}}─{{end}}{{safeHTML $padding}}{{$catcount}}&nbsp;<a title='{{if or (ne $cat $thiscat) (ne $thissubcat "")}}{{else}}You are here&#10;{{end}}Product Category: {{$cat}}' href='/cat/{{$cat}}' {{if or (ne $cat $thiscat) (ne $thissubcat "")}}{{else}}class='cur'{{end}}>{{$cat}}</a></li></summary>{{$subcats := index $page.SubCatsByCat $cat}}{{ $subcatsSorted := $subcats }}{{ $subcatsLen := len $subcatsSorted }}{{range $index, $subcat := $subcatsSorted}}{{$subcatcount := index (index $page.SubCatsCounts $cat) $subcat}}{{$subcatcountString := printf "%d" $subcatcount }}{{ $lensubcatcountString := len $subcatcountString }}{{$diff := sub $lencatcountString $lensubcatcountString}}{{$extrapadding := repeat "─" $diff}}
<li style='display: flex; font-size:10pt; align-items: center; white-space: nowrap;'{{if ne $thissubcat (escapesubcat $subcat)}}{{else}}class='nv'{{end}} >{{if ne (add $catindex 1) $catsLen}}│{{else}}&nbsp;{{end}}{{ if eq (add $index 1) $subcatsLen }} └{{ else }} ├{{ end }}{{safeHTML $extrapadding}}{{safeHTML $padding}}{{$subcatcount}}&nbsp;<a title='{{if eq $thissubcat (escapesubcat $subcat)}}You are here&#10;{{end}}Product Category: {{$cat}};&#10; Product Subcategory: {{escapesubcat $subcat}}' href='/cat/{{$cat}}/{{escapesubcat $subcat}}' {{if eq $thissubcat (escapesubcat $subcat)}}class='cur'{{end}}>{{$subcat}}</a></li>{{end}}</details>{{end}}</ul></details></li>
<li class='tui-dropdown'><a title='Navigate Home' href='#'>Home</a></li>&nbsp;<li class='tui-dropdown'><details><summary title='dropdown menu'>Etc...</summary><ul><li><a title='about magnetosphere electronic surplus' href='#about'>About</a></li><li><a title='shipping and refund policy' href='#policy'>Policy</a></li><li><a title='view our telegram channel&#10;pictures of unlisted inventory' href='https://t.me/magnetospheredotnet'>Telegram</a></li><li><a title='get in touch via telegram' href='https://t.me/magnetosphere'>Contact</a></li>{{if .Page.Mobile}}{{else}}<li><a title='other misc. links' href='#links'>Links</a></li>{{end}}</ul></details></li></ul></nav>{{.Page.SnipcartDiv}}</header>
`
const htmlHeaderTemplate1 = `{{ $page := .Page }}{{$lenall := $page.LenAllProducts}}{{$thiscat := .Category}}{{$cats := $page.Cats}}{{ $catsLen := len $cats }}{{$catscounts := $page.CatsCounts}}{{$thissubcat := .Subcategory}}{{ $lenallString := printf "%d" $lenall }}{{ $lenlenallString := len $lenallString }}<header><nav class='absolute' style='white-space: nowrap;'><ul id='menu' style='background-color: black;'><li class='tui-dropdown' style='background-color: black;'>
<details><summary title='drop down menu'>Categories</summary><ul>
<li class='tui-dropdown' style='display: flex; font-size:10pt;'>├──{{$lenall}}&nbsp;<a style='color: cyan; background-color: black;' onmouseover='this.style.color="green"' onmouseout='this.style.color="cyan"' onmousedown='this.style.color="gray"' onmouseup='this.style.color="green"' title='All Products' href='/cat'>All Products</a></li>
{{range $catindex, $cat := $cats}}{{$catcount := index $page.CatsCounts $cat}}{{$catcountString := printf "%d" $catcount }}{{ $lencatcountString := len $catcountString }}{{$diff := sub $lenlenallString $lencatcountString}}{{$padding := repeat "─" $diff}}
<details {{if eq $cat $thiscat}}open{{end}}><summary><li style='display: flex; font-size:10pt; align-items: center;' {{if or (ne $cat $thiscat) (ne $thissubcat "")}}{{else}}class='nv'{{end}}>{{if eq (add $catindex 1) $catsLen}}└{{else}}├{{end}}─{{if index $page.SubCatsByCat $cat}}┬{{else}}─{{end}}{{safeHTML $padding}}{{$catcount}}&nbsp;<a title='{{if or (ne $cat $thiscat) (ne $thissubcat "")}}{{else}}You are here&#10;{{end}}Product Category: {{$cat}}' href='/cat/{{$cat}}' {{if or (ne $cat $thiscat) (ne $thissubcat "")}}{{else}}class='cur'{{end}}>{{$cat}}</a></li></summary>{{$subcats := index $page.SubCatsByCat $cat}}{{ $subcatsSorted := $subcats }}{{ $subcatsLen := len $subcatsSorted }}{{range $index, $subcat := $subcatsSorted}}{{$subcatcount := index (index $page.SubCatsCounts $cat) $subcat}}{{$subcatcountString := printf "%d" $subcatcount }}{{ $lensubcatcountString := len $subcatcountString }}{{$diff := sub $lencatcountString $lensubcatcountString}}{{$extrapadding := repeat "─" $diff}}
<li style='display: flex; font-size:10pt; align-items: center; white-space: nowrap;'{{if ne $thissubcat (escapesubcat $subcat)}}{{else}}class='nv'{{end}} >{{if ne (add $catindex 1) $catsLen}}│{{else}}&nbsp;{{end}}{{ if eq (add $index 1) $subcatsLen }} └{{ else }} ├{{ end }}{{safeHTML $extrapadding}}{{safeHTML $padding}}{{$subcatcount}}&nbsp;<a title='{{if eq $thissubcat (escapesubcat $subcat)}}You are here&#10;{{end}}Product Category: {{$cat}};&#10; Product Subcategory: {{escapesubcat $subcat}}' href='/cat/{{$cat}}/{{escapesubcat $subcat}}' {{if eq $thissubcat (escapesubcat $subcat)}}class='cur'{{end}}>{{$subcat}}</a></li>{{end}}</details>{{end}}</ul></details></li>
<li class='tui-dropdown'><a title='Navigate Home' href='#'>Home</a></li>&nbsp;<li class='tui-dropdown'><details><summary title='dropdown menu'>Etc...</summary><ul><li><a title='about magnetosphere electronic surplus' href='#about'>About</a></li><li><a title='shipping and refund policy' href='#policy'>Policy</a></li><li><a title='view our telegram channel&#10;pictures of unlisted inventory' href='https://t.me/magnetospheredotnet'>Telegram</a></li><li><a title='get in touch via telegram' href='https://t.me/magnetosphere'>Contact</a></li>{{if .Page.Mobile}}{{else}}<li><a title='other misc. links' href='#links'>Links</a></li>{{end}}</ul></details></li></ul></nav>{{.Page.SnipcartDiv}}</header>
`



const htmlMainPageTemplate = `
{{ $page := .Page }}<!doctype html><html lang='en'>
{{template "head" .}}
<body title='' style='background-color:black;color:white;'>{{template "header" .}}
<main>
{{ if or .Page.Mobile (eq .Page.Page "cart") }}{{else}}<div style='float: right; position: fixed; top: 0; right: 0; padding-bottom: 10px; width: 200px; height: 100%; overflow-y: auto;'>
<details title='product categories' open><summary title='click to collapse'><h2 style='background-color: black; color: white;'>Categories:</h2></summary>
<pre style='background-color: black; color: white;'>{{.Page.LenAllProducts}} <a title='All Products' href='/cat'>All</a></pre>
{{$thiscat := .Category}}{{$thissubcat := .Subcategory}}{{range $cat := $page.Cats}}{{if eq $cat $thiscat}}<pre style='background-color: white; color: black;'>{{index $page.CatsCounts $cat}} <a  title='Product Category: {{$cat}}' href='{{if eq $page.Page "front"}}#cat-{{$cat}}{{else}}/cat/{{$cat}}{{end}}'>{{$cat}}</a></pre>{{else}}<pre style='background-color: black; color: white;'>{{index $page.CatsCounts $cat}} <a  title='Product Category: {{$cat}}' href='{{if eq $page.Page "front"}}#cat-{{$cat}}{{else}}/cat/{{$cat}}{{end}}'>{{$cat}}</a></pre>{{end}}{{end}}
{{if eq .Page.Page "category"}}{{if index $page.SubCatsByCat $thiscat}}<details  title='product subcategories for category: {{$thiscat}}' open><summary title='click to collapse'><h2 style='background-color: black; color: white;'>Subcategories:</h2></summary>
{{range $subcat := index $page.SubCatsByCat $thiscat}}{{if eq $subcat $thissubcat}}<pre style='background-color: white; color: black;'>{{index (index $page.SubCatsCounts $thiscat) $subcat}} <a  title='Product Category: {{$subcat}}' href='/cat/{{$thiscat}}/{{$subcat}}'>{{$subcat}}</a></pre>{{else}}<pre style='background-color: black; color: white;'>{{index (index $page.SubCatsCounts $thiscat) $subcat}} <a  title='Product Category: {{$subcat}}' href='/cat/{{$thiscat}}/{{$subcat}}'>{{$subcat}}</a></pre>{{end}}{{end}}</details>{{end}}{{end}}</details></div>{{end}}
{{template "this" .}}
</main>
{{ if ne .Page.Page "cart"}}<footer><table style='padding: 0; margin: 0;width: 100%; border-collapse: collapse;'><tr style='padding: 0; margin: 0; border-bottom: 1px solid blue;'><td style='padding: 0; margin: 0; width: 33.33%; text-align: center; background-color: black;'><span style='font-size:0.8em; white-space: nowrap;'>&nbsp;<a title='shopping cart' href='/cart'><span style='color:red' class='snipcart-checkout'><span style='text-decoration: underline;'>cart:<span class='snipcart-items-count'></span> <span class='snipcart-total-price'></span></span></span></a>&nbsp;</span></td><td id='middletd' style='padding: 0; margin: 0; width: 33.33%; text-align: center; color: red; background-color: black;'>&nbsp;&nbsp;</td><td style='padding: 0; margin: 0; width: 33.33%; text-align: center; background-color: black;'><span style='font-size:0.1em; white-space: nowrap;'>&nbsp;© 2005-2023 <a  title='magnetosphere.net' href='/'>magnetosphere.net</a> All Rights Reserved&nbsp;</span></td></tr></table></footer>{{end}}
</body></html>
`
const htmlCartPageTemplate = `<h1 style='font-family:Courier New; font-size:10pt'>Cart</h1>{{.Page.SnipcartCart}}`
const htmlCategoryPageTemplate = `
<br><h1 style='font-family:Courier New; font-size:10pt'>{{if eq .Category ""}}All Products{{else}}Category: <a title='Category: {{.Category}}' href='/cat/{{.Category}}'>{{.Category}}</a>{{if ne .Subcategory ""}}{{$index0 := index .Products 0}} | Subcategory: <a title='Category: {{.Category}} Subcategory: {{$index0.Subcategory}}' href='/cat/{{.Category}}/{{.Subcategory}}'>{{$index0.Subcategory}}</a>{{end}}{{end}}</h1>
{{ if .Page.Mobile }}<div style='word-wrap: break-word;'>{{range .Products}}
<div><a title='Read more about {{.Partno}}' href='/p/{{.Partno}}'><img style='max-width: 20%; max-height: 20%;' src='/img/{{.Category}}/{{.Image1}}' alt='{{.Name}}' loading='lazy'></a></div>
{{.Name}}<br>Price: ${{.Price}} ; In stock: {{.Quantity}}
<button class='snipcart-add-item' data-item-id='{{.Partno}}' data-item-name='{{.Partno}}' data-item-image='/img/{{.Category}}/{{.Image1}}' data-item-price='{{.Price}}'	data-item-description='{{.Name}}' data-item-min-quantity='1' data-item-quantity='1'	data-item-quantity-step='1' data-item-shippable='true' data-item-weight='{{printf "%.0f" (mul (toFloat .WeightOz) 28.3495)}}' data-item-length='{{printf "%.0f" (mul (toFloat .LengthInches) 2.54)}}' data-item-width='{{printf "%.0f" (mul (toFloat .WidthInches) 2.54)}}' data-item-height='{{printf "%.0f" (mul (toFloat .HeightInches) 2.54)}}' data-item-has-taxes-included='false' {{if eq .Quantity "0"}}disabled{{end}}>Add to cart</button> <a title='Read more about {{.Partno}}' href='/p/{{.Partno}}'>Read More</a><hr>{{end}}</div>{{else}}
<table style='height: 90%; width: 90%; border-collapse: collapse; white-space: nowrap; '>
<thead><tr style='border-bottom: 1px solid purple;'><th style='width: 20.0%;'>Image</th><th style='width: 20.0%;'>Name</th><th style='width: 20.0%;'>Price</th><th style='width: 20.0%;'>Stock</th><th style='width: 20.0%;'>Buy</th><th style='width: 20.0%;'></th></tr></thead>
<tbody>{{range .Products}}
<tr style='border-bottom: 1px solid blue;'><td style='width: 20.0%; text-align: center;'><a title='Read more about {{.Partno}}' href='/p/{{.Partno}}'><img style='max-width: 20%; max-height: 20%;' src='/img/{{.Category}}/{{.Image1}}' alt='{{.Name}}' loading='lazy'></a></td><td style='width: 20.0%; text-align: center;'>{{.Name}}</td><td style='width: 20.0%; text-align: center;'>${{.Price}}</td><td style='width: 20.0%; text-align: center;'>{{.Quantity}}</td><td style='width: 20.0%; text-align: center;'>{{if ne .Quantity "0"}}<button class='snipcart-add-item' data-item-id='{{.Partno}}'	data-item-name='{{.Partno}}' data-item-image='/img/{{.Category}}/{{.Image1}}' data-item-price='{{.Price}}'	data-item-description='{{.Name}}'	data-item-min-quantity='1'	data-item-quantity='1'	data-item-quantity-step='1' data-item-shippable='true' data-item-weight='{{printf "%.0f" (mul (toFloat .WeightOz) 28.3495)}}' data-item-length='{{printf "%.0f" (mul (toFloat .LengthInches) 2.54)}}' data-item-width='{{printf "%.0f" (mul (toFloat .WidthInches) 2.54)}}' data-item-height='{{printf "%.0f" (mul (toFloat .HeightInches) 2.54)}}' data-item-has-taxes-included='false'>Add to cart</button></td>{{end}}<td style='width: 20.0%;'></td></tr>{{end}}</tbody></table>{{end}}
`

const htmlProductPageTemplate = `{{$p := .Prod }}<br><br><br><br>
<div style='word-wrap: break-word;text-align: left;' itemscope itemtype='https://schema.org/Product' itemid='{{$p.Partno}}'>
<h1 title='{{$p.Name}}' itemprop='name'>{{$p.Name}}</h1>
<img style='max-width: 80%; max-height: 60%;' src='/img/{{$p.Category}}/{{$p.Image1}}' alt='{{$p.Name}}'><br>
<pre title='${{$p.Price}}' itemprop='price'>Price: ${{$p.Price}}</pre>
<pre title='{{$p.Quantity}} in stock'>In stock: {{$p.Quantity}}</pre>
{{if ne $p.Quantity "0"}}<pre><button class='snipcart-add-item' data-item-id='{{$p.Partno}}' data-item-name='{{$p.Partno}}' data-item-image='/img/{{$p.Category}}/{{$p.Image1}}' data-item-price='{{$p.Price}}' data-item-description='{{$p.Name}}' data-item-min-quantity='1' data-item-quantity='1' data-item-quantity-step='1' data-item-shippable='true' data-item-weight='{{printf "%.0f" (mul (toFloat $p.WeightOz) 28.3495)}}' data-item-length='{{printf "%.0f" (mul (toFloat $p.LengthInches) 2.54)}}' data-item-width='{{printf "%.0f" (mul (toFloat $p.WidthInches) 2.54)}}' data-item-height='{{printf "%.0f" (mul (toFloat $p.HeightInches) 2.54)}}' data-item-has-taxes-included='false'>Add to cart</button></pre><pre>partno: {{$p.Partno}}</pre>{{end}}
{{if equalsIgnoreCase $p.Description1 $p.Name}}{{else}}{{if ne $p.Description1 ""}}<p style='font-family:Courier New; font-size:10pt; word-wrap: break-word;'>{{safeHTML $p.Description1}}</p>{{end}}{{end}}
{{if ne $p.Mfgname ""}}<pre>Brand: {{$p.Mfgname}}</pre>{{end}}
{{if ne $p.Mfgpartno ""}}<pre itemprop='mpn'>MPN: {{$p.Mfgpartno}}</pre>{{end}}
<pre>Category: <a title='Product Category: {{$p.Category}}' href='/cat/{{$p.Category}}'>{{$p.Category}}</a></pre>
{{- $subcategorylink := replace $p.Subcategory "¼" "quarter-" -}}{{- $subcategorylink = replace $subcategorylink "½" "half-" -}}{{- $subcategorylink = replace $subcategorylink "1/16" "sixteenth-" -}}{{- $subcategorylink = replace $subcategorylink "%" "-pct" -}}{{- $subcategorylink = replace $subcategorylink "  " " " -}}{{- $subcategorylink = replace $subcategorylink "watt1" "watt-1" -}}{{- $subcategorylink = replace $subcategorylink "watt5" "watt-5" -}}{{- $subcategorylink = replace $subcategorylink " " "-" -}}{{- $subcategorylink = replace $subcategorylink "--" "-" -}}{{if ne $p.Subcategory ""}}<pre>Subcategory: <a title='Product SubCategory: {{$p.Subcategory}}' href='/cat/{{$p.Category}}/{{ $subcategorylink }}'>{{$p.Subcategory}}</a></pre>{{end}}
{{if and (ne $p.VoltsRating "0") (ne $p.VoltsRating "0.0") (ne $p.VoltsRating "")}}<pre>Voltage: {{$p.VoltsRating}}</pre>{{end}}
{{if and (ne $p.Value "0") (ne $p.Value "0.0") (ne $p.Value "")}}<pre>Value: {{$p.Value}}{{$p.ValUnit}}</pre>{{end}}
{{if and (ne $p.AmpsRating "0") (ne $p.AmpsRating "0.0") (ne $p.AmpsRating "")}}<pre>Amperage: {{$p.AmpsRating}}</pre>{{end}}
{{if and (ne $p.Tolerance "0") (ne $p.Tolerance "")}}{{- $tolerancePercent := printf "%.2f%%" (mul 100 (toFloat $p.Tolerance)) -}}<pre>Tolerance: {{$tolerancePercent}}</pre>{{end}}
{{if ne $p.Typ ""}}<pre>Typ: {{$p.Typ}}</pre>{{end}}
{{if ne $p.Packagetype ""}}<pre>Package Type: {{$p.Packagetype}}</pre>{{end}}
{{if ne $p.Technology ""}}<pre>Technology: {{$p.Technology}}</pre>{{end}}
{{if ne $p.Materials ""}}<pre>Materials: {{$p.Materials}}</pre>{{end}}
{{if and (ne $p.WattsRating "0") (ne $p.WattsRating "0.0") (ne $p.WattsRating "")}}<pre>Watts Rating: {{$p.WattsRating}}</pre>{{end}}
{{if and (ne $p.Year "0") (ne $p.Year "")}}<pre>Year: {{$p.Year}}</pre>{{end}}
{{if and (ne $p.CableLengthInches "0") (ne $p.CableLengthInches "0.0") (ne $p.CableLengthInches "")}}<pre>Cable Length: {{$p.CableLengthInches}} inches</pre>{{end}}
{{if and (ne $p.WeightOz "0") (ne $p.WeightOz "0.0")}}<pre>Weight: {{$p.WeightOz}} oz</pre>{{end}}
{{if and (ne $p.TempRating "0") (ne $p.TempRating "0.0")}}<pre>Temp rating: {{$p.TempRating}}{{$p.TempUnit}}</pre>{{end}}
{{if ne $p.Condition ""}}<pre>Condition: {{$p.Condition}}</pre>{{end}}
{{if ne $p.Datasheet ""}}<pre>Datasheet: <a title='Product Datasheet: {{$p.Datasheet}}' href='/img/pdf/{{$p.Datasheet}}'>{{$p.Datasheet}}</a></pre>{{end}}
{{if ne $p.Docs ""}}<pre>Documentation: {{safeHTML  $p.Docs}}</pre>{{end}}
{{if ne $p.Note ""}}<pre>Note: {{safeHTML  $p.Note}}</pre>{{end}}
{{if ne $p.Warning ""}}<pre>Warning: {{safeHTML  $p.Warning}}</pre>{{end}}
{{if ne $p.Description2 ""}}<pre>Additional Description: {{safeHTML  $p.Description2}}</pre>{{end}}
</div>{{.Page.Gocanvas}}<br><br><br>
`
const htmlFrontPageTemplate = `
<h1 title='magnetosphere electronic surplus' style='background:black;'>magnetosphere electronic surplus</h1> <h2 title='we can rebuild him' style='font-size:10pt; background-color: black; color: white;'>- we have the technology -</h2><h3 style='font-size:22pt;padding:0; margin:0;'><span class='nv'>m</span>a<span class='nv'>g</span>n<span class='nv'>e</span>t<span class='nv'>o</span>s<span class='nv'>p</span>h<span class='nv'>e</span>r<span class='nv'>e</span>.<span class='nv'>n</span>e<span class='nv'>t</span></h3>
<div class='tab-folder'>
{{if .Page.Mobile}}{{else}}
<div id='categories' class='tab-content'><div style='padding: 50px;' class='center'><div class='tui-window' style='text-align: left;'><fieldset class='tui-fieldset'><legend class='center'>Categories</legend>
<table class='tui-table hovered-cyan' ><thead><tr><th>Count</th><th>Name</th></tr></thead>
<tbody><tr><td>{{.Page.LenAllProducts}}</td><td><a title='Product Category: All' href='/cat/'>All</a></td></tr>{{$cats := .Page.Cats}}{{$catscounts := .Page.CatsCounts}}{{range $cat := $cats}}
<tr><td>{{index $catscounts $cat}}</td><td><a title='Product Category: {{$cat}}' href='/cat/{{$cat}}'>{{$cat}}</a></td></tr>{{end}}</tbody></table></fieldset>
</div></div></div>{{$cats := .Page.Cats}}{{$prods := .Prods}}{{range $cat := $cats}}
<div id='cat-{{$cat}}' class='tab-content'><br><br><br><h2 style='font-family: Courier New; font-size:10pt; background-color: black; color: white;'>Category: {{$cat}}</h2>
<div style='overflow-y: auto;'><table style='height: 90%; width: 90%; border-collapse: collapse; white-space: nowrap; '>
<thead><tr style='border-bottom: 1px solid purple;'><th style='width: 20.0%%;'>Image</th><th style='width: 20.0%%;'>Name</th><th style='width: 20.0%%;'>Price</th><th style='width: 20.0%%;'>Stock</th><th style='width: 20.0%%;'>Buy</th></tr></thead>
<tbody>{{range $prod := $prods}}{{if and (eq $prod.Enable "TRUE") (eq $prod.Category $cat)}}<tr style='border-bottom: 1px solid blue;'>
<td style='width: 20.0%; text-align: center;'><a title='Read more about {{$prod.Partno}}' href='/p/{{$prod.Partno}}'><img style='max-width: 20%; max-height: 20%;' src='/img/{{$prod.Category}}/{{$prod.Image1}}' alt='{{$prod.Name}}' loading='lazy'></a></td>
<td style='width: 20.0%; text-align: left;'>{{$prod.Name}}</td>
<td style='width: 20.0%; text-align: center;'>${{$prod.Price}}</td>
<td style='width: 20.0%; text-align: center;'>{{$prod.Quantity}}</td>
<td style='width: 20.0%; text-align: center;' ><button class='snipcart-add-item' data-item-id='{{$prod.Partno}}' data-item-name='{{$prod.Partno}}' data-item-image='/img/{{$prod.Category}}/{{$prod.Image1}}' data-item-price='{{$prod.Price}}' data-item-description='{{$prod.Name}}' data-item-min-quantity='1' data-item-quantity='1' data-item-quantity-step='1' data-item-shippable='true' data-item-weight='{{printf "%.0f" (mul (toFloat $prod.WeightOz) 28.3495)}}' data-item-length='{{printf "%.0f" (mul (toFloat $prod.LengthInches) 2.54)}}' data-item-width='{{printf "%.0f" (mul (toFloat $prod.WidthInches) 2.54)}}' data-item-height='{{printf "%.0f" (mul (toFloat $prod.HeightInches) 2.54)}}' data-item-has-taxes-included='false' {{if eq $prod.Quantity "0"}}disabled{{end}}>Add to cart</button></td>
</tr>{{end}}{{end}}</tbody></table></div></div>{{end}}{{end}}
<div id='about'  style='text-align: left; word-wrap: break-word; padding:20px;' class='tab-content'>{{.Page.AboutHTML}}</div>
{{if .Page.Mobile}}{{else}}<div id='links' style='text-align: left; word-wrap: break-word; padding:20px;' class='tab-content'>{{.Page.LinksHTML}}</div>{{end}}
<div id='policy'  style='text-align: left; word-wrap: break-word;' class='tab-content'>{{.Page.PolicyHTML}}</div>
<div id='home' class='tab-content'>
<div id='htmlanimation'></div>
{{.Page.Gocanvas}}
{{.Page.LogoImage}}
<p style='font-size:8pt; background:black;margin:0;'>
&nbsp;┌┬┐┌─┐┌─┐┌┐┌┌─┐┌┬┐┌─┐┌─┐┌─┐┬ ┬┌─┐┬─┐┌─┐&nbsp;┌┐┌┌─┐┌┬┐<br>
│││├─┤│&nbsp;┬│││├┤&nbsp;&nbsp;│&nbsp;│&nbsp;│└─┐├─┘├─┤├┤&nbsp;├┬┘├┤&nbsp; │││├┤&nbsp;&nbsp;│ <br>
┴ ┴┴ ┴└─┘┘└┘└─┘&nbsp;┴&nbsp;└─┘└─┘┴ &nbsp;┴ ┴└─┘┴└─└─┘o┘└┘└─┘&nbsp;┴  <br>
</p>
{{if ne .Page.Message ""}}<div>{{.Page.Message}}</div>{{end}}</div></div>
`
const htmlTestPageTemplate = `
<h1 title='magnetosphere electronic surplus' style='background:black;'>magnetosphere electronic surplus</h1> <h2 title='we can rebuild him' style='font-size:10pt; background-color: black; color: white;'>- we have the technology -</h2><h3 style='font-size:22pt;padding:0; margin:0;'><span class='nv'>m</span>a<span class='nv'>g</span>n<span class='nv'>e</span>t<span class='nv'>o</span>s<span class='nv'>p</span>h<span class='nv'>e</span>r<span class='nv'>e</span>.<span class='nv'>n</span>e<span class='nv'>t</span></h3>
<div class='tab-folder'>
<p style='font-size:8pt; background:black;'>
&nbsp;┌┬┐┌─┐┌─┐┌┐┌┌─┐┌┬┐┌─┐┌─┐┌─┐┬ ┬┌─┐┬─┐┌─┐&nbsp;┌┐┌┌─┐┌┬┐<br>
│││├─┤│&nbsp;┬│││├┤&nbsp;&nbsp;│&nbsp;│&nbsp;│└─┐├─┘├─┤├┤&nbsp;├┬┘├┤&nbsp; │││├┤&nbsp;&nbsp;│ <br>
┴ ┴┴ ┴└─┘┘└┘└─┘&nbsp;┴&nbsp;└─┘└─┘┴ &nbsp;┴ ┴└─┘┴└─└─┘o┘└┘└─┘&nbsp;┴  <br>
</p>
{{if ne .Page.Message ""}}<div>{{.Page.Message}}</div>{{end}}</div></div>
`
func equalsIgnoreCase(a, b string) bool {
	return strings.EqualFold(strings.Join(strings.Fields(a), ""), strings.Join(strings.Fields(b), ""))
}

func replace(s, old, new string) string {
	return strings.ReplaceAll(s, old, new)
}
func mul(a, b float64) float64 {
	return a * b
}
func div(a, b float64) float64 {
	return a / b
}
func add(a, b int) int {
	return a + b
}
func sub(a, b int) int {
	return a - b
}
func safeHTML(s string) htmpl.HTML {
	return htmpl.HTML(s)
}
func repeat(s string, count int) string {
	var result string
	for i := 0; i < count; i++ {
		result += s
	}
	return result
}
func sortsubcats(subcats []string, counts map[string]map[string]int) []string {
	sort.Slice(subcats, func(i, j int) bool {
        catI, catJ := subcats[i], subcats[j]
        countI, countJ := counts[catI]["count"], counts[catJ]["count"]
        return countI > countJ
    })
    return subcats
}

var allproducts Products

// Products is an array of Product
type Products []Product

// Product represents a product record line in the products csv
type Product struct {
	Enable            string
	Partno            string
	Name              string
	Image1            string
	Price             string
	Quantity          string
	Shippable         string
	Minorder          string
	Maxorder          string
	Defaultquantity   string
	Stepquantity      string
	Mfgpartno         string
	Mfgname           string
	Category          string
	Subcategory       string
	Location          string
	Msrp              string
	Cost              string
	Typ               string
	Packagetype       string
	Technology        string
	Materials         string
	Value             string
	ValUnit           string
	Resistance        string
	ResUnit           string
	Tolerance         string
	VoltsRating       string
	AmpsRating        string
	WattsRating       string
	TempRating        string
	TempUnit          string
	Description1      string
	Description2      string
	Color1            string
	Color2            string
	Sourceinfo        string
	Datasheet         string
	Docs              string
	Reference         string
	Attributes        string
	Year              string
	Condition         string
	Note              string
	Warning           string
	CableLengthInches string
	LengthInches      string
	WidthInches       string
	HeightInches      string
	WeightLb          string
	WeightOz          string
}

func readproductscsv() (data []byte) {
	data, err := os.ReadFile("products.csv")
	if err != nil {
		fmt.Printf(`Error on os.ReadFile("products.csv"): %v`, err)
	}
	return data
}

func readCSV() {
	var prods Products
	scanner := bufio.NewScanner(bytes.NewReader(readproductscsv()))
	for scanner.Scan() {
		line := scanner.Text()
		fields := strings.Split(line, ",")
		if len(fields) < 3 {
			continue
		}
		if fields[3] == "TRUE" {
			p := Product{
				Image1:            fields[0],
				Partno:            fields[1],
				Name:              fields[2],
				Enable:            fields[3],
				Price:             fields[4],
				Quantity:          fields[5],
				Shippable:         fields[6],
				Minorder:          fields[7],
				Maxorder:          fields[8],
				Defaultquantity:   fields[9],
				Stepquantity:      fields[10],
				Mfgpartno:         fields[11],
				Mfgname:           fields[12],
				Category:          fields[13],
				Subcategory:       fields[14],
				Location:          fields[15],
				Msrp:              fields[16],
				Cost:              fields[17],
				Typ:               fields[18],
				Packagetype:       fields[19],
				Technology:        fields[20],
				Materials:         fields[21],
				Value:             fields[22],
				ValUnit:           fields[23],
				Resistance:        fields[24],
				ResUnit:           fields[25],
				Tolerance:         fields[26],
				VoltsRating:       fields[27],
				AmpsRating:        fields[28],
				WattsRating:       fields[29],
				TempRating:        fields[30],
				TempUnit:          fields[31],
				Description1:      fields[32],
				Description2:      fields[33],
				Color1:            fields[34],
				Color2:            fields[35],
				Sourceinfo:        fields[36],
				Datasheet:         fields[37],
				Docs:              fields[38],
				Reference:         fields[39],
				Attributes:        fields[40],
				Year:              fields[41],
				Condition:         fields[42],
				Note:              fields[43],
				Warning:           fields[44],
				CableLengthInches: fields[45],
				LengthInches:      fields[46],
				WidthInches:       fields[47],
				HeightInches:      fields[48],
				WeightLb:          fields[49],
				WeightOz:          fields[50],
			}
			prods = append(prods, p)
		}
	}
	allproducts = prods
}