package tst

import (
	"testing"
)

// These tests exercise the success-paths of each assertion: i.e. the cases
// where the assertion should NOT mark the test as failed. They verify the
// boolean/conditional logic of each function. We avoid testing the failure
// branches because the assertions take a concrete *testing.T (not an
// interface), so substituting a mock would require unsafe/reflection tricks
// that are brittle and cascade failures to the parent test.

// --- AssertEqual ----------------------------------------------------------

func TestAssertEqual_Int(t *testing.T) {
	AssertEqual(t, 42, 42)
	AssertEqual(t, -1, -1)
	AssertEqual(t, 0, 0)
}

func TestAssertEqual_String(t *testing.T) {
	AssertEqual(t, "hello", "hello")
	AssertEqual(t, "", "")
}

func TestAssertEqual_Bool(t *testing.T) {
	AssertEqual(t, true, true)
	AssertEqual(t, false, false)
}

func TestAssertEqual_Float(t *testing.T) {
	AssertEqual(t, 3.14, 3.14)
}

// --- AssertArrayEqual -----------------------------------------------------

func TestAssertArrayEqual_Empty(t *testing.T) {
	AssertArrayEqual(t, []int{}, []int{})
}

func TestAssertArrayEqual_Equal(t *testing.T) {
	AssertArrayEqual(t, []int{1, 2, 3}, []int{1, 2, 3})
	AssertArrayEqual(t, []string{"a", "b"}, []string{"a", "b"})
}

func TestAssertArrayEqual_SingleElement(t *testing.T) {
	AssertArrayEqual(t, []int{7}, []int{7})
}

// --- AssertNotEqual -------------------------------------------------------

func TestAssertNotEqual_Int(t *testing.T) {
	AssertNotEqual(t, 1, 2)
	AssertNotEqual(t, 0, -1)
}

func TestAssertNotEqual_String(t *testing.T) {
	AssertNotEqual(t, "foo", "bar")
	AssertNotEqual(t, "", "x")
}

func TestAssertNotEqual_Bool(t *testing.T) {
	AssertNotEqual(t, true, false)
}

// --- AssertDeepEqual ------------------------------------------------------

func TestAssertDeepEqual_Struct(t *testing.T) {
	type s struct {
		A int
		B string
	}
	AssertDeepEqual(t, s{A: 1, B: "x"}, s{A: 1, B: "x"})
}

func TestAssertDeepEqual_Slice(t *testing.T) {
	AssertDeepEqual(t, []int{1, 2, 3}, []int{1, 2, 3})
}

func TestAssertDeepEqual_Map(t *testing.T) {
	AssertDeepEqual(t, map[string]int{"a": 1, "b": 2}, map[string]int{"a": 1, "b": 2})
}

func TestAssertDeepEqual_NilSlice(t *testing.T) {
	var a, b []int
	AssertDeepEqual(t, a, b)
}

func TestAssertDeepEqual_NestedStruct(t *testing.T) {
	type inner struct{ X int }
	type outer struct {
		I inner
		S []string
	}
	a := outer{I: inner{X: 1}, S: []string{"a", "b"}}
	b := outer{I: inner{X: 1}, S: []string{"a", "b"}}
	AssertDeepEqual(t, a, b)
}

// --- AssertSetDeepEqual ---------------------------------------------------

func TestAssertSetDeepEqual_Empty(t *testing.T) {
	AssertSetDeepEqual(t, []int{}, []int{})
}

func TestAssertSetDeepEqual_SameOrder(t *testing.T) {
	AssertSetDeepEqual(t, []int{1, 2, 3}, []int{1, 2, 3})
}

func TestAssertSetDeepEqual_DifferentOrder(t *testing.T) {
	AssertSetDeepEqual(t, []int{3, 1, 2}, []int{1, 2, 3})
}

func TestAssertSetDeepEqual_Strings(t *testing.T) {
	AssertSetDeepEqual(t, []string{"b", "a", "c"}, []string{"a", "b", "c"})
}

func TestAssertSetDeepEqual_Structs(t *testing.T) {
	type s struct{ V int }
	AssertSetDeepEqual(t, []s{{V: 2}, {V: 1}}, []s{{V: 1}, {V: 2}})
}

// --- AssertNotDeepEqual ---------------------------------------------------

func TestAssertNotDeepEqual_Struct(t *testing.T) {
	type s struct {
		A int
	}
	AssertNotDeepEqual(t, s{A: 1}, s{A: 2})
}

func TestAssertNotDeepEqual_Slice(t *testing.T) {
	AssertNotDeepEqual(t, []int{1, 2}, []int{1, 2, 3})
}

func TestAssertNotDeepEqual_Map(t *testing.T) {
	AssertNotDeepEqual(t, map[string]int{"a": 1}, map[string]int{"b": 1})
}

// --- AssertDeRefEqual -----------------------------------------------------

func TestAssertDeRefEqual_Int(t *testing.T) {
	v := 42
	AssertDeRefEqual(t, &v, 42)
}

func TestAssertDeRefEqual_String(t *testing.T) {
	v := "hello"
	AssertDeRefEqual(t, &v, "hello")
}

func TestAssertDeRefEqual_Bool(t *testing.T) {
	v := true
	AssertDeRefEqual(t, &v, true)
}

// --- AssertPtrEqual -------------------------------------------------------

func TestAssertPtrEqual_BothNil(t *testing.T) {
	var a, b *int
	AssertPtrEqual(t, a, b)
}

func TestAssertPtrEqual_SameValue(t *testing.T) {
	a, b := 5, 5
	AssertPtrEqual(t, &a, &b)
}

func TestAssertPtrEqual_DifferentPointersSameValue(t *testing.T) {
	a, b := "hi", "hi"
	AssertPtrEqual(t, &a, &b)
}

func TestAssertPtrEqual_SamePointer(t *testing.T) {
	a := 99
	AssertPtrEqual(t, &a, &a)
}

// --- AssertHexEqual -------------------------------------------------------

func TestAssertHexEqual_Empty(t *testing.T) {
	AssertHexEqual(t, "", []byte{})
}

func TestAssertHexEqual_Bytes(t *testing.T) {
	AssertHexEqual(t, "deadbeef", []byte{0xde, 0xad, 0xbe, 0xef})
}

func TestAssertHexEqual_SingleByte(t *testing.T) {
	AssertHexEqual(t, "ff", []byte{0xff})
}

func TestAssertHexEqual_AllZero(t *testing.T) {
	AssertHexEqual(t, "0000", []byte{0x00, 0x00})
}

// --- AssertTrue / AssertFalse ---------------------------------------------

func TestAssertTrue(t *testing.T) {
	AssertTrue(t, true)
}

func TestAssertFalse(t *testing.T) {
	AssertFalse(t, false)
}

// --- AssertNoErr ----------------------------------------------------------

func TestAssertNoErr_Nil(t *testing.T) {
	AssertNoErr(t, nil)
}

// --- AssertStrRepEqual ----------------------------------------------------

func TestAssertStrRepEqual_Same(t *testing.T) {
	AssertStrRepEqual(t, 42, 42)
	AssertStrRepEqual(t, "abc", "abc")
}

func TestAssertStrRepEqual_DifferentTypesSameRep(t *testing.T) {
	// 42 and "42" both stringify to "42" via %v
	AssertStrRepEqual(t, 42, "42")
}

func TestAssertStrRepEqual_Bool(t *testing.T) {
	AssertStrRepEqual(t, true, true)
}

// --- AssertStrRepNotEqual -------------------------------------------------

func TestAssertStrRepNotEqual_Different(t *testing.T) {
	AssertStrRepNotEqual(t, 42, 43)
	AssertStrRepNotEqual(t, "abc", "xyz")
}

func TestAssertStrRepNotEqual_BoolVsInt(t *testing.T) {
	// "true" != "1"
	AssertStrRepNotEqual(t, true, 1)
}