package main

import (
	// External
	"git.gibonuddevalla.se/go/html_template"

	// Standard
	"embed"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
)

var (
	htmlEngine HTMLTemplate.Engine

	//go:embed static
	staticFS embed.FS

	//go:embed views
	viewFS embed.FS
)

func registerWebserverHandlers() {
	var err error
	htmlEngine, err = HTMLTemplate.NewEngine(viewFS, staticFS, flagDev)
	if err != nil {
		logger.Error("webserver", "error", err)
		os.Exit(1)
	}

	http.HandleFunc("/", rootHandler)
	http.HandleFunc("/record/save", actionRecordSave)
}

func startWebserver() {
	listen := fmt.Sprintf("%s:%d", config.Network.Address, config.Network.Port)
	logger.Info("webserver", "listen", listen)
	http.ListenAndServe(listen, nil)
}

func rootHandler(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path == "/" {
		page := HTMLTemplate.SimplePage{}
		page.Layout = "main"
		page.Page = "index"

		var err error
		data := make(map[string]any)

		data["Identity"], err = device.GetIdentity()
		if err != nil {
			w.Write([]byte(err.Error()))
			return
		}

		var entries []DNSRecord
		entries, err = device.StaticDNSEntries()
		if err != nil {
			w.Write([]byte(err.Error()))
			return
		}

		data["DNSRecords"] = entries

		data["VERSION"] = VERSION
		page.Data = data

		err = htmlEngine.Render(page, w, r)
		if err != nil {
			w.Write([]byte(err.Error()))
			return
		}
		return
	}

	htmlEngine.StaticResource(w, r)
}

func httpError(w http.ResponseWriter, err error) {
	resp := struct {
		OK    bool
		Error string
	}{
		false,
		err.Error(),
	}

	j, _ := json.Marshal(resp)
	w.Write(j)
}

func actionRecordSave(w http.ResponseWriter, r *http.Request) {
	body, _ := io.ReadAll(r.Body)
	var record DNSRecord
	err := json.Unmarshal(body, &record)
	if err != nil {
		httpError(w, err)
		return
	}

	entry, err := device.UpdateDNSEntry(record.toDNSEntry())
	if err != nil {
		httpError(w, err)
		logger.Error("webserver", "op", "record_save", "error", err)
		return
	}

	record = NewDNSRecord(entry)

	j, _ := json.Marshal(struct{ OK bool; Record DNSRecord }{true, record})
	w.Write(j)
}