Inoue API

package main

import (
	"bufio"
	"bytes"
	"errors"
	"fmt"
	"io"
	"strings"
)

var keyErr = errors.New("json: expected key name")
var objErr = errors.New("json: not an object")

func readStr(r *bufio.Reader) (s string, err error) {
	// assumes " already read!!
	for {
		seg, err := r.ReadString('"')
		if err != nil {
			return seg, fmt.Errorf("%w while reading key name", err)
		}
		if strings.HasSuffix(s, "\\\"") {
			s = s + strings.TrimSuffix(seg, "\\\"")
		} else {
			return s + strings.TrimSuffix(seg, "\""), nil
		}
	}
}

func skipWhitespace(r *bufio.Reader) error {
	for {
		char, err := r.ReadByte()
		if err != nil {
			return fmt.Errorf("%w while reading whitespace", err)
		}
		switch char {
		case ' ':
		case '\r':
		case '\n':
		case '\t':
			break
		default:
			return r.UnreadByte()
		}
	}
}

func passString(r *bufio.Reader, w *bytes.Buffer) error {
	// assumes " already read!!
	for {
		seg, err := r.ReadBytes('"')
		if err != nil {
			return fmt.Errorf("%w while reading string", err)
		}
		w.Write(seg)
		if !bytes.HasSuffix(seg, []byte("\\\"")) {
			return nil
		} // else have another go
	}
}

func passObject(r *bufio.Reader, w *bytes.Buffer) error {
	level := 0
	for {
		char, err := r.ReadByte()
		if err != nil {
			return fmt.Errorf("%w while reading object", err)
		}
		shouldWrite, shouldExit := true, false
		switch char {
		case '{':
			level++
		case '}':
			level--
			if level == 0 {
				shouldExit = true
			}
			if level < 0 {
				// inner (passed) object ended and we ran into outer's brace
				r.UnreadByte()
				shouldWrite = false
				shouldExit = true
			}
		case '[':
			level++
		case ']':
			level--
			if level == 0 {
				shouldExit = true
			}
			// i think we should never run into the same level < 0 case as for objects above,
			// because only objects are supported at outermost level.
			// in case this assumption is wrong, here's where to fix it :D
		case ',':
			if level == 0 {
				r.UnreadByte()
				shouldWrite = false
				shouldExit = true
			}
		case '"':
			w.WriteByte(char)
			shouldWrite = false
			err = passString(r, w)
			if err != nil {
				return err
			}
		default:
			/* none */
		}
		if shouldWrite {
			w.WriteByte(char)
		}
		if shouldExit {
			return nil
		}
	}
}

func jsonParse(rdr io.Reader) (is map[string][]byte, err error) {
	// can accept malformed json but its fiine, it only gets Trusted Inputs
	r := bufio.NewReader(rdr)
	is = make(map[string][]byte)
	b, err := r.ReadByte()
	if b != '{' {
		return is, objErr
	}
	for {
		err = skipWhitespace(r)
		if err != nil {
			return
		}
		b, err = r.ReadByte()
		if err != nil {
			return
		}
		if b == '}' {
			return is, nil
		}
		if b == ',' {
			continue
		}
		if b != '"' {
			return is, keyErr
		}
		name, err := readStr(r)
		if err != nil {
			return is, err
		}
		_, err = r.ReadBytes(':')
		if err != nil {
			return is, err
		}
		err = skipWhitespace(r)
		if err != nil {
			return is, err
		}
		vbuf := bytes.Buffer{}
		err = passObject(r, &vbuf)
		if err != nil {
			return is, err
		}
		is[name] = vbuf.Bytes()
	}
}

// there is a joke about pass-through to be made