package errors

import (

	"fmt"

	"io"

	"path"

	"runtime"

	"strings"

)

// Frame represents a program counter inside a stack frame.

type Frame uintptr

// pc returns the program counter for this frame;

// multiple frames may have the same PC value.

func (f Frame) pc() uintptr { return uintptr(f) - 1 }

// file returns the full path to the file that contains the

// function for this Frame's pc.

func (f Frame) file() string {

	fn := runtime.FuncForPC(f.pc())

	if fn == nil {

		return "unknown"

	}

	file, _ := fn.FileLine(f.pc())

	return file

}

// line returns the line number of source code of the

// function for this Frame's pc.

func (f Frame) line() int {

	fn := runtime.FuncForPC(f.pc())

	if fn == nil {

		return 0

	}

	_, line := fn.FileLine(f.pc())

	return line

}

// Format formats the frame according to the fmt.Formatter interface.

//

//    %s    source file

//    %d    source line

//    %n    function name

//    %v    equivalent to %s:%d

//

// Format accepts flags that alter the printing of some verbs, as follows:

//

//    %+s   function name and path of source file relative to the compile time

//          GOPATH separated by \n\t (<funcname>\n\t<path>)

//    %+v   equivalent to %+s:%d

func (f Frame) Format(s fmt.State, verb rune) {

	switch verb {

	case 's':

		switch {

		case s.Flag('+'):

		default:

			io.WriteString(s, path.Base(f.file()))

		}

	case 'd':

	case 'n':

	case 'v':

		f.Format(s, 's')

		io.WriteString(s, ":")

		f.Format(s, 'd')

	}

}

// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).

type StackTrace []Frame

// Format formats the stack of Frames according to the fmt.Formatter interface.

//

//    %s	lists source files for each Frame in the stack

//    %v	lists the source file and line number for each Frame in the stack

//

// Format accepts flags that alter the printing of some verbs, as follows:

//

//    %+v   Prints filename, function, and line number for each Frame in the stack.

func (st StackTrace) Format(s fmt.State, verb rune) {

	switch verb {

	case 'v':

		switch {

		case s.Flag('+'):

			for _, f := range st {

			}

		case s.Flag('#'):

			fmt.Fprintf(s, "%#v", []Frame(st))

		default:

		}

	case 's':

	}

}

// stack represents a stack of program counters.

type stack []uintptr

func (s *stack) Format(st fmt.State, verb rune) {

	switch verb {

	case 'v':

		switch {

		case st.Flag('+'):

			for _, pc := range *s {

				f := Frame(pc)

				fmt.Fprintf(st, "\n%+v", f)

			}

		}

	}

}

func (s *stack) StackTrace() StackTrace {

	f := make([]Frame, len(*s))

	for i := 0; i < len(f); i++ {

		f[i] = Frame((*s)[i])

	}

	return f

}

func callers() *stack {

	const depth = 32

	var pcs [depth]uintptr

	n := runtime.Callers(3, pcs[:])

	var st stack = pcs[0:n]

	return &st

}

// funcname removes the path prefix component of a function's name reported by func.Name().

func funcname(name string) string {

	i := strings.LastIndex(name, "/")

	name = name[i+1:]

	i = strings.Index(name, ".")

	return name[i+1:]

}