// Copyright (C) 2022  Luke Shumaker <lukeshu@lukeshu.com>
//
// SPDX-License-Identifier: GPL-2.0-or-later

package json

import (
	"bufio"
	"bytes"
	"encoding/json"
	"io"

	"git.lukeshu.com/go/lowmemjson"
)

type (
	Number     = json.Number
	Marshaler  = json.Marshaler
	RawMessage = json.RawMessage

	// low-level decode errors
	SyntaxError         = lowmemjson.SyntaxError
	UnmarshalFieldError = json.UnmarshalFieldError
	UnmarshalTypeError  = json.UnmarshalTypeError // lowmemjson.DecodeTypeError

	// high-level decode errors
	InvalidUnmarshalError = json.InvalidUnmarshalError // lowmemjson.DecodeArgumentError

	// marshal errors
	InvalidUTF8Error      = json.InvalidUTF8Error
	MarshalerError        = json.MarshalerError
	UnsupportedTypeError  = json.UnsupportedTypeError
	UnsupportedValueError = json.UnsupportedValueError
)

/////////////////////////////////////////////////////////////////////

func MarshalIndent(v any, prefix, indent string) ([]byte, error) {
	var buf bytes.Buffer
	formatter := &lowmemjson.ReEncoder{
		Out:    &buf,
		Indent: indent,
		Prefix: prefix,
	}
	err := lowmemjson.Encode(formatter, v)
	return buf.Bytes(), err
}

func Marshal(v any) ([]byte, error) {
	var buf bytes.Buffer
	formatter := &lowmemjson.ReEncoder{
		Out:     &buf,
		Compact: true,
	}
	err := lowmemjson.Encode(formatter, v)
	return buf.Bytes(), err
}

func HTMLEscape(dst *bytes.Buffer, src []byte) {
	formatter := &lowmemjson.ReEncoder{
		Out: dst,
	}
	_, _ = formatter.Write(src)
}

func Compact(dst *bytes.Buffer, src []byte) error {
	formatter := &lowmemjson.ReEncoder{
		Out:     dst,
		Compact: true,
	}
	_, err := formatter.Write(src)
	return err
}

func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error {
	formatter := &lowmemjson.ReEncoder{
		Out:    dst,
		Indent: indent,
		Prefix: prefix,
	}
	_, err := formatter.Write(src)
	return err
}

func Valid(data []byte) bool {
	formatter := &lowmemjson.ReEncoder{
		Out:     io.Discard,
		Compact: true,
	}
	_, err := formatter.Write(data)
	return err == nil
}

func Unmarshal(data []byte, ptr any) error {
	return lowmemjson.Decode(bytes.NewReader(data), ptr)
}

/////////////////////////////////////////////////////////////////////

type Decoder struct {
	*lowmemjson.Decoder
	buf *bufio.Reader
}

func NewDecoder(r io.Reader) *Decoder {
	br, ok := r.(*bufio.Reader)
	if !ok {
		br = bufio.NewReader(r)
	}
	return &Decoder{
		Decoder: lowmemjson.NewDecoder(br),
		buf:     br,
	}
}

func (dec *Decoder) Buffered() io.Reader {
	dat, _ := dec.buf.Peek(dec.buf.Buffered())
	return bytes.NewReader(dat)
}

//func (dec *Decoder) Token() (Token, error)