errutil

func TestMultiError_Error(t *testing.T)

{
	e := &MultiError{}
	if e.Error() != "" {
		t.Errorf("empty multierror should return empty string, got %q", e.Error())
	}

	e.Append(errors.New("one"))
	if e.Error() != "one" {
		t.Errorf("single error: got %q, want %q", e.Error(), "one")
	}

	e.Append(errors.New("two"))
	want := "multiple errors occurred: one; two"
	if e.Error() != want {
		t.Errorf("multiple errors: got %q, want %q", e.Error(), want)
	}
}

func TestJoinErrors(t *testing.T)

{
	err := JoinErrors(errors.New("a"), nil, errors.New("b"))
	if err == nil {
		t.Fatal("JoinErrors should return error")
	}
	if !strings.Contains(err.Error(), "a") || !strings.Contains(err.Error(), "b") {
		t.Errorf("JoinErrors error content: %v", err)
	}

	if JoinErrors(nil, nil) != nil {
		t.Error("JoinErrors with only nil should return nil")
	}
}

func drawRichTrace(r any)

{
	raw := debug.Stack()
	lines := strings.Split(string(raw), "\n")

	type entry struct {
		funcName string
		file     string
		line     int
	}

	var stack []entry

	for i := 0; i < len(lines); i++ {
		l := lines[i]
		t := strings.TrimSpace(l)

		if t == "" || strings.HasPrefix(t, "goroutine ") {
			continue
		}
		if strings.HasPrefix(t, "runtime.") || strings.Contains(t, "runtime/") {
			continue
		}
		if strings.Contains(t, "pkg/errutil/") || strings.HasPrefix(t, "created by ") {
			continue
		}
		if strings.Contains(t, "panic({") {
			continue
		}

		if !strings.Contains(t, ".go:") && !strings.HasPrefix(t, "created by ") {
			fn := strings.TrimSuffix(t, "(...)")
			fn = strings.TrimSuffix(fn, " {...}")

			e := entry{funcName: fn}

			if i+1 < len(lines) {
				nl := strings.TrimSpace(lines[i+1])
				if strings.Contains(nl, ".go:") {
					parts := strings.SplitN(nl, ".go:", 2)
					if len(parts) == 2 {
						e.file = strings.TrimSpace(parts[0]) + ".go"
						numStr := strings.TrimSpace(parts[1])
						if idx := strings.Index(numStr, " +"); idx != -1 {
							numStr = numStr[:idx]
						}
						n, err := strconv.Atoi(numStr)
						if err == nil {
							e.line = n
						}
					}
					i++
				}
			}

			if !strings.Contains(e.funcName, "drawRichTrace") && !strings.Contains(e.funcName, "Auto.func1") && !strings.HasPrefix(e.funcName, "Auto") && !strings.HasPrefix(e.funcName, "EnableAuto") && !strings.HasPrefix(e.funcName, "github.com/mirkobrombin/go-foundation/pkg/errutil.") {
				stack = append(stack, e)
			}
		}
	}

	yl := "\x1b[33m"
	cy := "\x1b[36m"
	gy := "\x1b[90m"
	rs := "\x1b[0m"

	fmt.Fprintf(os.Stderr, "\n  panic: %v\n\n", r)

	if len(stack) == 0 {
		fmt.Fprintln(os.Stderr, "  (no user frames)")
		return
	}

	for i := len(stack) - 1; i >= 0; i-- {
		e := stack[i]
		num := len(stack) - i

		fmt.Fprintf(os.Stderr, "  %s%d.%s %s%s%s\n", yl, num, rs, cy, e.funcName, rs)
		if e.file != "" {
			fmt.Fprintf(os.Stderr, "     %s%s:%d%s\n", gy, e.file, e.line, rs)
			snip(e.file, e.line, os.Stderr)
		}
		fmt.Fprintln(os.Stderr)
	}
}

func snip(path string, target int, w *os.File)

{
	f, err := os.Open(path)
	if err != nil {
		fmt.Fprintf(w, "      %s(source not available)%s\n", gy, rs)
		return
	}
	defer f.Close()

	start := target - 2
	if start < 1 {
		start = 1
	}
	end := target + 2

	s := bufio.NewScanner(f)
	n := 0
	for s.Scan() {
		n++
		if n < start {
			continue
		}
		if n > end {
			break
		}
		mark := "   "
		if n == target {
			mark = " >>"
		}
		fmt.Fprintf(w, "      %s %5d  %s\n", mark, n, s.Text())
	}
}

func Print(err error)

{
	if err == nil {
		return
	}

	fmt.Fprintf(os.Stderr, "\n  error: %s\n\n", err.Error())

	type frame struct {
		funcName string
		file     string
		line     int
	}
	var chain []frame
	seen := map[*withStack]bool{}

	for e := err; e != nil; e = unwrapOne(e) {
		if ws, ok := e.(*withStack); ok && !seen[ws] {
			seen[ws] = true
			frms := runtime.CallersFrames(ws.stack)
			for {
				f, more := frms.Next()
				fn := f.Func.Name()
				if fn == "" {
					if !more {
						break
					}
					continue
				}
				if isSkip(fn) {
					if !more {
						break
					}
					continue
				}
				chain = append(chain, frame{funcName: fn[strings.LastIndex(fn, "/")+1:], file: f.File, line: f.Line})
				if !more {
					break
				}
			}
		}
	}

	for i := len(chain) - 1; i >= 0; i-- {
		f := chain[i]
		num := len(chain) - i
		fmt.Fprintf(os.Stderr, "  %s%d.%s %s%s%s\n", yl, num, rs, cy, f.funcName, rs)
		fmt.Fprintf(os.Stderr, "     %s%s:%d%s\n", gy, f.file, f.line, rs)
		snip(f.file, f.line, os.Stderr)
		fmt.Fprintln(os.Stderr)
	}
}

func AutoHTTP(next http.Handler) http.Handler

{
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if rec := recover(); rec != nil {
				raw := debug.Stack()

				fmt.Fprintf(os.Stderr, "\n%s panic: %v %s\n", r.Method, r.URL.String(), rec)
				os.Stderr.Write(raw)
				fmt.Fprintln(os.Stderr)

				w.Header().Set("Content-Type", "text/plain; charset=utf-8")
				w.WriteHeader(http.StatusInternalServerError)

				fmt.Fprintf(w, "500 - Internal Server Error\n\n")
				fmt.Fprintf(w, "panic: %v\n\n", rec)
				fmt.Fprintf(w, "Request: %s %s\n\n", r.Method, r.URL.String())

				lines := bytes.Split(raw, []byte("\n"))
				for _, l := range lines {
					str := string(bytes.TrimSpace(l))
					if str == "" || len(str) == 0 {
						continue
					}
					if startsWithAny(str, "goroutine ", "runtime.", "panic({", "pkg/errutil/") {
						continue
					}
					if containsAny(str, "runtime/", "runtime(") {
						continue
					}
					fmt.Fprintf(w, "  %s\n", str)
				}
			}
		}()
		next.ServeHTTP(w, r)
	})
}

func Wrap(err error) error

{
	if err == nil {
		return nil
	}
	if _, ok := err.(*withStack); ok {
		return err
	}
	pc := make([]uintptr, 32)
	n := runtime.Callers(2, pc)
	return &withStack{err: err, stack: pc[:n]}
}

func StackTrace(err error) []uintptr

{
	type stackTracer interface {
		Stack() []uintptr
	}
	var st stackTracer
	for {
		if s, ok := err.(stackTracer); ok {
			st = s
		}
		if unwrapper, ok := err.(interface{ Unwrap() error }); ok {
			err = unwrapper.Unwrap()
		} else {
			break
		}
	}
	if st != nil {
		return st.Stack()
	}
	return nil
}

func Recover(fn func())

{
	defer func() {
		if r := recover(); r != nil {
			stack := debug.Stack()
			lines := strings.Split(string(stack), "\n")

			var out strings.Builder
			for _, l := range lines {
				trimmed := strings.TrimSpace(l)
				if trimmed == "" {
					continue
				}
				if strings.HasPrefix(trimmed, "goroutine ") && strings.Contains(trimmed, "[running]") {
					continue
				}
				if strings.Contains(l, "runtime.") || strings.Contains(l, "runtime/") {
					continue
				}
				if strings.Contains(l, "pkg/errutil/") {
					continue
				}
				out.WriteString(l)
				out.WriteString("\n")
			}

			prefix := fmt.Sprintf("panic: %v\n", r)
			fmt.Fprint(os.Stderr, prefix+out.String())
			os.Exit(1)
		}
	}()
	fn()
}