/*
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 nh: this version has no http(s) support. Even
the unit-tests from the original nh are omitted.

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

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

package main

import (
	"bufio"
	"bytes"
	"flag"
	"fmt"
	"io"
	"math"
	"os"
	"strconv"
	"strings"
)

const usage = `
nh [options...] [filenames...]


Nice Hexadecimal is a simple hexadecimal viewer to easily inspect bytes
from files/data.

Each line shows the starting offset for the bytes shown, 16 of the bytes
themselves in base-16 notation, and any ASCII codes when the byte values
are in the typical ASCII range. The offsets shown are base-10.

The base-16 codes are color-coded, with most bytes shown in gray, while
all-1 and all-0 bytes are shown in orange and blue respectively.

All-0 bytes are the commonest kind in most binary file types and, along
with all-1 bytes are also a special case worth noticing when exploring
binary data, so it makes sense for them to stand out right away.
`

func main() {
	err := run(parseFlags(usage[1:]))
	if err != nil {
		os.Stderr.WriteString(err.Error())
		os.Stderr.WriteString("\n")
		os.Exit(1)
	}
}

func run(cfg config) error {
	// f, _ := os.Create(`nh.prof`)
	// defer f.Close()
	// pprof.StartCPUProfile(f)
	// defer pprof.StopCPUProfile()

	w := bufio.NewWriterSize(os.Stdout, 32*1024)
	defer w.Flush()

	// with no filenames given, handle stdin and quit
	if len(cfg.Filenames) == 0 {
		return handle(w, os.Stdin, `<stdin>`, -1, cfg)
	}

	// show all files given
	for i, fname := range cfg.Filenames {
		if i > 0 {
			w.WriteString("\n")
			w.WriteString("\n")
		}

		err := handleFile(w, fname, cfg)
		if err != nil {
			return err
		}
	}

	return nil
}

// handleFile is like handleReader, except it also shows file-related info
func handleFile(w *bufio.Writer, fname string, cfg config) error {
	f, err := os.Open(fname)
	if err != nil {
		return err
	}
	defer f.Close()

	stat, err := f.Stat()
	if err != nil {
		return handle(w, f, fname, -1, cfg)
	}

	fsize := int(stat.Size())
	return handle(w, f, fname, fsize, cfg)
}

// handle shows some messages related to the input and the cmd-line options
// used, and then follows them by the hexadecimal byte-view
func handle(w *bufio.Writer, r io.Reader, name string, size int, cfg config) error {
	skip(r, cfg.Skip)
	if cfg.MaxBytes > 0 {
		r = io.LimitReader(r, int64(cfg.MaxBytes))
	}

	// finish config setup based on the filesize, if a valid one was given
	if cfg.OffsetCounterWidth < 1 {
		if size < 1 {
			cfg.OffsetCounterWidth = defaultOffsetCounterWidth
		} else {
			w := math.Log10(float64(size))
			w = math.Max(math.Ceil(w), 1)
			cfg.OffsetCounterWidth = uint(w)
		}
	}

	switch cfg.To {
	case plainOutput:
		writeMetaPlain(w, name, size, cfg)
		// when done, emit a new line in case only part of the last line is
		// shown, which means no newline was emitted for it
		defer w.WriteString("\n")
		return render(w, r, cfg, writeBufferPlain)

	case ansiOutput:
		writeMetaANSI(w, name, size, cfg)
		// when done, emit a new line in case only part of the last line is
		// shown, which means no newline was emitted for it
		defer w.WriteString("\x1b[0m\n")
		return render(w, r, cfg, writeBufferANSI)

	default:
		const fs = `unsupported output format %q`
		return fmt.Errorf(fs, cfg.To)
	}
}

// skip ignores n bytes from the reader given
func skip(r io.Reader, n int) {
	if n < 1 {
		return
	}

	// use func Seek for input files, except for stdin, which you can't seek
	if f, ok := r.(*os.File); ok && r != os.Stdin {
		f.Seek(int64(n), io.SeekCurrent)
		return
	}
	io.CopyN(io.Discard, r, int64(n))
}

// renderer is the type for the hex-view render funcs
type renderer func(rc rendererConfig, first, second []byte) error

// render reads all input and shows the hexadecimal byte-view for the input
// data via the rendering callback given
func render(w *bufio.Writer, r io.Reader, cfg config, fn renderer) error {
	if cfg.PerLine < 1 {
		cfg.PerLine = 16
	}

	rc := rendererConfig{
		out:     w,
		offset:  uint(cfg.Skip),
		chunks:  0,
		perLine: uint(cfg.PerLine),
		ruler:   cfg.Ruler,

		offsetWidth: cfg.OffsetCounterWidth,
		showOffsets: cfg.ShowOffsets,
		showASCII:   cfg.ShowASCII,
	}

	// calling func Read directly can sometimes result in chunks shorter
	// than the max chunk-size, even when there are plenty of bytes yet
	// to read; to avoid that, use a buffered-reader to explicitly fill
	// a slice instead
	br := bufio.NewReader(r)

	// to show ASCII up to 1 full chunk ahead, 2 chunks are needed
	cur := make([]byte, 0, cfg.PerLine)
	ahead := make([]byte, 0, cfg.PerLine)

	// the ASCII-panel's wide output requires staying 1 step/chunk behind,
	// so to speak
	cur, err := fillChunk(cur[:0], cfg.PerLine, br)
	if len(cur) == 0 {
		if err == io.EOF {
			err = nil
		}
		return err
	}

	for {
		ahead, err := fillChunk(ahead[:0], cfg.PerLine, br)
		if err != nil && err != io.EOF {
			return err
		}

		if len(ahead) == 0 {
			// done, maybe except for an extra line of output
			break
		}

		// show the byte-chunk on its own output line
		err = fn(rc, cur, ahead)
		if err != nil {
			// probably a pipe was closed
			return nil
		}

		rc.chunks++
		rc.offset += uint(len(cur))
		cur = cur[:copy(cur, ahead)]
	}

	// don't forget the last output line
	if rc.chunks > 0 && len(cur) > 0 {
		return fn(rc, cur, nil)
	}
	return nil
}

// fillChunk tries to read the number of bytes given, appending them to the
// byte-slice given; this func returns an EOF error only when no bytes are
// read, which somewhat simplifies error-handling for the func caller
func fillChunk(chunk []byte, n int, br *bufio.Reader) ([]byte, error) {
	// read buffered-bytes up to the max chunk-size
	for i := 0; i < n; i++ {
		b, err := br.ReadByte()
		if err == nil {
			chunk = append(chunk, b)
			continue
		}

		if err == io.EOF && i > 0 {
			return chunk, nil
		}
		return chunk, err
	}

	// got the full byte-count asked for
	return chunk, nil
}

const (
	usageMaxBytes   = `limit input up to n bytes; negative to disable`
	usagePerLine    = `how many bytes to show on each line`
	usageSkip       = `how many leading bytes to skip/ignore`
	usageTitle      = `use this to show a title/description`
	usageTo         = `the output format to use (plain or ansi)`
	usagePlain      = `show plain-text output, as opposed to ansi-styled output`
	usageShowOffset = `start lines with the offset of the 1st byte shown on each`
	usageShowASCII  = `repeat all ASCII strings on the side, so they're searcheable`
)

const defaultOffsetCounterWidth = 8

const (
	plainOutput = `plain`
	ansiOutput  = `ansi`
)

// config is the parsed cmd-line options given to the app
type config struct {
	// MaxBytes limits how many bytes are shown; a negative value means no limit
	MaxBytes int

	// PerLine is how many bytes are shown per output line
	PerLine int

	// Skip is how many leading bytes to skip/ignore
	Skip int

	// OffsetCounterWidth is the max string-width; not exposed as a cmd-line option
	OffsetCounterWidth uint

	// Title is an optional title preceding the output proper
	Title string

	// To is the output format
	To string

	// Filenames is the list of input filenames
	Filenames []string

	// Ruler is a prerendered ruler to emit every few output lines
	Ruler []byte

	// ShowOffsets starts lines with the offset of the 1st byte shown on each
	ShowOffsets bool

	// ShowASCII shows a side-panel with searcheable ASCII-runs
	ShowASCII bool
}

// parseFlags is the constructor for type config
func parseFlags(usage string) config {
	flag.Usage = func() {
		fmt.Fprintf(flag.CommandLine.Output(), "%s\n\nOptions\n\n", usage)
		flag.PrintDefaults()
	}

	cfg := config{
		MaxBytes:           -1,
		PerLine:            16,
		OffsetCounterWidth: 0,
		To:                 ansiOutput,
		ShowOffsets:        true,
		ShowASCII:          true,
	}

	plain := false
	flag.IntVar(&cfg.MaxBytes, `max`, cfg.MaxBytes, usageMaxBytes)
	flag.IntVar(&cfg.PerLine, `width`, cfg.PerLine, usagePerLine)
	flag.IntVar(&cfg.Skip, `skip`, cfg.Skip, usageSkip)
	flag.StringVar(&cfg.Title, `title`, cfg.Title, usageTitle)
	flag.StringVar(&cfg.To, `to`, cfg.To, usageTo)
	flag.BoolVar(&cfg.ShowOffsets, `n`, cfg.ShowOffsets, usageShowOffset)
	flag.BoolVar(&cfg.ShowASCII, `ascii`, cfg.ShowASCII, usageShowASCII)
	flag.BoolVar(&plain, `p`, plain, "alias for option `plain`")
	flag.BoolVar(&plain, `plain`, plain, usagePlain)
	flag.Parse()

	if plain {
		cfg.To = plainOutput
	}

	// normalize values for option -to
	switch cfg.To {
	case `text`, `plaintext`, `plain-text`:
		cfg.To = plainOutput
	}

	cfg.Ruler = makeRuler(cfg.PerLine)
	cfg.Filenames = flag.Args()
	return cfg
}

// makeRuler prerenders a ruler-line, used to make the output lines breathe
func makeRuler(numitems int) []byte {
	if n := numitems / 4; n > 0 {
		var pat = []byte(`           ·`)
		return bytes.Repeat(pat, n)
	}
	return nil
}

// rendererConfig groups several arguments given to any of the rendering funcs
type rendererConfig struct {
	// out is writer to send all output to
	out *bufio.Writer

	// offset is the byte-offset of the first byte shown on the current output
	// line: if shown at all, it's shown at the start the line
	offset uint

	// chunks is the 0-based counter for byte-chunks/lines shown so far, which
	// indirectly keeps track of when it's time to show a `breather` line
	chunks uint

	// ruler is the `ruler` content to show on `breather` lines
	ruler []byte

	// perLine is how many hex-encoded bytes are shown per line
	perLine uint

	// offsetWidth is the max string-width for the byte-offsets shown at the
	// start of output lines, and determines those values' left-padding
	offsetWidth uint

	// showOffsets determines whether byte-offsets are shown at all
	showOffsets bool

	// showASCII determines whether the ASCII-panels are shown at all
	showASCII bool
}

// loopThousandsGroups comes from my lib/package `mathplus`: that's why it
// handles negatives, even though this app only uses it with non-negatives.
func loopThousandsGroups(n int, fn func(i, n int)) {
	// 0 doesn't have a log10
	if n == 0 {
		fn(0, 0)
		return
	}

	sign := +1
	if n < 0 {
		n = -n
		sign = -1
	}

	intLog1000 := int(math.Log10(float64(n)) / 3)
	remBase := int(math.Pow10(3 * intLog1000))

	for i := 0; remBase > 0; i++ {
		group := (1000 * n) / remBase / 1000
		fn(i, sign*group)
		// if original number was negative, ensure only first
		// group gives a negative input to the callback
		sign = +1

		n %= remBase
		remBase /= 1000
	}
}

// sprintCommas turns the non-negative number given into a readable string,
// where digits are grouped-separated by commas
func sprintCommas(n int) string {
	var sb strings.Builder
	loopThousandsGroups(n, func(i, n int) {
		if i == 0 {
			var buf [4]byte
			sb.Write(strconv.AppendInt(buf[:0], int64(n), 10))
			return
		}
		sb.WriteByte(',')
		writePad0Sub1000Counter(&sb, uint(n))
	})
	return sb.String()
}

// writePad0Sub1000Counter is an alternative to fmt.Fprintf(w, `%03d`, n)
func writePad0Sub1000Counter(w io.Writer, n uint) {
	// precondition is 0...999
	if n > 999 {
		w.Write([]byte(`???`))
		return
	}

	var buf [3]byte
	buf[0] = byte(n/100) + '0'
	n %= 100
	buf[1] = byte(n/10) + '0'
	buf[2] = byte(n%10) + '0'
	w.Write(buf[:])
}

// writeHex is faster than calling fmt.Fprintf(w, `%02x`, b): this
// matters because it's called for every byte of input which isn't
// all 0s or all 1s
func writeHex(w *bufio.Writer, b byte) {
	const hexDigits = `0123456789abcdef`
	w.WriteByte(hexDigits[b>>4])
	w.WriteByte(hexDigits[b&0x0f])
}

// padding is the padding/spacing emitted across each output line, except for
// the breather/ruler lines
const padding = `  `

// writeMetaPlain shows metadata right before the plain-text hex byte-view
func writeMetaPlain(w *bufio.Writer, fname string, fsize int, cfg config) {
	if cfg.Title != `` {
		w.WriteString(cfg.Title)
		w.WriteString("\n")
		w.WriteString("\n")
	}

	if fsize < 0 {
		fmt.Fprintf(w, "• %s\n", fname)
	} else {
		const fs = "• %s  (%s bytes)\n"
		fmt.Fprintf(w, fs, fname, sprintCommas(fsize))
	}

	if cfg.Skip > 0 {
		const fs = "   skipping first %s bytes\n"
		fmt.Fprintf(w, fs, sprintCommas(cfg.Skip))
	}
	if cfg.MaxBytes > 0 {
		const fs = "   showing only up to %s bytes\n"
		fmt.Fprintf(w, fs, sprintCommas(cfg.MaxBytes))
	}
	w.WriteString("\n")
}

// writeBufferPlain shows the hex byte-view withOUT using ANSI colors/styles
func writeBufferPlain(rc rendererConfig, first, second []byte) error {
	// show a ruler every few lines to make eye-scanning easier
	if rc.chunks%5 == 0 && rc.chunks > 0 {
		rc.out.WriteByte('\n')
	}

	return writeLinePlain(rc, first, second)
}

func writeLinePlain(rc rendererConfig, first, second []byte) error {
	w := rc.out

	// start each line with the byte-offset for the 1st item shown on it
	if rc.showOffsets {
		writePlainCounter(w, int(rc.offsetWidth), rc.offset)
		w.WriteByte(' ')
	} else {
		w.WriteString(padding)
	}

	for _, b := range first {
		// fmt.Fprintf(w, ` %02x`, b)
		//
		// the commented part above was a performance bottleneck, since
		// the slow/generic fmt.Fprintf was called for each input byte
		w.WriteByte(' ')
		writeHex(w, b)
	}

	if rc.showASCII {
		writePlainASCII(w, first, second, int(rc.perLine))
	}

	return w.WriteByte('\n')
}

// writePlainCounter just emits a left-padded number
func writePlainCounter(w *bufio.Writer, width int, n uint) {
	var buf [32]byte
	str := strconv.AppendUint(buf[:0], uint64(n), 10)
	writeSpaces(w, width-len(str))
	w.Write(str)
}

// writeRulerPlain emits a breather line using a ruler-like pattern of spaces
// and dots, to guide the eye across the main output lines
// func writeRulerPlain(w *bufio.Writer, indent int, offset int, numitems int) {
// 	writeSpaces(w, indent)
// 	for i := 0; i < numitems-1; i++ {
// 		if (i+offset+1)%5 == 0 {
// 			w.WriteString(`   `)
// 		} else {
// 			w.WriteString(`  ·`)
// 		}
// 	}
// }

// writeSpaces bulk-emits the number of spaces given
func writeSpaces(w *bufio.Writer, n int) {
	const spaces = `                                `
	for ; n > len(spaces); n -= len(spaces) {
		w.WriteString(spaces)
	}
	if n > 0 {
		w.WriteString(spaces[:n])
	}
}

// writePlainASCII emits the side-panel showing all ASCII runs for each line
func writePlainASCII(w *bufio.Writer, first, second []byte, perline int) {
	// prev keeps track of the previous byte, so spaces are added
	// when bytes change from non-visible-ASCII to visible-ASCII
	prev := byte(0)

	spaces := 3*(perline-len(first)) + len(padding)

	for _, b := range first {
		if 32 < b && b < 127 {
			if !(32 < prev && prev < 127) {
				writeSpaces(w, spaces)
				spaces = 1
			}
			w.WriteByte(b)
		}
		prev = b
	}

	for _, b := range second {
		if 32 < b && b < 127 {
			if !(32 < prev && prev < 127) {
				writeSpaces(w, spaces)
				spaces = 1
			}
			w.WriteByte(b)
		}
		prev = b
	}
}

// styledHexBytes is a super-fast direct byte-to-result lookup table, and was
// autogenerated by running the command
//
// seq 0 255 | ./hex-styles.awk
var styledHexBytes = [256]string{
	"\x1b[38;5;111m00 ", "\x1b[38;5;246m01 ",
	"\x1b[38;5;246m02 ", "\x1b[38;5;246m03 ",
	"\x1b[38;5;246m04 ", "\x1b[38;5;246m05 ",
	"\x1b[38;5;246m06 ", "\x1b[38;5;246m07 ",
	"\x1b[38;5;246m08 ", "\x1b[38;5;246m09 ",
	"\x1b[38;5;246m0a ", "\x1b[38;5;246m0b ",
	"\x1b[38;5;246m0c ", "\x1b[38;5;246m0d ",
	"\x1b[38;5;246m0e ", "\x1b[38;5;246m0f ",
	"\x1b[38;5;246m10 ", "\x1b[38;5;246m11 ",
	"\x1b[38;5;246m12 ", "\x1b[38;5;246m13 ",
	"\x1b[38;5;246m14 ", "\x1b[38;5;246m15 ",
	"\x1b[38;5;246m16 ", "\x1b[38;5;246m17 ",
	"\x1b[38;5;246m18 ", "\x1b[38;5;246m19 ",
	"\x1b[38;5;246m1a ", "\x1b[38;5;246m1b ",
	"\x1b[38;5;246m1c ", "\x1b[38;5;246m1d ",
	"\x1b[38;5;246m1e ", "\x1b[38;5;246m1f ",
	"\x1b[38;5;72m20\x1b[38;5;239m ", "\x1b[38;5;72m21\x1b[38;5;239m!",
	"\x1b[38;5;72m22\x1b[38;5;239m\"", "\x1b[38;5;72m23\x1b[38;5;239m#",
	"\x1b[38;5;72m24\x1b[38;5;239m$", "\x1b[38;5;72m25\x1b[38;5;239m%",
	"\x1b[38;5;72m26\x1b[38;5;239m&", "\x1b[38;5;72m27\x1b[38;5;239m'",
	"\x1b[38;5;72m28\x1b[38;5;239m(", "\x1b[38;5;72m29\x1b[38;5;239m)",
	"\x1b[38;5;72m2a\x1b[38;5;239m*", "\x1b[38;5;72m2b\x1b[38;5;239m+",
	"\x1b[38;5;72m2c\x1b[38;5;239m,", "\x1b[38;5;72m2d\x1b[38;5;239m-",
	"\x1b[38;5;72m2e\x1b[38;5;239m.", "\x1b[38;5;72m2f\x1b[38;5;239m/",
	"\x1b[38;5;72m30\x1b[38;5;239m0", "\x1b[38;5;72m31\x1b[38;5;239m1",
	"\x1b[38;5;72m32\x1b[38;5;239m2", "\x1b[38;5;72m33\x1b[38;5;239m3",
	"\x1b[38;5;72m34\x1b[38;5;239m4", "\x1b[38;5;72m35\x1b[38;5;239m5",
	"\x1b[38;5;72m36\x1b[38;5;239m6", "\x1b[38;5;72m37\x1b[38;5;239m7",
	"\x1b[38;5;72m38\x1b[38;5;239m8", "\x1b[38;5;72m39\x1b[38;5;239m9",
	"\x1b[38;5;72m3a\x1b[38;5;239m:", "\x1b[38;5;72m3b\x1b[38;5;239m;",
	"\x1b[38;5;72m3c\x1b[38;5;239m<", "\x1b[38;5;72m3d\x1b[38;5;239m=",
	"\x1b[38;5;72m3e\x1b[38;5;239m>", "\x1b[38;5;72m3f\x1b[38;5;239m?",
	"\x1b[38;5;72m40\x1b[38;5;239m@", "\x1b[38;5;72m41\x1b[38;5;239mA",
	"\x1b[38;5;72m42\x1b[38;5;239mB", "\x1b[38;5;72m43\x1b[38;5;239mC",
	"\x1b[38;5;72m44\x1b[38;5;239mD", "\x1b[38;5;72m45\x1b[38;5;239mE",
	"\x1b[38;5;72m46\x1b[38;5;239mF", "\x1b[38;5;72m47\x1b[38;5;239mG",
	"\x1b[38;5;72m48\x1b[38;5;239mH", "\x1b[38;5;72m49\x1b[38;5;239mI",
	"\x1b[38;5;72m4a\x1b[38;5;239mJ", "\x1b[38;5;72m4b\x1b[38;5;239mK",
	"\x1b[38;5;72m4c\x1b[38;5;239mL", "\x1b[38;5;72m4d\x1b[38;5;239mM",
	"\x1b[38;5;72m4e\x1b[38;5;239mN", "\x1b[38;5;72m4f\x1b[38;5;239mO",
	"\x1b[38;5;72m50\x1b[38;5;239mP", "\x1b[38;5;72m51\x1b[38;5;239mQ",
	"\x1b[38;5;72m52\x1b[38;5;239mR", "\x1b[38;5;72m53\x1b[38;5;239mS",
	"\x1b[38;5;72m54\x1b[38;5;239mT", "\x1b[38;5;72m55\x1b[38;5;239mU",
	"\x1b[38;5;72m56\x1b[38;5;239mV", "\x1b[38;5;72m57\x1b[38;5;239mW",
	"\x1b[38;5;72m58\x1b[38;5;239mX", "\x1b[38;5;72m59\x1b[38;5;239mY",
	"\x1b[38;5;72m5a\x1b[38;5;239mZ", "\x1b[38;5;72m5b\x1b[38;5;239m[",
	"\x1b[38;5;72m5c\x1b[38;5;239m\\", "\x1b[38;5;72m5d\x1b[38;5;239m]",
	"\x1b[38;5;72m5e\x1b[38;5;239m^", "\x1b[38;5;72m5f\x1b[38;5;239m_",
	"\x1b[38;5;72m60\x1b[38;5;239m`", "\x1b[38;5;72m61\x1b[38;5;239ma",
	"\x1b[38;5;72m62\x1b[38;5;239mb", "\x1b[38;5;72m63\x1b[38;5;239mc",
	"\x1b[38;5;72m64\x1b[38;5;239md", "\x1b[38;5;72m65\x1b[38;5;239me",
	"\x1b[38;5;72m66\x1b[38;5;239mf", "\x1b[38;5;72m67\x1b[38;5;239mg",
	"\x1b[38;5;72m68\x1b[38;5;239mh", "\x1b[38;5;72m69\x1b[38;5;239mi",
	"\x1b[38;5;72m6a\x1b[38;5;239mj", "\x1b[38;5;72m6b\x1b[38;5;239mk",
	"\x1b[38;5;72m6c\x1b[38;5;239ml", "\x1b[38;5;72m6d\x1b[38;5;239mm",
	"\x1b[38;5;72m6e\x1b[38;5;239mn", "\x1b[38;5;72m6f\x1b[38;5;239mo",
	"\x1b[38;5;72m70\x1b[38;5;239mp", "\x1b[38;5;72m71\x1b[38;5;239mq",
	"\x1b[38;5;72m72\x1b[38;5;239mr", "\x1b[38;5;72m73\x1b[38;5;239ms",
	"\x1b[38;5;72m74\x1b[38;5;239mt", "\x1b[38;5;72m75\x1b[38;5;239mu",
	"\x1b[38;5;72m76\x1b[38;5;239mv", "\x1b[38;5;72m77\x1b[38;5;239mw",
	"\x1b[38;5;72m78\x1b[38;5;239mx", "\x1b[38;5;72m79\x1b[38;5;239my",
	"\x1b[38;5;72m7a\x1b[38;5;239mz", "\x1b[38;5;72m7b\x1b[38;5;239m{",
	"\x1b[38;5;72m7c\x1b[38;5;239m|", "\x1b[38;5;72m7d\x1b[38;5;239m}",
	"\x1b[38;5;72m7e\x1b[38;5;239m~", "\x1b[38;5;246m7f ",
	"\x1b[38;5;246m80 ", "\x1b[38;5;246m81 ",
	"\x1b[38;5;246m82 ", "\x1b[38;5;246m83 ",
	"\x1b[38;5;246m84 ", "\x1b[38;5;246m85 ",
	"\x1b[38;5;246m86 ", "\x1b[38;5;246m87 ",
	"\x1b[38;5;246m88 ", "\x1b[38;5;246m89 ",
	"\x1b[38;5;246m8a ", "\x1b[38;5;246m8b ",
	"\x1b[38;5;246m8c ", "\x1b[38;5;246m8d ",
	"\x1b[38;5;246m8e ", "\x1b[38;5;246m8f ",
	"\x1b[38;5;246m90 ", "\x1b[38;5;246m91 ",
	"\x1b[38;5;246m92 ", "\x1b[38;5;246m93 ",
	"\x1b[38;5;246m94 ", "\x1b[38;5;246m95 ",
	"\x1b[38;5;246m96 ", "\x1b[38;5;246m97 ",
	"\x1b[38;5;246m98 ", "\x1b[38;5;246m99 ",
	"\x1b[38;5;246m9a ", "\x1b[38;5;246m9b ",
	"\x1b[38;5;246m9c ", "\x1b[38;5;246m9d ",
	"\x1b[38;5;246m9e ", "\x1b[38;5;246m9f ",
	"\x1b[38;5;246ma0 ", "\x1b[38;5;246ma1 ",
	"\x1b[38;5;246ma2 ", "\x1b[38;5;246ma3 ",
	"\x1b[38;5;246ma4 ", "\x1b[38;5;246ma5 ",
	"\x1b[38;5;246ma6 ", "\x1b[38;5;246ma7 ",
	"\x1b[38;5;246ma8 ", "\x1b[38;5;246ma9 ",
	"\x1b[38;5;246maa ", "\x1b[38;5;246mab ",
	"\x1b[38;5;246mac ", "\x1b[38;5;246mad ",
	"\x1b[38;5;246mae ", "\x1b[38;5;246maf ",
	"\x1b[38;5;246mb0 ", "\x1b[38;5;246mb1 ",
	"\x1b[38;5;246mb2 ", "\x1b[38;5;246mb3 ",
	"\x1b[38;5;246mb4 ", "\x1b[38;5;246mb5 ",
	"\x1b[38;5;246mb6 ", "\x1b[38;5;246mb7 ",
	"\x1b[38;5;246mb8 ", "\x1b[38;5;246mb9 ",
	"\x1b[38;5;246mba ", "\x1b[38;5;246mbb ",
	"\x1b[38;5;246mbc ", "\x1b[38;5;246mbd ",
	"\x1b[38;5;246mbe ", "\x1b[38;5;246mbf ",
	"\x1b[38;5;246mc0 ", "\x1b[38;5;246mc1 ",
	"\x1b[38;5;246mc2 ", "\x1b[38;5;246mc3 ",
	"\x1b[38;5;246mc4 ", "\x1b[38;5;246mc5 ",
	"\x1b[38;5;246mc6 ", "\x1b[38;5;246mc7 ",
	"\x1b[38;5;246mc8 ", "\x1b[38;5;246mc9 ",
	"\x1b[38;5;246mca ", "\x1b[38;5;246mcb ",
	"\x1b[38;5;246mcc ", "\x1b[38;5;246mcd ",
	"\x1b[38;5;246mce ", "\x1b[38;5;246mcf ",
	"\x1b[38;5;246md0 ", "\x1b[38;5;246md1 ",
	"\x1b[38;5;246md2 ", "\x1b[38;5;246md3 ",
	"\x1b[38;5;246md4 ", "\x1b[38;5;246md5 ",
	"\x1b[38;5;246md6 ", "\x1b[38;5;246md7 ",
	"\x1b[38;5;246md8 ", "\x1b[38;5;246md9 ",
	"\x1b[38;5;246mda ", "\x1b[38;5;246mdb ",
	"\x1b[38;5;246mdc ", "\x1b[38;5;246mdd ",
	"\x1b[38;5;246mde ", "\x1b[38;5;246mdf ",
	"\x1b[38;5;246me0 ", "\x1b[38;5;246me1 ",
	"\x1b[38;5;246me2 ", "\x1b[38;5;246me3 ",
	"\x1b[38;5;246me4 ", "\x1b[38;5;246me5 ",
	"\x1b[38;5;246me6 ", "\x1b[38;5;246me7 ",
	"\x1b[38;5;246me8 ", "\x1b[38;5;246me9 ",
	"\x1b[38;5;246mea ", "\x1b[38;5;246meb ",
	"\x1b[38;5;246mec ", "\x1b[38;5;246med ",
	"\x1b[38;5;246mee ", "\x1b[38;5;246mef ",
	"\x1b[38;5;246mf0 ", "\x1b[38;5;246mf1 ",
	"\x1b[38;5;246mf2 ", "\x1b[38;5;246mf3 ",
	"\x1b[38;5;246mf4 ", "\x1b[38;5;246mf5 ",
	"\x1b[38;5;246mf6 ", "\x1b[38;5;246mf7 ",
	"\x1b[38;5;246mf8 ", "\x1b[38;5;246mf9 ",
	"\x1b[38;5;246mfa ", "\x1b[38;5;246mfb ",
	"\x1b[38;5;246mfc ", "\x1b[38;5;246mfd ",
	"\x1b[38;5;246mfe ", "\x1b[38;5;209mff ",
}

// hexSymbols is a direct lookup table combining 2 hex digits with either a
// space or a displayable ASCII symbol matching the byte's own ASCII value;
// this table was autogenerated by running the command
//
// seq 0 255 | ./hex-symbols.awk
var hexSymbols = [256]string{
	`00 `, `01 `, `02 `, `03 `, `04 `, `05 `, `06 `, `07 `,
	`08 `, `09 `, `0a `, `0b `, `0c `, `0d `, `0e `, `0f `,
	`10 `, `11 `, `12 `, `13 `, `14 `, `15 `, `16 `, `17 `,
	`18 `, `19 `, `1a `, `1b `, `1c `, `1d `, `1e `, `1f `,
	`20 `, `21!`, `22"`, `23#`, `24$`, `25%`, `26&`, `27'`,
	`28(`, `29)`, `2a*`, `2b+`, `2c,`, `2d-`, `2e.`, `2f/`,
	`300`, `311`, `322`, `333`, `344`, `355`, `366`, `377`,
	`388`, `399`, `3a:`, `3b;`, `3c<`, `3d=`, `3e>`, `3f?`,
	`40@`, `41A`, `42B`, `43C`, `44D`, `45E`, `46F`, `47G`,
	`48H`, `49I`, `4aJ`, `4bK`, `4cL`, `4dM`, `4eN`, `4fO`,
	`50P`, `51Q`, `52R`, `53S`, `54T`, `55U`, `56V`, `57W`,
	`58X`, `59Y`, `5aZ`, `5b[`, `5c\`, `5d]`, `5e^`, `5f_`,
	"60`", `61a`, `62b`, `63c`, `64d`, `65e`, `66f`, `67g`,
	`68h`, `69i`, `6aj`, `6bk`, `6cl`, `6dm`, `6en`, `6fo`,
	`70p`, `71q`, `72r`, `73s`, `74t`, `75u`, `76v`, `77w`,
	`78x`, `79y`, `7az`, `7b{`, `7c|`, `7d}`, `7e~`, `7f `,
	`80 `, `81 `, `82 `, `83 `, `84 `, `85 `, `86 `, `87 `,
	`88 `, `89 `, `8a `, `8b `, `8c `, `8d `, `8e `, `8f `,
	`90 `, `91 `, `92 `, `93 `, `94 `, `95 `, `96 `, `97 `,
	`98 `, `99 `, `9a `, `9b `, `9c `, `9d `, `9e `, `9f `,
	`a0 `, `a1 `, `a2 `, `a3 `, `a4 `, `a5 `, `a6 `, `a7 `,
	`a8 `, `a9 `, `aa `, `ab `, `ac `, `ad `, `ae `, `af `,
	`b0 `, `b1 `, `b2 `, `b3 `, `b4 `, `b5 `, `b6 `, `b7 `,
	`b8 `, `b9 `, `ba `, `bb `, `bc `, `bd `, `be `, `bf `,
	`c0 `, `c1 `, `c2 `, `c3 `, `c4 `, `c5 `, `c6 `, `c7 `,
	`c8 `, `c9 `, `ca `, `cb `, `cc `, `cd `, `ce `, `cf `,
	`d0 `, `d1 `, `d2 `, `d3 `, `d4 `, `d5 `, `d6 `, `d7 `,
	`d8 `, `d9 `, `da `, `db `, `dc `, `dd `, `de `, `df `,
	`e0 `, `e1 `, `e2 `, `e3 `, `e4 `, `e5 `, `e6 `, `e7 `,
	`e8 `, `e9 `, `ea `, `eb `, `ec `, `ed `, `ee `, `ef `,
	`f0 `, `f1 `, `f2 `, `f3 `, `f4 `, `f5 `, `f6 `, `f7 `,
	`f8 `, `f9 `, `fa `, `fb `, `fc `, `fd `, `fe `, `ff `,
}

const (
	unknownStyle = 0
	zeroStyle    = 1
	otherStyle   = 2
	asciiStyle   = 3
	allOnStyle   = 4
)

// byteStyles turns bytes into one of several distinct visual types, which
// allows quickly telling when ANSI styles codes are repetitive and when
// they're actually needed
var byteStyles = [256]int{
	zeroStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, asciiStyle,
	asciiStyle, asciiStyle, asciiStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, otherStyle,
	otherStyle, otherStyle, otherStyle, allOnStyle,
}

// writeMetaANSI shows metadata right before the ANSI-styled hex byte-view
func writeMetaANSI(w *bufio.Writer, fname string, fsize int, cfg config) {
	if cfg.Title != "" {
		fmt.Fprintf(w, "\x1b[4m%s\x1b[0m\n", cfg.Title)
		w.WriteString("\n")
	}

	if fsize < 0 {
		fmt.Fprintf(w, "• %s\n", fname)
	} else {
		const fs = "• %s  \x1b[38;5;248m(%s bytes)\x1b[0m\n"
		fmt.Fprintf(w, fs, fname, sprintCommas(fsize))
	}

	if cfg.Skip > 0 {
		const fs = "   \x1b[38;5;5mskipping first %s bytes\x1b[0m\n"
		fmt.Fprintf(w, fs, sprintCommas(cfg.Skip))
	}
	if cfg.MaxBytes > 0 {
		const fs = "   \x1b[38;5;5mshowing only up to %s bytes\x1b[0m\n"
		fmt.Fprintf(w, fs, sprintCommas(cfg.MaxBytes))
	}
	w.WriteString("\n")
}

// writeBufferANSI shows the hex byte-view using ANSI colors/styles
func writeBufferANSI(rc rendererConfig, first, second []byte) error {
	// show a ruler every few lines to make eye-scanning easier
	if rc.chunks%5 == 0 && rc.chunks > 0 {
		writeRulerANSI(rc)
	}

	return writeLineANSI(rc, first, second)
}

// writeRulerANSI emits an indented ANSI-styled line showing spaced-out dots,
// so as to help eye-scan items on nearby output lines
func writeRulerANSI(rc rendererConfig) {
	w := rc.out
	if len(rc.ruler) == 0 {
		w.WriteByte('\n')
		return
	}

	w.WriteString("\x1b[38;5;248m")
	indent := int(rc.offsetWidth) + len(padding)
	writeSpaces(w, indent)
	w.Write(rc.ruler)
	w.WriteString("\x1b[0m\n")
}

func writeLineANSI(rc rendererConfig, first, second []byte) error {
	w := rc.out

	// start each line with the byte-offset for the 1st item shown on it
	if rc.showOffsets {
		writeStyledCounter(w, int(rc.offsetWidth), rc.offset)
		w.WriteString(padding + "\x1b[48;5;254m")
	} else {
		w.WriteString(padding)
	}

	prevStyle := unknownStyle
	for _, b := range first {
		// using the slow/generic fmt.Fprintf is a performance bottleneck,
		// since it's called for each input byte
		// w.WriteString(styledHexBytes[b])

		// this more complicated way of emitting output avoids repeating
		// ANSI styles when dealing with bytes which aren't displayable
		// ASCII symbols, thus emitting fewer bytes when dealing with
		// general binary datasets; it makes no difference for plain-text
		// ASCII input
		style := byteStyles[b]
		if style != prevStyle {
			w.WriteString(styledHexBytes[b])
			if style == asciiStyle {
				// styling displayable ASCII symbols uses multiple different
				// styles each time it happens, always forcing ANSI-style
				// updates
				style = unknownStyle
			}
		} else {
			w.WriteString(hexSymbols[b])
		}
		prevStyle = style
	}

	w.WriteString("\x1b[0m")
	if rc.showASCII {
		writePlainASCII(w, first, second, int(rc.perLine))
	}

	return w.WriteByte('\n')
}

func writeStyledCounter(w *bufio.Writer, width int, n uint) {
	var buf [32]byte
	str := strconv.AppendUint(buf[:0], uint64(n), 10)

	// left-pad the final result with leading spaces
	writeSpaces(w, width-len(str))

	var style bool
	// emit leading part with 1 or 2 digits unstyled, ensuring the
	// rest or the rendered number's string is a multiple of 3 long
	if rem := len(str) % 3; rem != 0 {
		w.Write(str[:rem])
		str = str[rem:]
		// next digit-group needs some styling
		style = true
	} else {
		style = false
	}

	// alternate between styled/unstyled 3-digit groups
	for len(str) > 0 {
		if !style {
			w.Write(str[:3])
		} else {
			w.WriteString("\x1b[38;5;248m")
			w.Write(str[:3])
			w.WriteString("\x1b[0m")
		}

		style = !style
		str = str[3:]
	}
}