package assert

import (

	"bufio"

	"bytes"

	"encoding/json"

	"errors"

	"fmt"

	"math"

	"os"

	"reflect"

	"regexp"

	"runtime"

	"runtime/debug"

	"strings"

	"time"

	"unicode"

	"unicode/utf8"

	"github.com/davecgh/go-spew/spew"

	"github.com/pmezard/go-difflib/difflib"

	yaml "gopkg.in/yaml.v3"

)

//go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_format.go.tmpl"

// TestingT is an interface wrapper around *testing.T

type TestingT interface {

	Errorf(format string, args ...interface{})

}

// ComparisonAssertionFunc is a common function prototype when comparing two values.  Can be useful

// for table driven tests.

type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) bool

// ValueAssertionFunc is a common function prototype when validating a single value.  Can be useful

// for table driven tests.

type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) bool

// BoolAssertionFunc is a common function prototype when validating a bool value.  Can be useful

// for table driven tests.

type BoolAssertionFunc func(TestingT, bool, ...interface{}) bool

// ErrorAssertionFunc is a common function prototype when validating an error value.  Can be useful

// for table driven tests.

type ErrorAssertionFunc func(TestingT, error, ...interface{}) bool

// Comparison is a custom function that returns true on success and false on failure

type Comparison func() (success bool)

/*

	Helper functions

*/

// ObjectsAreEqual determines if two objects are considered equal.

//

// This function does no assertion of any kind.

func ObjectsAreEqual(expected, actual interface{}) bool {

	if expected == nil || actual == nil {

		return expected == actual

	}

	exp, ok := expected.([]byte)

	if !ok {

		return reflect.DeepEqual(expected, actual)

	}

	act, ok := actual.([]byte)

	if !ok {

		return false

	}

	if exp == nil || act == nil {

		return exp == nil && act == nil

	}

	return bytes.Equal(exp, act)

}

// ObjectsAreEqualValues gets whether two objects are equal, or if their

// values are equal.

func ObjectsAreEqualValues(expected, actual interface{}) bool {

	if ObjectsAreEqual(expected, actual) {

		return true

	}

	actualType := reflect.TypeOf(actual)

	if actualType == nil {

		return false

	}

	expectedValue := reflect.ValueOf(expected)

	if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) {

		// Attempt comparison after type conversion

		return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual)

	}

	return false

}

/* CallerInfo is necessary because the assert functions use the testing object

internally, causing it to print the file:line of the assert method, rather than where

the problem actually occurred in calling code.*/

// CallerInfo returns an array of strings containing the file and line number

// of each stack frame leading from the current test to the assert call that

// failed.

func CallerInfo() []string {

	var pc uintptr

	var ok bool

	var file string

	var line int

	var name string

	callers := []string{}

	for i := 0; ; i++ {

		pc, file, line, ok = runtime.Caller(i)

		if !ok {

			// The breaks below failed to terminate the loop, and we ran off the

			// end of the call stack.

			break

		}

		// This is a huge edge case, but it will panic if this is the case, see #180

		if file == "<autogenerated>" {

			break

		}

		f := runtime.FuncForPC(pc)

		if f == nil {

			break

		}

		name = f.Name()

		// testing.tRunner is the standard library function that calls

		// tests. Subtests are called directly by tRunner, without going through

		// the Test/Benchmark/Example function that contains the t.Run calls, so

		// with subtests we should break when we hit tRunner, without adding it

		// to the list of callers.

		if name == "testing.tRunner" {

			break

		}

		parts := strings.Split(file, "/")

		file = parts[len(parts)-1]

		if len(parts) > 1 {

			dir := parts[len(parts)-2]

			if (dir != "assert" && dir != "mock" && dir != "require") || file == "mock_test.go" {

			}

		}

		// Drop the package

		segments := strings.Split(name, ".")

		name = segments[len(segments)-1]

		if isTest(name, "Test") ||

			isTest(name, "Benchmark") ||

			isTest(name, "Example") {

			break

		}

	}

	return callers

}

// Stolen from the `go test` tool.

// isTest tells whether name looks like a test (or benchmark, according to prefix).

// It is a Test (say) if there is a character after Test that is not a lower-case letter.

// We don't want TesticularCancer.

func isTest(name, prefix string) bool {

	if !strings.HasPrefix(name, prefix) {

		return false

	}

	if len(name) == len(prefix) { // "Test" is ok

		return true

	}

	r, _ := utf8.DecodeRuneInString(name[len(prefix):])

	return !unicode.IsLower(r)

}

func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {

	if len(msgAndArgs) == 0 || msgAndArgs == nil {

		return ""

	}

	if len(msgAndArgs) == 1 {

		msg := msgAndArgs[0]

		if msgAsStr, ok := msg.(string); ok {

			return msgAsStr

		}

		return fmt.Sprintf("%+v", msg)

	}

	if len(msgAndArgs) > 1 {

		return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)

	}

	return ""

}

// Aligns the provided message so that all lines after the first line start at the same location as the first line.

// Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab).

// The longestLabelLen parameter specifies the length of the longest label in the output (required becaues this is the

// basis on which the alignment occurs).

func indentMessageLines(message string, longestLabelLen int) string {

	outBuf := new(bytes.Buffer)

	for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ {

		// no need to align first line because it starts at the correct location (after the label)

		if i != 0 {

			// append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab

			outBuf.WriteString("\n\t" + strings.Repeat(" ", longestLabelLen+1) + "\t")

		}

		outBuf.WriteString(scanner.Text())

	}

	return outBuf.String()

}

type failNower interface {

	FailNow()

}

// FailNow fails test

func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {

	if h, ok := t.(tHelper); ok {

		h.Helper()

	}

	Fail(t, failureMessage, msgAndArgs...)

	// We cannot extend TestingT with FailNow() and

	// maintain backwards compatibility, so we fallback

	// to panicking when FailNow is not available in

	// TestingT.

	// See issue #263

	if t, ok := t.(failNower); ok {

		t.FailNow()

	} else {

		panic("test failed and t is missing `FailNow()`")

	}

	return false

}

// Fail reports a failure through

func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {

	if h, ok := t.(tHelper); ok {

		h.Helper()

	}

	content := []labeledContent{

		{"Error Trace", strings.Join(CallerInfo(), "\n\t\t\t")},

		{"Error", failureMessage},

	}

	// Add test name if the Go version supports it

	if n, ok := t.(interface {

		Name() string

	}); ok {

		content = append(content, labeledContent{"Test", n.Name()})

	}

	message := messageFromMsgAndArgs(msgAndArgs...)

	if len(message) > 0 {

		content = append(content, labeledContent{"Messages", message})

	}

	t.Errorf("\n%s", ""+labeledOutput(content...))

	return false

}

type labeledContent struct {

	label   string

	content string

}

// labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner:

//

//   \t{{label}}:{{align_spaces}}\t{{content}}\n

//

// The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label.

// If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this

// alignment is achieved, "\t{{content}}\n" is added for the output.

//

// If the content of the labeledOutput contains line breaks, the subsequent lines are aligned so that they start at the same location as the first line.

func labeledOutput(content ...labeledContent) string {

	longestLabel := 0

	for _, v := range content {

		if len(v.label) > longestLabel {

			longestLabel = len(v.label)

		}

	}

	var output string

	for _, v := range content {

		output += "\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n"

	}

	return output

}

// Implements asserts that an object is implemented by the specified interface.

//

//    assert.Implements(t, (*MyInterface)(nil), new(MyObject))

func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {

	if h, ok := t.(tHelper); ok {

		h.Helper()

	}

	interfaceType := reflect.TypeOf(interfaceObject).Elem()

	if object == nil {

		return Fail(t, fmt.Sprintf("Cannot check if nil implements %v", interfaceType), msgAndArgs...)

	}

	if !reflect.TypeOf(object).Implements(interfaceType) {

		return Fail(t, fmt.Sprintf("%T must implement %v", object, interfaceType), msgAndArgs...)

	}

	return true

}

// IsType asserts that the specified objects are of the same type.

func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {

	if h, ok := t.(tHelper); ok {

		h.Helper()

	}

	if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) {

		return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...)

	}

	return true

}

// Equal asserts that two objects are equal.

//

//    assert.Equal(t, 123, 123)

//

// Pointer variable equality is determined based on the equality of the

// referenced values (as opposed to the memory addresses). Function equality

// cannot be determined and will always fail.

func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {

	if h, ok := t.(tHelper); ok {

		h.Helper()

	}

	if err := validateEqualArgs(expected, actual); err != nil {

		return Fail(t, fmt.Sprintf("Invalid operation: %#v == %#v (%s)",

			expected, actual, err), msgAndArgs...)

	}

	if !ObjectsAreEqual(expected, actual) {

		diff := diff(expected, actual)

		expected, actual = formatUnequalValues(expected, actual)

		return Fail(t, fmt.Sprintf("Not equal: \n"+

			"expected: %s\n"+

			"actual  : %s%s", expected, actual, diff), msgAndArgs...)

	}

	return true

}

// validateEqualArgs checks whether provided arguments can be safely used in the

// Equal/NotEqual functions.

func validateEqualArgs(expected, actual interface{}) error {

	if expected == nil && actual == nil {

		return nil

	}

	if isFunction(expected) || isFunction(actual) {

		return errors.New("cannot take func type as argument")

	}

	return nil

}

// Same asserts that two pointers reference the same object.

//

//    assert.Same(t, ptr1, ptr2)

//

// Both arguments must be pointer variables. Pointer variable sameness is

// determined based on the equality of both type and value.

func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {

	if h, ok := t.(tHelper); ok {

		h.Helper()

	}

	if !samePointers(expected, actual) {

		return Fail(t, fmt.Sprintf("Not same: \n"+

			"expected: %p %#v\n"+

			"actual  : %p %#v", expected, expected, actual, actual), msgAndArgs...)

	}

	return true

}

// NotSame asserts that two pointers do not reference the same object.

//

//    assert.NotSame(t, ptr1, ptr2)

//

// Both arguments must be pointer variables. Pointer variable sameness is

// determined based on the equality of both type and value.

func NotSame(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {

	if h, ok := t.(tHelper); ok {

		h.Helper()

	}

	if samePointers(expected, actual) {

		return Fail(t, fmt.Sprintf(

			"Expected and actual point to the same object: %p %#v",

			expected, expected), msgAndArgs...)

	}

	return true

}

// samePointers compares two generic interface objects and returns whether

// they point to the same object

func samePointers(first, second interface{}) bool {

	firstPtr, secondPtr := reflect.ValueOf(first), reflect.ValueOf(second)

	if firstPtr.Kind() != reflect.Ptr || secondPtr.Kind() != reflect.Ptr {