/*
The MIT License (MIT)

Copyright © 2024 pacman64

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

/*
Single-file source-code for nj: this version has no http(s) support. Even
the unit-tests from the original nj are omitted.

To compile a smaller-sized command-line app, you can use the `go` command as
follows:

go build -ldflags "-s -w" -trimpath nj.go
*/

package main

import (
	"bufio"
	"encoding/json"
	"errors"
	"io"
	"os"
)

const info = `
nj [filepath...]

Nice Json reads JSON, and emits it back as ANSI-styled indented lines, using
2 spaces for each indentation level.
`

// indent is how many spaces each indentation level uses
const indent = 2

const (
	// boolStyle is bluish, and very distinct from all other colors used
	boolStyle = "\x1b[38;5;74m"

	// keyStyle is magenta, and very distinct from normal strings
	keyStyle = "\x1b[38;5;99m"

	// nullStyle is a light-gray, just like syntax elements, but the word
	// `null` is wide enough to stand out from syntax items at a glance
	nullStyle = syntaxStyle

	// numberStyle is a nice green
	numberStyle = "\x1b[38;5;29m"

	// stringStyle used to be bluish, but it's better to keep it plain,
	// which also minimizes how many different colors the output can show
	stringStyle = ""

	// stringStyle is bluish, but clearly darker than boolStyle
	// stringStyle = "\x1b[38;5;24m"

	// syntaxStyle is a light-gray, not too light, not too dark
	syntaxStyle = "\x1b[38;5;248m"
)

// errNoMoreOutput is a way to successfully quit the app right away, its
// message never shown
var errNoMoreOutput = errors.New(`no more output`)

func main() {
	if len(os.Args) > 1 {
		switch os.Args[1] {
		case `-h`, `--h`, `-help`, `--help`:
			os.Stderr.WriteString(info[1:])
			return
		}
	}

	if len(os.Args) > 2 {
		showError(errors.New(`multiple inputs not allowed`))
		os.Exit(1)
	}

	var err error
	if len(os.Args) == 1 || (len(os.Args) == 2 && os.Args[1] == `-`) {
		// handle lack of filepath arg, or `-` as the filepath
		err = niceJSON(os.Stdout, os.Stdin)
	} else {
		// handle being given a normal filepath
		err = handleFile(os.Stdout, os.Args[1])
	}

	if err != nil && err != errNoMoreOutput {
		showError(err)
		os.Exit(1)
	}
}

// showError standardizes how errors look in this app
func showError(err error) {
	os.Stderr.WriteString("\x1b[31m")
	os.Stderr.WriteString(err.Error())
	os.Stderr.WriteString("\x1b[0m\n")
}

// writeSpaces does what it says, minimizing calls to write-like funcs
func writeSpaces(w *bufio.Writer, n int) {
	const spaces = `                                `
	for n >= len(spaces) {
		w.WriteString(spaces)
		n -= len(spaces)
	}
	if n > 0 {
		w.WriteString(spaces[:n])
	}
}

func handleFile(w io.Writer, path string) error {
	// if f := strings.HasPrefix; f(path, `https://`) || f(path, `http://`) {
	// 	resp, err := http.Get(path)
	// 	if err != nil {
	// 		return err
	// 	}
	// 	defer resp.Body.Close()
	// 	return niceJSON(w, resp.Body)
	// }

	f, err := os.Open(path)
	if err != nil {
		// on windows, file-not-found error messages may mention `CreateFile`,
		// even when trying to open files in read-only mode
		return errors.New(`can't open file named ` + path)
	}
	defer f.Close()

	return niceJSON(w, f)
}

func niceJSON(w io.Writer, r io.Reader) error {
	bw := bufio.NewWriter(w)
	defer bw.Flush()

	dec := json.NewDecoder(r)
	// using string-like json.Number values instead of float64 ones avoids
	// unneeded reformatting of numbers; reformatting parsed float64 values
	// can potentially even drop/change decimals, causing the output not to
	// match the input digits exactly, which is best to avoid
	dec.UseNumber()

	t, err := dec.Token()
	if err == io.EOF {
		return errors.New(`empty input isn't valid JSON`)
	}
	if err != nil {
		return err
	}

	if err := handleToken(bw, dec, t, 0, 0); err != nil {
		return err
	}
	// don't forget to end the last output line
	bw.WriteByte('\n')

	if _, err := dec.Token(); err != io.EOF {
		return errors.New(`unexpected trailing JSON data`)
	}
	return nil
}

func handleToken(w *bufio.Writer, d *json.Decoder, t json.Token, pre, level int) error {
	switch t := t.(type) {
	case json.Delim:
		switch t {
		case json.Delim('['):
			return handleArray(w, d, pre, level)

		case json.Delim('{'):
			return handleObject(w, d, pre, level)

		default:
			// return fmt.Errorf(`unsupported JSON delimiter %v`, t)
			return errors.New(`unsupported JSON delimiter`)
		}

	case nil:
		return handleNull(w, pre)

	case bool:
		return handleBoolean(w, t, pre)

	case string:
		return handleString(w, t, pre)

	case json.Number:
		return handleNumber(w, t, pre)

	default:
		// return fmt.Errorf(`unsupported token type %T`, t)
		return errors.New(`unsupported token type`)
	}
}

func handleArray(w *bufio.Writer, d *json.Decoder, pre, level int) error {
	for i := 0; true; i++ {
		t, err := d.Token()
		if err != nil {
			return err
		}

		if t == json.Delim(']') {
			if i == 0 {
				writeSpaces(w, indent*pre)
				w.WriteString(syntaxStyle + "[]\x1b[0m")
			} else {
				w.WriteString("\n")
				writeSpaces(w, indent*level)
				w.WriteString(syntaxStyle + "]\x1b[0m")
			}
			return nil
		}

		if i == 0 {
			writeSpaces(w, indent*pre)
			w.WriteString(syntaxStyle + "[\x1b[0m\n")
		} else {
			// this is a good spot to check for early-quit opportunities
			_, err = w.WriteString(syntaxStyle + ",\x1b[0m\n")
			if err != nil {
				return errNoMoreOutput
			}
		}

		writeSpaces(w, indent*(level+1))
		if err := handleToken(w, d, t, level, level+1); err != nil {
			return err
		}
	}

	// make the compiler happy
	return nil
}

func handleBoolean(w *bufio.Writer, b bool, pre int) error {
	writeSpaces(w, indent*pre)
	if b {
		w.WriteString(boolStyle + "true\x1b[0m")
	} else {
		w.WriteString(boolStyle + "false\x1b[0m")
	}
	return nil
}

func handleKey(w *bufio.Writer, s string, pre int) error {
	writeSpaces(w, indent*pre)
	w.WriteString(syntaxStyle + "\"\x1b[0m" + keyStyle)
	w.WriteString(s)
	w.WriteString(syntaxStyle + "\":\x1b[0m ")
	return nil
}

func handleNull(w *bufio.Writer, pre int) error {
	writeSpaces(w, indent*pre)
	w.WriteString(nullStyle + "null\x1b[0m")
	return nil
}

func handleNumber(w *bufio.Writer, n json.Number, pre int) error {
	writeSpaces(w, indent*pre)
	w.WriteString(numberStyle)
	w.WriteString(n.String())
	w.WriteString("\x1b[0m")
	return nil
}

func handleObject(w *bufio.Writer, d *json.Decoder, pre, level int) error {
	for i := 0; true; i++ {
		t, err := d.Token()
		if err != nil {
			return err
		}

		if t == json.Delim('}') {
			if i == 0 {
				writeSpaces(w, indent*pre)
				w.WriteString(syntaxStyle + "{}\x1b[0m")
			} else {
				w.WriteString("\n")
				writeSpaces(w, indent*level)
				w.WriteString(syntaxStyle + "}\x1b[0m")
			}
			return nil
		}

		if i == 0 {
			writeSpaces(w, indent*pre)
			w.WriteString(syntaxStyle + "{\x1b[0m\n")
		} else {
			// this is a good spot to check for early-quit opportunities
			_, err = w.WriteString(syntaxStyle + ",\x1b[0m\n")
			if err != nil {
				return errNoMoreOutput
			}
		}

		// the stdlib's JSON parser is supposed to complain about non-string
		// keys anyway, but make sure just in case
		k, ok := t.(string)
		if !ok {
			return errors.New(`expected key to be a string`)
		}
		if err := handleKey(w, k, level+1); err != nil {
			return err
		}

		// handle value
		t, err = d.Token()
		if err != nil {
			return err
		}
		if err := handleToken(w, d, t, 0, level+1); err != nil {
			return err
		}
	}

	// make the compiler happy
	return nil
}

func handleString(w *bufio.Writer, s string, pre int) error {
	writeSpaces(w, indent*pre)
	w.WriteString(syntaxStyle + "\"\x1b[0m" + stringStyle)
	w.WriteString(s)
	w.WriteString(syntaxStyle + "\"\x1b[0m")
	return nil
}