Zettelstore Client

Copyright (c) 2021-2022 Detlef Stern

                          Licensed under the EUPL

Zettelstore client is licensed under the European Union Public License,
version 1.2 or later (EUPL v. 1.2). The license is available in the
official languages of the EU. The English version is included here. Please
see https://joinup.ec.europa.eu/community/eupl/og_page/eupl for official

type ZettelJSON struct {
	ID       ZettelID     `json:"id"`
	Meta     ZettelMeta   `json:"meta"`
	Encoding string       `json:"encoding"`
	Content  string       `json:"content"`
	Rights   ZettelRights `json:"rights"`
}







// ZettelListJSON contains data for a zettel list.
type ZettelListJSON struct {
	Query string        `json:"query"`
	Human string        `json:"human"`
	List  []ZidMetaJSON `json:"list"`
}

//-----------------------------------------------------------------------------
// Copyright (c) 2021-2022 Detlef Stern
//
// This file is part of zettelstore-client.
//
// Zettelstore client 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.
//-----------------------------------------------------------------------------

	KeyForward      = "forward"
	KeyLang         = "lang"
	KeyLicense      = "license"
	KeyModified     = "modified"
	KeyPrecursor    = "precursor"
	KeyPredecessor  = "predecessor"
	KeyPublished    = "published"

	KeyReadOnly     = "read-only"
	KeySuccessors   = "successors"
	KeySummary      = "summary"
	KeyURL          = "url"
	KeyUselessFiles = "useless-files"
	KeyUserID       = "user-id"
	KeyUserRole     = "user-role"

	HeaderContentType = "Content-Type"
	HeaderDestination = "Destination"
	HeaderLocation    = "Location"
)

// Values for HTTP query parameter.
const (
	QueryKeyCommand  = "cmd"
	QueryKeyCost     = "cost"
	QueryKeyDir      = "dir"
	QueryKeyEncoding = "enc"

	QueryKeyLimit    = "limit"
	QueryKeyPart     = "part"
	QueryKeyPhrase   = "phrase"
	QueryKeyQuery    = "q"

)

// Supported dir values.
const (
	DirBackward = "backward"
	DirForward  = "forward"
)

// Supported encoding values.
const (
	EncodingHTML  = "html"
	EncodingMD    = "md"
	EncodingSexpr = "sexpr"
	EncodingText  = "text"
	EncodingZJSON = "zjson"
	EncodingZMK   = "zmk"



)

var mapEncodingEnum = map[string]EncodingEnum{
	EncodingHTML:  EncoderHTML,
	EncodingMD:    EncoderMD,
	EncodingSexpr: EncoderSexpr,
	EncodingText:  EncoderText,
	EncodingZJSON: EncoderZJSON,
	EncodingZMK:   EncoderZmk,



}
var mapEnumEncoding = map[EncodingEnum]string{}

func init() {
	for k, v := range mapEncodingEnum {
		mapEnumEncoding[v] = k
	}

// Values for EncoderEnum
const (
	EncoderUnknown EncodingEnum = iota
	EncoderHTML
	EncoderMD
	EncoderSexpr
	EncoderText
	EncoderZJSON

	EncoderZmk

)

// String representation of an encoder key.
func (e EncodingEnum) String() string {
	if f, ok := mapEnumEncoding[e]; ok {
		return f
	}

	ub.rawLocal = ""
	ub.fragment = s
	return ub
}

// String produces a string value.
func (ub *URLBuilder) String() string {









	var sb strings.Builder

	sb.WriteString(ub.prefix)
	if ub.key != '/' {
		sb.WriteByte(ub.key)
	}
	if ub.rawLocal != "" {

		sb.WriteByte('#')
		sb.WriteString(ub.fragment)
	}
	for i, q := range ub.query {
		if i == 0 {
			sb.WriteByte('?')
		} else {
			sb.WriteByte('&')
		}
		sb.WriteString(q.key)
		if val := q.val; val != "" {
			sb.WriteByte('=')
			sb.WriteString(url.QueryEscape(val))
		}
	}
	return sb.String()
}

//-----------------------------------------------------------------------------
// Copyright (c) 2021-2022 Detlef Stern
//
// This file is part of zettelstore-client.
//
// Zettelstore client 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.
//-----------------------------------------------------------------------------

	"strconv"
	"strings"
	"time"

	"codeberg.org/t73fde/sxpf"
	"zettelstore.de/c/api"
	"zettelstore.de/c/sexpr"
	"zettelstore.de/c/zjson"
)

// Client contains all data to execute requests.
type Client struct {
	base      string
	username  string
	password  string

// CreateZettelJSON creates a new zettel and returns its URL.
func (c *Client) CreateZettelJSON(ctx context.Context, data *api.ZettelDataJSON) (api.ZettelID, error) {
	var buf bytes.Buffer
	if err := encodeZettelData(&buf, data); err != nil {
		return api.InvalidZID, err
	}
	ub := c.newURLBuilder('j')
	resp, err := c.buildAndExecuteRequest(ctx, http.MethodPost, ub, &buf, nil)
	if err != nil {
		return api.InvalidZID, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusCreated {
		return api.InvalidZID, statusToError(resp)

		lines = lines[:len(lines)-1]
	}
	return lines, nil
}

// ListZettelJSON returns a list of zettel.
func (c *Client) ListZettelJSON(ctx context.Context, query string) (string, string, []api.ZidMetaJSON, error) {
	ub := c.newURLBuilder('j').AppendQuery(query)
	resp, err := c.buildAndExecuteRequest(ctx, http.MethodGet, ub, nil, nil)
	if err != nil {
		return "", "", nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return "", "", nil, statusToError(resp)

		return nil, statusToError(resp)
	}
	return io.ReadAll(resp.Body)
}

// GetZettelJSON returns a zettel as a JSON struct.
func (c *Client) GetZettelJSON(ctx context.Context, zid api.ZettelID) (*api.ZettelDataJSON, error) {
	ub := c.newURLBuilder('j').SetZid(zid)


	resp, err := c.buildAndExecuteRequest(ctx, http.MethodGet, ub, nil, nil)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return nil, statusToError(resp)
	}
	dec := json.NewDecoder(resp.Body)
	var out api.ZettelDataJSON
	err = dec.Decode(&out)
	if err != nil {
		return nil, err
	}
	return &out, nil
}

// GetParsedZettel return a parsed zettel in a defined encoding.
func (c *Client) GetParsedZettel(ctx context.Context, zid api.ZettelID, enc api.EncodingEnum) ([]byte, error) {
	return c.getZettelString(ctx, 'p', zid, enc)
}

// GetEvaluatedZettel return an evaluated zettel in a defined encoding.
func (c *Client) GetEvaluatedZettel(ctx context.Context, zid api.ZettelID, enc api.EncodingEnum) ([]byte, error) {
	return c.getZettelString(ctx, 'v', zid, enc)
}

func (c *Client) getZettelString(ctx context.Context, key byte, zid api.ZettelID, enc api.EncodingEnum) ([]byte, error) {
	ub := c.newURLBuilder(key).SetZid(zid)
	ub.AppendKVQuery(api.QueryKeyEncoding, enc.String())
	ub.AppendKVQuery(api.QueryKeyPart, api.PartContent)



	resp, err := c.buildAndExecuteRequest(ctx, http.MethodGet, ub, nil, nil)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return nil, statusToError(resp)
	}
	return io.ReadAll(resp.Body)
}

// GetParsedZettelZJSON returns an parsed zettel as a JSON-decoded data structure.
func (c *Client) GetParsedSexpr(ctx context.Context, zid api.ZettelID, part string) (sxpf.Value, error) {
	return c.getSexpr(ctx, 'p', zid, part)
}

// GetEvaluatedZettelZJSON returns an evaluated zettel as a JSON-decoded data structure.
func (c *Client) GetEvaluatedSexpr(ctx context.Context, zid api.ZettelID, part string) (sxpf.Value, error) {
	return c.getSexpr(ctx, 'v', zid, part)
}

func (c *Client) getSexpr(ctx context.Context, key byte, zid api.ZettelID, part string) (sxpf.Value, error) {
	ub := c.newURLBuilder(key).SetZid(zid)
	ub.AppendKVQuery(api.QueryKeyEncoding, api.EncodingSexpr)
	if part != "" {
		ub.AppendKVQuery(api.QueryKeyPart, part)
	}



	resp, err := c.buildAndExecuteRequest(ctx, http.MethodGet, ub, nil, nil)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return nil, statusToError(resp)
	}

	return sxpf.ParseValue(sexpr.Smk, bufio.NewReaderSize(resp.Body, 8))
}

// GetParsedZettelZJSON returns an parsed zettel as a JSON-decoded data structure.
func (c *Client) GetParsedZJSON(ctx context.Context, zid api.ZettelID, part string) (zjson.Value, error) {
	return c.getZJSON(ctx, 'p', zid, part)
}

// GetEvaluatedZettelZJSON returns an evaluated zettel as a JSON-decoded data structure.
func (c *Client) GetEvaluatedZJSON(ctx context.Context, zid api.ZettelID, part string) (zjson.Value, error) {
	return c.getZJSON(ctx, 'v', zid, part)
}

func (c *Client) getZJSON(ctx context.Context, key byte, zid api.ZettelID, part string) (zjson.Value, error) {
	ub := c.newURLBuilder(key).SetZid(zid)
	ub.AppendKVQuery(api.QueryKeyEncoding, api.EncodingZJSON)
	if part != "" {
		ub.AppendKVQuery(api.QueryKeyPart, part)
	}
	resp, err := c.buildAndExecuteRequest(ctx, http.MethodGet, ub, nil, nil)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return nil, statusToError(resp)
	}
	return zjson.Decode(resp.Body)
}

// GetMeta returns the metadata of a zettel.
func (c *Client) GetMeta(ctx context.Context, zid api.ZettelID) (api.ZettelMeta, error) {
	ub := c.newURLBuilder('m').SetZid(zid)
	resp, err := c.buildAndExecuteRequest(ctx, http.MethodGet, ub, nil, nil)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return nil, statusToError(resp)

// UpdateZettelJSON updates an existing zettel.
func (c *Client) UpdateZettelJSON(ctx context.Context, zid api.ZettelID, data *api.ZettelDataJSON) error {
	var buf bytes.Buffer
	if err := encodeZettelData(&buf, data); err != nil {
		return err
	}
	ub := c.newURLBuilder('j').SetZid(zid)
	resp, err := c.buildAndExecuteRequest(ctx, http.MethodPut, ub, &buf, nil)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusNoContent {
		return statusToError(resp)

// QueryMapMeta returns a map of all metadata values with the given query action to the
// list of zettel IDs containing this value.
func (c *Client) QueryMapMeta(ctx context.Context, query string) (api.MapMeta, error) {
	err := c.updateToken(ctx)
	if err != nil {
		return nil, err
	}
	req, err := c.newRequest(ctx, http.MethodGet, c.newURLBuilder('q').AppendQuery(query), nil)
	if err != nil {
		return nil, err
	}
	resp, err := c.executeRequest(req)
	if err != nil {
		return nil, err
	}

//-----------------------------------------------------------------------------
// Copyright (c) 2022 Detlef Stern
//
// This file is part of zettelstore-client.
//
// Zettelstore client 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.
//-----------------------------------------------------------------------------

package client_test

import (
	"context"
	"flag"
	"log"
	"net/http"
	"net/url"
	"testing"

	"codeberg.org/t73fde/sxpf"
	"zettelstore.de/c/api"
	"zettelstore.de/c/client"
	"zettelstore.de/c/zjson"
)

func TestZettelList(t *testing.T) {
	c := getClient()
	_, err := c.ListZettel(context.Background(), "")
	if err != nil {
		t.Error(err)

		} else {
			t.Error(err)
		}
		return
	}
}

func TestGetZJSONZettel(t *testing.T) {
	c := getClient()
	data, err := c.GetEvaluatedZJSON(context.Background(), api.ZidDefaultHome, api.PartContent)
	if err != nil {
		t.Error(err)
		return
	}
	if data == nil {
		t.Error("No data")
	}
	var v vis
	zjson.WalkBlock(&v, data.(zjson.Array), -1)
	// t.Error("Argh")
}

type vis struct{}

func (*vis) BlockArray(a zjson.Array, pos int) zjson.CloseFunc {
	log.Println("SBLO", pos, a)
	return nil
}
func (*vis) InlineArray(a zjson.Array, pos int) zjson.CloseFunc {
	log.Println("SINL", pos, a)
	return nil
}
func (*vis) ItemArray(a zjson.Array, pos int) zjson.CloseFunc {
	log.Println("SITE", pos, a)
	return nil
}
func (*vis) BlockObject(t string, obj zjson.Object, pos int) (bool, zjson.CloseFunc) {
	log.Println("BOBJ", pos, t, obj)
	return true, nil
}
func (*vis) InlineObject(t string, obj zjson.Object, pos int) (bool, zjson.CloseFunc) {
	log.Println("IOBJ", pos, t, obj)
	return true, nil
}
func (*vis) Unexpected(val zjson.Value, pos int, exp string) { log.Println("Expect", pos, exp, val) }

func TestGetSexprZettel(t *testing.T) {
	c := getClient()
	value, err := c.GetEvaluatedSexpr(context.Background(), api.ZidDefaultHome, api.PartContent)
	if err != nil {
		t.Error(err)
		return
	}

//-----------------------------------------------------------------------------
// Copyright (c) 2022 Detlef Stern
//
// This file is part of zettelstore-client.
//
// Zettelstore client 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.
//-----------------------------------------------------------------------------

package html

import (
	"bytes"
	"fmt"
	"io"
	"log"
	"net/url"
	"strconv"

	"codeberg.org/t73fde/sxpf"
	"zettelstore.de/c/api"
	"zettelstore.de/c/attrs"
	"zettelstore.de/c/sexpr"

	ref := env.GetPair(args.GetTail())
	env.WriteImageWithSource(args, env.GetString(ref.GetTail()))
}

func (env *EncEnvironment) WriteImageWithSource(args *sxpf.Pair, src string) {
	a := env.GetAttributes(args)
	a = a.Set("src", src)
	if title := args.GetTail().GetTail().GetTail(); !title.IsNil() {
		a = a.Set("title", text.EvaluateInlineString(title))


	}
	env.WriteStartTag("img", a)
}

func (env *EncEnvironment) LookupForm(sym *sxpf.Symbol) (sxpf.Form, error) {
	return env.Builtins.LookupForm(sym)
}

var defaultEncodingFunctions = []struct {
	sym     *sxpf.Symbol
	minArgs int
	fn      encodingFunc
}{
	{sexpr.SymPara, 0, func(env *EncEnvironment, args *sxpf.Pair) {

		env.WriteString("<p>")
		sxpf.EvalSequence(env, args)
		env.WriteString("</p>")

	}},
	{sexpr.SymHeading, 5, func(env *EncEnvironment, args *sxpf.Pair) {
		nLevel := env.GetInteger(args)
		if nLevel <= 0 {
			return
		}
		level := strconv.FormatInt(nLevel+int64(env.headingOffset), 10)

		}
		env.writeVerbatim(args, a)
		env.visibleSpace = oldVisible
	}},
	{sexpr.SymVerbatimZettel, 0, DoNothingFn},
	{sexpr.SymBLOB, 3, func(env *EncEnvironment, args *sxpf.Pair) {
		argSyntax := args.GetTail()
		env.writeBLOB(env.GetString(args), env.GetString(argSyntax), env.GetString(argSyntax.GetTail()))
	}},
	{sexpr.SymTransclude, 2, func(env *EncEnvironment, args *sxpf.Pair) {
		a := sexpr.GetAttributes(env.GetPair(args))
		ref := env.GetPair(args.GetTail())
		refKind := env.GetSymbol(ref)
		if refKind == nil {
			return

			env.WriteEscaped(refValue)
			env.WriteString(" -->")
			return
		}
		if env.err == nil {
			_, env.err = fmt.Fprintf(env.w, "%v\n", args)
		}
		log.Println("TRAN", args)
	}},
	{sexpr.SymText, 0, func(env *EncEnvironment, args *sxpf.Pair) {
		if !sxpf.IsNil(args) {
			env.WriteEscaped(env.GetString(args))
		}
	}},
	{sexpr.SymSpace, 0, func(env *EncEnvironment, args *sxpf.Pair) {

		} else {
			env.WriteImage(args)
		}
	}},
	{sexpr.SymEmbedBLOB, 3, func(env *EncEnvironment, args *sxpf.Pair) {
		argSyntax := args.GetTail()
		a, syntax, data := env.GetAttributes(args), env.GetString(argSyntax), env.GetString(argSyntax.GetTail())
		title, _ := a.Get("title")
		env.writeBLOB(title, syntax, data)
	}},
	{sexpr.SymCite, 2, func(env *EncEnvironment, args *sxpf.Pair) {
		env.WriteStartTag("span", env.GetAttributes(args))
		argKey := args.GetTail()
		if key := env.GetString(argKey); key != "" {
			env.WriteEscaped(key)
			if text := argKey.GetTail(); !text.IsNil() {

		env.writeLiteral(args, a, "code")
	}},
	{sexpr.SymLiteralZettel, 0, DoNothingFn},
}

// DoNothingFn is a function that does nothing.
func DoNothingFn(*EncEnvironment, *sxpf.Pair) { /* Should really do nothing */ }




































func makeListFn(tag string) encodingFunc {
	return func(env *EncEnvironment, args *sxpf.Pair) {
		env.WriteStartTag(tag, nil)
		for elem := args; !elem.IsNil(); elem = elem.GetTail() {
			env.WriteStartTag("li", nil)
			sxpf.Eval(env, elem.GetFirst())

func execHTML(env *EncEnvironment, args *sxpf.Pair) {
	if s := env.GetString(args.GetTail()); s != "" && IsSafe(s) {
		env.WriteString(s)
	}
}

func (env *EncEnvironment) writeBLOB(title, syntax, data string) {
	if data == "" {
		return
	}
	switch syntax {
	case "":
	case api.ValueSyntaxSVG:
		// TODO: add  title as description
		env.WriteStrings("<p>", data, "</p>")
	default:
		env.WriteStrings(`<p><img src="data:image/`, syntax, ";base64,", data)
		if title != "" {
			env.WriteString(`" `)

			env.WriteOneAttribute("title", title)
			env.WriteString(`></p>`)
		} else {
			env.WriteString(`"></p>`)
		}

	}
}

func PrepareLink(env *EncEnvironment, args *sxpf.Pair) (attrs.Attributes, string, bool) {
	if env.noLinks {
		WriteAsSpan(env, args)
		return nil, "", false

<title>Change Log</title>














<a name="0_9"></a>
<h2>Changes for Version 0.9.0 (2022-12-12)</h2>
  *  Rename <tt>api.QueryKeyDepth</tt> to <tt>api.QueryKeyCost</tt>
  *  Update encode / syntax names

<a name="0_6"></a>

<title>Home</title>

This repository contains Go client software to
access [https://zettelstore.de|Zettelstore] via its API.

<h3>Latest Release: 0.9.0 (2022-12-12)</h3>
  *  [./changes.wiki#0_9|Change summary]
  *  [/timeline?p=v0.9.0&bt=v0.8.0&y=ci|Check-ins for version 0.9.0],
     [/vdiff?to=v0.9.0&from=v0.8.0|content diff]
  *  [/timeline?df=v0.9.0&y=ci|Check-ins derived from the 0.9.0 release],
     [/vdiff?from=v0.9.0&to=trunk|content diff]
  *  [/timeline?t=release|Timeline of all past releases]

//-----------------------------------------------------------------------------
// Copyright (c) 2022 Detlef Stern
//
// This file is part of zettelstore-client.
//
// Zettelstore client 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.
//-----------------------------------------------------------------------------

package zjson

// Values for Zettelmarkup element object names
const (
	NameType        = ""
	NameAttribute   = "a"
	NameBLOB        = "j"
	NameBinary      = "o"
	NameBlock       = "b"
	NameDescrList   = "d"
	NameDescription = "e"
	NameInline      = "i"
	NameList        = "c"
	NameNumeric     = "n"
	NameSet         = "y"
	NameString      = "s"
	NameString2     = "q"
	NameString3     = "v"
	NameTable       = "p"
)

// Values to specify the Zettelmarkup element type
const (
	TypeBLOB            = "BLOB"
	TypeBlock           = "Block"
	TypeBreakHard       = "Hard"
	TypeBreakSoft       = "Soft"
	TypeBreakThematic   = "Thematic"
	TypeCitation        = "Cite"
	TypeDescrList       = "Description"
	TypeEmbed           = "Embed"
	TypeEmbedBLOB       = "EmbedBLOB"
	TypeExcerpt         = "Excerpt"
	TypeFootnote        = "Footnote"
	TypeFormatDelete    = "Delete"
	TypeFormatEmph      = "Emph"
	TypeFormatInsert    = "Insert"
	TypeFormatQuote     = "Quote"
	TypeFormatSpan      = "Span"
	TypeFormatStrong    = "Strong"
	TypeFormatSub       = "Sub"
	TypeFormatSuper     = "Super"
	TypeHeading         = "Heading"
	TypeLink            = "Link"
	TypeListBullet      = "Bullet"
	TypeListOrdered     = "Ordered"
	TypeListQuotation   = "Quotation"
	TypeLiteralCode     = "Code"
	TypeLiteralComment  = "Comment"
	TypeLiteralHTML     = "HTML"
	TypeLiteralInput    = "Input"
	TypeLiteralOutput   = "Output"
	TypeLiteralMath     = "Math"
	TypeLiteralZettel   = "Zettel"
	TypeMark            = "Mark"
	TypeParagraph       = "Para"
	TypePoem            = "Poem"
	TypeSpace           = "Space"
	TypeTable           = "Table"
	TypeText            = "Text"
	TypeTransclude      = "Transclude"
	TypeVerbatimCode    = "CodeBlock"
	TypeVerbatimComment = "CommentBlock"
	TypeVerbatimEval    = "EvalBlock"
	TypeVerbatimHTML    = "HTMLBlock"
	TypeVerbatimMath    = "MathBlock"
	TypeVerbatimZettel  = "ZettelBlock"
)

// Values to specify the state of a reference
const (
	RefStateBased    = "based"
	RefStateBroken   = "broken"
	RefStateExternal = "external"
	RefStateFound    = "found"
	RefStateHosted   = "local"
	RefStateInvalid  = "invalid"
	RefStateQuery    = "query"
	RefStateSelf     = "self"
	RefStateZettel   = "zettel"
)

// Values for table cell alignment
const (
	AlignDefault = ""
	AlignLeft    = "<"
	AlignCenter  = ":"
	AlignRight   = ">"
)

//-----------------------------------------------------------------------------
// Copyright (c) 2022 Detlef Stern
//
// This file is part of zettelstore-client.
//
// Zettelstore client 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.
//-----------------------------------------------------------------------------

package zjson

type Meta map[string]MetaValue
type MetaValue struct {
	Type  string
	Key   string
	Value Value
}

func MakeMeta(val Value) Meta {
	obj := MakeObject(val)
	if len(obj) == 0 {
		return nil
	}
	result := make(Meta, len(obj))
	for k, v := range obj {
		mvObj := MakeObject(v)
		if len(mvObj) == 0 {
			continue
		}
		mv := makeMetaValue(mvObj)
		if mv.Type != "" {
			result[k] = mv
		}
	}
	return result
}
func makeMetaValue(mvObj Object) MetaValue {
	mv := MetaValue{}
	for n, val := range mvObj {
		if n == NameType {
			if t, ok := val.(string); ok {
				mv.Type = t
			}
		} else {
			mv.Key = n
			mv.Value = val
		}
	}
	return mv
}

func (m Meta) GetArray(key string) Array {
	if v, found := m[key]; found {
		return MakeArray(v.Value)
	}
	return nil
}

func (m Meta) GetString(key string) string {
	if v, found := m[key]; found {
		return MakeString(v.Value)
	}
	return ""
}

//-----------------------------------------------------------------------------
// Copyright (c) 2022 Detlef Stern
//
// This file is part of zettelstore-client.
//
// Zettelstore client 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.
//-----------------------------------------------------------------------------

// Package zjson provides types, constants and function to work with the ZJSON
// encoding of zettel.
package zjson

import (
	"encoding/json"
	"fmt"
	"io"

	"zettelstore.de/c/attrs"
)

// Value is the gerneric JSON value.
type Value = interface{}

// Array represents a JSON array.
type Array = []Value

// Object represents a JSON object.
type Object = map[string]Value

// Decode some JSON data and return the tree.
func Decode(data io.Reader) (Value, error) {
	var result interface{}
	dec := json.NewDecoder(data)
	dec.UseNumber()
	err := dec.Decode(&result)
	if err != nil {
		return nil, err
	}
	return result, nil
}

// GetMetaContent returns the metadata and the content of a zettel ZJSON.
func GetMetaContent(zjZettel Value) (Meta, Array) {
	if zettel, ok := zjZettel.(Object); ok {
		meta := MakeMeta(zettel["meta"])
		content := MakeArray(zettel["content"])
		return meta, content
	}
	return nil, nil
}

// Visitor provides functionality when a Value is traversed.
type Visitor interface {
	BlockArray(a Array, pos int) CloseFunc
	InlineArray(a Array, pos int) CloseFunc
	ItemArray(a Array, pos int) CloseFunc

	BlockObject(t string, obj Object, pos int) (bool, CloseFunc)
	InlineObject(t string, obj Object, pos int) (bool, CloseFunc)

	Unexpected(val Value, pos int, exp string)
}

// CloseFunc is a function that executes after a ZJSON element is visited.
type CloseFunc func()

// WalkBlock traverses a block array.
func WalkBlock(v Visitor, a Array, pos int) {
	ef := v.BlockArray(a, pos)
	for i, elem := range a {
		WalkBlockObject(v, elem, i)
	}
	if ef != nil {
		ef()
	}
}

// WalkInline traverses an inline array.
func WalkInline(v Visitor, a Array, pos int) {
	ef := v.InlineArray(a, pos)
	for i, elem := range a {
		WalkInlineObject(v, elem, i)
	}
	if ef != nil {
		ef()
	}
}

// WalkBlockObject traverses a value as a JSON object in a block array.
func WalkBlockObject(v Visitor, val Value, pos int) { walkObject(v, val, pos, v.BlockObject) }

// WalkInlineObject traverses a value as a JSON object in an inline array.
func WalkInlineObject(v Visitor, val Value, pos int) { walkObject(v, val, pos, v.InlineObject) }

func walkObject(v Visitor, val Value, pos int, objFunc func(string, Object, int) (bool, CloseFunc)) {
	obj, ok := val.(Object)
	if !ok {
		v.Unexpected(val, pos, "Object")
		return
	}

	tVal, ok := obj[NameType]
	if !ok {
		v.Unexpected(obj, pos, "Object type")
		return
	}
	t, ok := tVal.(string)
	if !ok {
		v.Unexpected(obj, pos, "Object type value")
		return
	}

	doChilds, ef := objFunc(t, obj, pos)
	if doChilds {
		WalkBlockChild(v, obj, pos)
		WalkItemChild(v, obj, pos)
		WalkInlineChild(v, obj, pos)
		walkDescriptionList(v, obj)
		walkTable(v, obj, pos)
	}
	if ef != nil {
		ef()
	}
}

// WalkInlineChild traverses the array found at the name NameInline ('i').
func WalkInlineChild(v Visitor, obj Object, pos int) {
	if iVal, ok := obj[NameInline]; ok {
		if il, ok := iVal.(Array); ok {
			WalkInline(v, il, 0)
		} else {
			v.Unexpected(iVal, pos, "Inline array")
		}
	}
}

// WalkBlockChild traverses the array found at the name NameBlock ('b').
func WalkBlockChild(v Visitor, obj Object, pos int) {
	if bVal, ok := obj[NameBlock]; ok {
		if bl, ok := bVal.(Array); ok {
			WalkBlock(v, bl, 0)
		} else {
			v.Unexpected(bVal, pos, "Block array")
		}
	}
}

// WalkItemChild traverses the arrays found at the name NameList ('c').
func WalkItemChild(v Visitor, obj Object, pos int) {
	iVal, ok := obj[NameList]
	if !ok {
		return
	}
	it, ok := iVal.(Array)
	if !ok {
		v.Unexpected(iVal, pos, "Item array")
		return
	}
	for i, l := range it {
		ef := v.ItemArray(it, i)
		if bl, ok := l.(Array); ok {
			WalkBlock(v, bl, i)
		} else {
			v.Unexpected(l, i, "Item block array")
		}
		if ef != nil {
			ef()
		}
	}
}

func walkDescriptionList(v Visitor, obj Object) {
	descrs := GetArray(obj, NameDescrList)
	if len(descrs) == 0 {
		return
	}
	for i, elem := range descrs {
		dObj := MakeObject(elem)
		if dObj == nil {
			continue
		}
		WalkInlineChild(v, dObj, i)
		descr := GetArray(dObj, NameDescription)
		if len(descr) == 0 {
			continue
		}
		for j, ddv := range descr {
			dd := MakeArray(ddv)
			if len(dd) == 0 {
				continue
			}
			WalkBlock(v, dd, j)
		}
	}
}

func walkTable(v Visitor, obj Object, pos int) {
	tdata := GetArray(obj, NameTable)
	if len(tdata) == 0 {
		return
	}
	if len(tdata) != 2 {
		v.Unexpected(obj, pos, "Table header/rows")
		return
	}
	walkRow(v, MakeArray(tdata[0]))
	if bArray := MakeArray(tdata[1]); len(bArray) > 0 {
		for _, row := range bArray {
			if rArray := MakeArray(row); rArray != nil {
				walkRow(v, rArray)
			}
		}
	}
}
func walkRow(v Visitor, row Array) {
	if len(row) > 0 {
		for _, cell := range row {
			if cObj := MakeObject(cell); cObj != nil {
				WalkInlineChild(v, cObj, 0)
			}
		}
	}
}

// GetArray returns the array-typed value under the given name.
func GetArray(obj Object, name string) Array {
	if v, ok := obj[name]; ok && v != nil {
		return MakeArray(v)
	}
	return nil
}

// GetNumber returns the numeric value at NameNumberic ('n') as a string.
func GetNumber(obj Object) string {
	if v, ok := obj[NameNumeric]; ok {
		if n, ok := v.(json.Number); ok {
			return string(n)
		}
		if f, ok := v.(float64); ok {
			return fmt.Sprint(f)
		}
	}
	return ""
}

// GetString returns the string value at the given name.
func GetString(obj Object, name string) string {
	if v, ok := obj[name]; ok {
		return MakeString(v)
	}
	return ""
}

// MakeArray returns the given value as a JSON array.
func MakeArray(val Value) Array {
	if a, ok := val.(Array); ok {
		return a
	}
	return nil
}

// MakeString returns the given value as a string.
func MakeString(val Value) string {
	if s, ok := val.(string); ok {
		return s
	}
	return ""
}

// GetAttribute returns a copy of the attributes of the given object.
func GetAttributes(obj Object) attrs.Attributes {
	a := GetObject(obj, NameAttribute)
	if len(a) == 0 {
		return nil
	}
	result := make(attrs.Attributes, len(a))
	for n, v := range a {
		if val, ok := v.(string); ok {
			result[n] = val
		}
	}
	return result
}

// SetAttributes copies the attributes to the given object.
func SetAttributes(obj Object, a attrs.Attributes) {
	if len(a) == 0 {
		delete(obj, NameAttribute)
	}
	val := make(Object)
	for k, v := range a {
		val[k] = v
	}
	obj[NameAttribute] = val
}

// GetObject returns the object found at the given object with the given name.
func GetObject(obj Object, name string) Object {
	if v, ok := obj[name]; ok && v != nil {
		return MakeObject(v)
	}
	return nil
}

// MakeObject returns the given value as a JSON object.
func MakeObject(val Value) Object {
	if o, ok := val.(Object); ok {
		return o
	}
	return nil
}

// GetParagraphInline return the inline list of the first paragraph (or nil if there is no such thing)
func GetParagraphInline(a Array) Array {
	if len(a) != 1 {
		return nil
	}
	if o := MakeObject(a[0]); o != nil {
		if GetString(o, NameType) == TypeParagraph {
			return GetArray(o, NameInline)
		}
	}
	return nil
}