package main

import (
	"compress/gzip"
	"crypto/rand"
	"database/sql"
	"encoding/json"
	"fmt"
	"html/template"
	"io"
	"log"
	"log/slog"
	"math/big"
	"net"
	"net/http"
	"strings"
	"time"
)

type (
	server struct {
		listen net.Listener
		db     *sql.DB
		h      *http.ServeMux
		log    *slog.Logger
		tmpl   *template.Template
		auth   func(c *Context) error // authentication
		autho  func(c *Context) error // authorization
	}

	handleFunc func(c *Context)

	Context struct {
		// internal maintenance stuff
		w    http.ResponseWriter
		r    *http.Request
		tmpl *template.Template
		db   *sql.DB
		log  *slog.Logger

		User    string  `json:"-"`
		Filter  *filter `json:"-"`
		CanEdit bool    `json:"-"` // has user permission to edit stuff?

		Title        string                   `json:"title,omitempty"`
		CurrentPath  string                   `json:"-"`
		Error        string                   `json:"error,omitempty"`
		Mappings     map[int]map[int]MapEntry `json:"mappings,omitempty"`
		Commands     map[string]int           `json:"commands,omitempty"`
		Checks       []check                  `json:"checks,omitempty"`
		CheckDetails *checkDetails            `json:"check_details,omitempty"`
		Groups       []group                  `json:"groups,omitempty"`
		Unhandled    bool                     `json:"-"` // set this flag when unhandled was called

		Content map[string]any `json:"-"` // used for the configuration dashboard
	}
)

func newServer(l net.Listener, db *sql.DB, log *slog.Logger, tmpl *template.Template, auth func(c *Context) error, autho func(c *Context) error) *server {
	s := &server{
		listen: l,
		db:     db,
		tmpl:   tmpl,
		h:      http.NewServeMux(),
		auth:   auth,
		autho:  autho,
		log:    log,
	}
	return s
}

func (s *server) ListenAndServe() error {
	server := http.Server{Handler: s.h}
	return server.Serve(s.listen)
}

func (s *server) Handle(path string, fun handleFunc) {
	s.h.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
		txid, err := newTxId()
		if err != nil {
			w.WriteHeader(http.StatusInternalServerError)
			w.Write([]byte(`internal error occured`))
			s.log.Error("could not create txid", "error", err)
			return
		}
		c := &Context{
			w:    w,
			r:    r,
			tmpl: s.tmpl,
			db:   s.db,
			log:  s.log.With("path", path, "txid", txid),
		}
		if err := s.auth(c); err != nil {
			return
		}
		if err := s.autho(c); err != nil {
			return
		}
		fun(c)
		return
	})
}

func (s *server) HandleStatic(path string, h func(w http.ResponseWriter, r *http.Request)) {
	s.h.HandleFunc(path, h)
}

// Render calls the template with the given name to
// render the appropiate content.
// In case of an error, a error message is automatically pushed
// to the client.
func (c *Context) Render(t string) error {
	var w io.Writer = c.w
	if strings.Contains(c.r.Header.Get("Accept-Encoding"), "gzip") {
		gz, err := gzip.NewWriterLevel(w, 5)
		if err != nil {
			log.Printf("could not create gzip writer: %s", err)
			return fmt.Errorf("could not create gzip writer: %s", err)
		}
		defer gz.Close()
		w = gz
		c.w.Header().Set("Content-Encoding", "gzip")
	}

	if c.r.Header.Get("Accept") == "application/json" {
		c.w.Header().Set("Content-Type", "application/json")
		enc := json.NewEncoder(w)
		enc.SetIndent("", "") // disable indentation to save traffic
		if err := enc.Encode(c); err != nil {
			c.w.WriteHeader(http.StatusInternalServerError)
			c.w.Write([]byte("could not write json output"))
			log.Printf("could not write json output: %s", err)
			return err
		}
		return nil
	}

	if err := c.tmpl.ExecuteTemplate(w, t, c); err != nil {
		c.w.WriteHeader(http.StatusInternalServerError)
		c.w.Write([]byte("problem with a template"))
		log.Printf("could not execute template: %s", err)
		return err
	}
	return nil
}

// Get a cookie value.
func (c *Context) GetCookieVal(name string) string {
	cook, err := c.r.Cookie(name)
	if err == http.ErrNoCookie {
		return ""
	}
	return cook.Value
}

// Set a new key value cookie with a deadline.
func (c *Context) SetCookie(name, val string, expire time.Time) {
	cook := http.Cookie{
		Name:     name,
		Value:    val,
		Expires:  expire,
		Secure:   true,
		SameSite: http.SameSiteStrictMode,
		HttpOnly: true,
		Path:     "/",
	}
	http.SetCookie(c.w, &cook)
	return
}

// Alphabet are the available characters used to generate the txids. The more
// characters available the more bits can be represented with shorter IDs.
const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-_"

// alphalen is the number of available characters in the alphabet.
var alphalen = big.NewInt(int64(len(alphabet)))

// txlen is the length of the generated transaction IDs
const txlen = 15

// generate a new transaction ID
//
// This function generates a unique ID using the above parameters. If the IDs
// generated are not unique enough to track a transaction, the txlen should
// be raised.
func newTxId() (string, error) {
	s := make([]byte, txlen)
	var err error
	var num *big.Int
	for i := 0; i < txlen; i++ {
		num, err = rand.Int(rand.Reader, alphalen)
		if err != nil {
			return "", err
		}
		s[i] = alphabet[num.Int64()]
	}
	return string(s), nil
}