module zettelstore.de/contrib/social

go 1.22

require zettelstore.de/sx.fossil v0.0.0-20240325101530-b11ffb3e9c3d

zettelstore.de/sx.fossil v0.0.0-20240325101530-b11ffb3e9c3d h1:UruOvkuWI6CQqBv4D6+3Q8ARjZIPsljdDkvP9mvBUcA=
zettelstore.de/sx.fossil v0.0.0-20240325101530-b11ffb3e9c3d/go.mod h1:/iGHxFXoo6GSV04PUkwaLuFrrCa5LMorxD73iLMAruI=

		return err
	}

	ucGetAllUserAgents := usecase.NewGetAllUserAgents(uaColl)

	docRoot := webui.MakeDocumentHandler(cfg.DocumentRoot)
	h.HandleFunc("GET /", docRoot)

	testHandler := webui.MakeTestHandler()
	h.HandleFunc("GET /social/{$}", testHandler)
	h.HandleFunc("GET /social/ua/{$}", webui.MakeGetAllUAHandler(ucGetAllUserAgents))
	h.HandleFunc("GET /.t/{$}", testHandler)
	h.HandleFunc("GET /.test/{$}", testHandler)
	h.HandleFunc("GET /.test/test/{$}", testHandler)
	h.HandleFunc("GET /.test/test/toast/{$}", testHandler)
	return nil
}

		&sxbuiltins.BeginS,    // begin
	}
	builtins = []*sxeval.Builtin{
		&sxbuiltins.Equal,                // =
		&sxbuiltins.NullP,                // null?
		&sxbuiltins.Car, &sxbuiltins.Cdr, // car, cdr
		&sxbuiltins.Caar, &sxbuiltins.Cadr, // caar, cadr
		&sxbuiltins.Cadar,         // cadar
		&sxbuiltins.LengthGreater, // length>
		&sxbuiltins.List,          // list
		&sxbuiltins.Map,           // map
		&sxbuiltins.BoundP,        // bound?
	}
)

func (wui *WebUI) bindExtra(root *sxeval.Binding) error {
	err := root.BindBuiltin(&sxeval.Builtin{
		Name:     "make-url",
		MinArity: 0,

	"fmt"
	"net/http"

	"zettelstore.de/sx.fossil"
	"zettelstore.de/sx.fossil/sxeval"
	"zettelstore.de/sx.fossil/sxhtml"
)

const contentName = "CONTENT"

func (wui *WebUI) renderTemplateStatus(w http.ResponseWriter, code int, templateSym *sx.Symbol, rb *renderBinding) error {
	if err := rb.err; err != nil {
		return err
	}
	binding := rb.bind
	wui.logger.Debug("Render", "binding", binding.Bindings())
	env := sxeval.MakeExecutionEnvironment(binding)
	if _, templateBound := env.Resolve(templateSym); templateBound {
		obj, err := env.Eval(sx.MakeList(sx.MakeSymbol("render-template"), templateSym))
		if err != nil {
			return err
		}
		wui.logger.Debug("Render", "content", obj)
		rb.bindObject(contentName, obj)

	} else if obj, contentBound := env.Resolve(sx.MakeSymbol(contentName)); contentBound && !sx.IsNil(obj) {
		if _, isList := sx.GetPair(obj); !isList {
			obj = sx.MakeList(symP, obj)
		}
		obj = sx.Cons(obj, sx.Nil())
		wui.logger.Debug("Render", "obj", obj)
		rb.bindObject(contentName, obj)

	} else if templateSym != nil {
		rb.bindObject(
			contentName,
			sx.MakeList(
				symP,
				sx.String("Template "),
				sx.String(templateSym.GoString()),
				sx.String(" not found."),
			))
	} else {
		rb.bindObject(contentName, sx.MakeList(symP, sx.String("No template given.")))
	}
	obj, err := env.Eval(sx.MakeList(sx.MakeSymbol("render-template"), sx.MakeSymbol(nameLayout)))
	if err != nil {
		return err
	}
	wui.logger.Debug("Render", "sxhtml", obj)
	gen := sxhtml.NewGenerator().SetNewline()

	}
	return nil
}

func (wui *WebUI) MakeTestHandler() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		rb := wui.makeRenderBinding("test", r)
		rb.bindObject("CONTENT", sx.MakeList(symP, sx.String(fmt.Sprintf("Some content, url is: %q", r.URL))))
		if err := wui.renderTemplateStatus(w, 200, nil, rb); err != nil {
			wui.handleError(w, "Render", err)
			return
		}
	}
}

// MakeGetAllUAHandler creates a new HTTP handler to display the list of found
// user agents.
func (wui *WebUI) MakeGetAllUAHandler(ucAllUA usecase.GetAllUserAgents) http.HandlerFunc {
	symUserAgents := sx.MakeSymbol("user-agents")
	return func(w http.ResponseWriter, r *http.Request) {
		uasT, uasF := ucAllUA.Run(r.Context())

		q := r.URL.Query()
		if len(q) == 0 {
			rb := wui.makeRenderBinding("user-agent", r)
			rb.bindObject("ALLOWED-AGENTS", stringsTosxList(uasT))
			rb.bindObject("BLOCKED-AGENTS", stringsTosxList(uasF))
			if err := wui.renderTemplateStatus(w, http.StatusOK, symUserAgents, rb); err != nil {
				wui.handleError(w, "Render", err)
			}
			return
		}
		if q.Has("plain") {
			var buf bytes.Buffer
			for _, ua := range uasT {
				fmt.Fprintln(&buf, ua)
			}
			if len(uasF) > 0 && len(uasT) > 0 {
				fmt.Fprintln(&buf, "---")
			}
			for _, ua := range uasF {
				fmt.Fprintln(&buf, ua)
			}
			w.WriteHeader(http.StatusOK)
			_, _ = w.Write(buf.Bytes())
			return
		}

		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
	}
}

func stringsTosxList(sl []string) *sx.Pair {
	var lb sx.ListBuilder
	for _, s := range sl {
		lb.Add(sx.String(s))

;;;----------------------------------------------------------------------------
;;; Copyright (c) 2024-present Detlef Stern
;;;
;;; This file is part of Zettel Social.
;;;
;;; Zettel Social is licensed under the latest version of the EUPL (European
;;; Union Public License). Please see file LICENSE.txt for your rights and
;;; obligations under this license.
;;;
;;; SPDX-License-Identifier: EUPL-1.2
;;; SPDX-FileCopyrightText: 2024-present Detlef Stern
;;;----------------------------------------------------------------------------

;;; Node "User Agents"

(defun string-item (s) `(li ,s))

(define-template user-agents
`(
  (h1 "User Agents")
  (ul ,@(map string-item ALLOWED-AGENTS))
  ,@(if (length> BLOCKED-AGENTS 0)
        `((h2 "Blockiert")
          (ul ,@(map string-item BLOCKED-AGENTS))))
  (a (@ (href "?plain")) "plain")
 )
)

func (rb *renderBinding) bindString(key, val string) {
	if rb.err == nil {
		rb.err = rb.bind.Bind(sx.MakeSymbol(key), sx.String(val))
	}
}

func (wui *WebUI) evalCode(env *sxeval.Environment) error {
	for _, content := range staticSxc {
		rdr := sxreader.MakeReader(bytes.NewReader(content))
		if err := wui.evalReader(env, rdr); err != nil {
			return err
		}
	}
	return nil
}

//go:embed prelude.sxc
var contentPreludeSxc []byte

//go:embed template.sxc
var contentTemplateSxc []byte

//go:embed layout.sxc
var contentLayoutSxc []byte

//go:embed useragent.sxc
var contentUseragentSxc []byte

var staticSxc = [][]byte{
	contentPreludeSxc,
	contentTemplateSxc,
	contentLayoutSxc,
	contentUseragentSxc,
}

func (wui *WebUI) evalReader(env *sxeval.Environment, rdr *sxreader.Reader) error {
	for {
		obj, err := rdr.Read()
		if err != nil {
			if err == io.EOF {
				break

// Template names
const (
	nameLayout = "layout"
)

// compileAllTemplates compiles (parses, reworks) all needed templates.
func (wui *WebUI) compileAllTemplates(env *sxeval.Environment, dir string) error {
	for _, name := range []string{nameLayout} {
		if err := wui.evalTemplate(env, dir, name); err != nil {
			return err
		}
	}
	return nil
}