/*

 * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

package spew

import (

	"bytes"

	"fmt"

	"io"

	"reflect"

	"sort"

	"strconv"

)

// Some constants in the form of bytes to avoid string overhead.  This mirrors

// the technique used in the fmt package.

var (

	panicBytes            = []byte("(PANIC=")

	plusBytes             = []byte("+")

	iBytes                = []byte("i")

	trueBytes             = []byte("true")

	falseBytes            = []byte("false")

	interfaceBytes        = []byte("(interface {})")

	commaNewlineBytes     = []byte(",\n")

	newlineBytes          = []byte("\n")

	openBraceBytes        = []byte("{")

	openBraceNewlineBytes = []byte("{\n")

	closeBraceBytes       = []byte("}")

	asteriskBytes         = []byte("*")

	colonBytes            = []byte(":")

	colonSpaceBytes       = []byte(": ")

	openParenBytes        = []byte("(")

	closeParenBytes       = []byte(")")

	spaceBytes            = []byte(" ")

	pointerChainBytes     = []byte("->")

	nilAngleBytes         = []byte("<nil>")

	maxNewlineBytes       = []byte("<max depth reached>\n")

	maxShortBytes         = []byte("<max>")

	circularBytes         = []byte("<already shown>")

	circularShortBytes    = []byte("<shown>")

	invalidAngleBytes     = []byte("<invalid>")

	openBracketBytes      = []byte("[")

	closeBracketBytes     = []byte("]")

	percentBytes          = []byte("%")

	precisionBytes        = []byte(".")

	openAngleBytes        = []byte("<")

	closeAngleBytes       = []byte(">")

	openMapBytes          = []byte("map[")

	closeMapBytes         = []byte("]")

	lenEqualsBytes        = []byte("len=")

	capEqualsBytes        = []byte("cap=")

)

// hexDigits is used to map a decimal value to a hex digit.

var hexDigits = "0123456789abcdef"

// catchPanic handles any panics that might occur during the handleMethods

// calls.

func catchPanic(w io.Writer, v reflect.Value) {

	if err := recover(); err != nil {

		w.Write(panicBytes)

		fmt.Fprintf(w, "%v", err)

		w.Write(closeParenBytes)

	}

}

// handleMethods attempts to call the Error and String methods on the underlying

// type the passed reflect.Value represents and outputes the result to Writer w.

//

// It handles panics in any called methods by catching and displaying the error

// as the formatted value.

func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {

	// We need an interface to check if the type implements the error or

	// Stringer interface.  However, the reflect package won't give us an

	// interface on certain things like unexported struct fields in order

	// to enforce visibility rules.  We use unsafe, when it's available,

	// to bypass these restrictions since this package does not mutate the

	// values.

	if !v.CanInterface() {

		if UnsafeDisabled {

			return false

		}

		v = unsafeReflectValue(v)

	}

	// Choose whether or not to do error and Stringer interface lookups against

	// the base type or a pointer to the base type depending on settings.

	// Technically calling one of these methods with a pointer receiver can

	// mutate the value, however, types which choose to satisify an error or

	// Stringer interface with a pointer receiver should not be mutating their

	// state inside these interface methods.

	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {

		v = unsafeReflectValue(v)

	}

	if v.CanAddr() {

		v = v.Addr()

	}

	// Is it an error or Stringer?

	switch iface := v.Interface().(type) {

	case error:

		defer catchPanic(w, v)

		if cs.ContinueOnMethod {

			w.Write(openParenBytes)

			w.Write([]byte(iface.Error()))

			w.Write(closeParenBytes)

			w.Write(spaceBytes)

			return false

		}

		w.Write([]byte(iface.Error()))

		return true

	case fmt.Stringer:

		defer catchPanic(w, v)

		if cs.ContinueOnMethod {

			w.Write(openParenBytes)

			w.Write([]byte(iface.String()))

			w.Write(closeParenBytes)

			w.Write(spaceBytes)

			return false

		}

		w.Write([]byte(iface.String()))

		return true

	}

	return false

}

// printBool outputs a boolean value as true or false to Writer w.

func printBool(w io.Writer, val bool) {

	if val {

		w.Write(trueBytes)

	} else {

		w.Write(falseBytes)

	}

}

// printInt outputs a signed integer value to Writer w.

func printInt(w io.Writer, val int64, base int) {

	w.Write([]byte(strconv.FormatInt(val, base)))

}

// printUint outputs an unsigned integer value to Writer w.

func printUint(w io.Writer, val uint64, base int) {

	w.Write([]byte(strconv.FormatUint(val, base)))

}

// printFloat outputs a floating point value using the specified precision,

// which is expected to be 32 or 64bit, to Writer w.

func printFloat(w io.Writer, val float64, precision int) {

	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))

}

// printComplex outputs a complex value using the specified float precision

// for the real and imaginary parts to Writer w.

func printComplex(w io.Writer, c complex128, floatPrecision int) {

	r := real(c)

	w.Write(openParenBytes)

	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))

	i := imag(c)

	if i >= 0 {

		w.Write(plusBytes)

	}

	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))

	w.Write(iBytes)

	w.Write(closeParenBytes)

}

// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'

// prefix to Writer w.

func printHexPtr(w io.Writer, p uintptr) {

	// Null pointer.

	num := uint64(p)

	if num == 0 {

		w.Write(nilAngleBytes)

		return

	}

	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix

	buf := make([]byte, 18)

	// It's simpler to construct the hex string right to left.

	base := uint64(16)

	i := len(buf) - 1

	for num >= base {

		buf[i] = hexDigits[num%base]

		num /= base

		i--

	}

	buf[i] = hexDigits[num]

	// Add '0x' prefix.

	i--

	buf[i] = 'x'

	i--

	buf[i] = '0'

	// Strip unused leading bytes.

	buf = buf[i:]

	w.Write(buf)

}

// valuesSorter implements sort.Interface to allow a slice of reflect.Value

// elements to be sorted.

type valuesSorter struct {

	values  []reflect.Value

	strings []string // either nil or same len and values

	cs      *ConfigState

}

// newValuesSorter initializes a valuesSorter instance, which holds a set of

// surrogate keys on which the data should be sorted.  It uses flags in

// ConfigState to decide if and how to populate those surrogate keys.

func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {

	vs := &valuesSorter{values: values, cs: cs}

	if canSortSimply(vs.values[0].Kind()) {

		return vs

	}

	if !cs.DisableMethods {

		vs.strings = make([]string, len(values))

		for i := range vs.values {

			b := bytes.Buffer{}

			if !handleMethods(cs, &b, vs.values[i]) {

				vs.strings = nil

				break

			}

			vs.strings[i] = b.String()

		}

	}

	if vs.strings == nil && cs.SpewKeys {

		vs.strings = make([]string, len(values))

		for i := range vs.values {

			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())

		}

	}

	return vs

}

// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted

// directly, or whether it should be considered for sorting by surrogate keys

// (if the ConfigState allows it).

func canSortSimply(kind reflect.Kind) bool {

	// This switch parallels valueSortLess, except for the default case.

	switch kind {

	case reflect.Bool:

		return true

	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:

		return true

	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:

		return true

	case reflect.Float32, reflect.Float64:

		return true

	case reflect.String:

		return true

	case reflect.Uintptr:

		return true

	case reflect.Array:

		return true

	}

	return false

}

// Len returns the number of values in the slice.  It is part of the

// sort.Interface implementation.

func (s *valuesSorter) Len() int {

	return len(s.values)

}

// Swap swaps the values at the passed indices.  It is part of the

// sort.Interface implementation.

func (s *valuesSorter) Swap(i, j int) {

	s.values[i], s.values[j] = s.values[j], s.values[i]

	if s.strings != nil {

		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]

	}

}

// valueSortLess returns whether the first value should sort before the second

// value.  It is used by valueSorter.Less as part of the sort.Interface

// implementation.

func valueSortLess(a, b reflect.Value) bool {

	switch a.Kind() {

	case reflect.Bool:

		return !a.Bool() && b.Bool()

	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:

		return a.Int() < b.Int()

	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:

		return a.Uint() < b.Uint()

	case reflect.Float32, reflect.Float64:

		return a.Float() < b.Float()

	case reflect.String:

		return a.String() < b.String()

	case reflect.Uintptr:

		return a.Uint() < b.Uint()

	case reflect.Array:

		// Compare the contents of both arrays.

		l := a.Len()

		for i := 0; i < l; i++ {

			av := a.Index(i)

			bv := b.Index(i)

			if av.Interface() == bv.Interface() {

				continue

			}

			return valueSortLess(av, bv)

		}

	}

	return a.String() < b.String()

}

// Less returns whether the value at index i should sort before the

// value at index j.  It is part of the sort.Interface implementation.

func (s *valuesSorter) Less(i, j int) bool {

	if s.strings == nil {

		return valueSortLess(s.values[i], s.values[j])

	}

	return s.strings[i] < s.strings[j]

}

// sortValues is a sort function that handles both native types and any type that

// can be converted to error or Stringer.  Other inputs are sorted according to

// their Value.String() value to ensure display stability.

func sortValues(values []reflect.Value, cs *ConfigState) {

	if len(values) == 0 {

		return

	}

	sort.Sort(newValuesSorter(values, cs))

}