package dataext

import (
	"reflect"
	"testing"
)

func TestSingle(t *testing.T) {
	s := NewSingle[int](7)
	if s.V1 != 7 {
		t.Fatalf("V1=%d", s.V1)
	}
	if s.TupleLength() != 1 {
		t.Fatalf("len=%d", s.TupleLength())
	}
	if !reflect.DeepEqual(s.TupleValues(), []any{7}) {
		t.Fatalf("values=%v", s.TupleValues())
	}
	if NewTuple1[int](7).V1 != 7 {
		t.Fatal("NewTuple1 mismatch")
	}
}

func TestTuple(t *testing.T) {
	tp := NewTuple[int, string](1, "two")
	if tp.V1 != 1 || tp.V2 != "two" {
		t.Fatal("values wrong")
	}
	if tp.TupleLength() != 2 {
		t.Fatal("len wrong")
	}
	if !reflect.DeepEqual(tp.TupleValues(), []any{1, "two"}) {
		t.Fatalf("values=%v", tp.TupleValues())
	}
	if NewTuple2[int, string](1, "two") != tp {
		t.Fatal("NewTuple2 mismatch")
	}
}

func TestTriple(t *testing.T) {
	tr := NewTriple[int, string, bool](1, "x", true)
	if tr.TupleLength() != 3 {
		t.Fatal("len wrong")
	}
	if !reflect.DeepEqual(tr.TupleValues(), []any{1, "x", true}) {
		t.Fatalf("values=%v", tr.TupleValues())
	}
	if NewTuple3[int, string, bool](1, "x", true) != tr {
		t.Fatal("NewTuple3 mismatch")
	}
}

func TestQuadruple(t *testing.T) {
	q := NewQuadruple[int, int, int, int](1, 2, 3, 4)
	if q.TupleLength() != 4 {
		t.Fatal("len wrong")
	}
	if !reflect.DeepEqual(q.TupleValues(), []any{1, 2, 3, 4}) {
		t.Fatalf("values=%v", q.TupleValues())
	}
	if NewTuple4[int, int, int, int](1, 2, 3, 4) != q {
		t.Fatal("NewTuple4 mismatch")
	}
}

func TestQuintuple(t *testing.T) {
	q := NewQuintuple[int, int, int, int, int](1, 2, 3, 4, 5)
	if q.TupleLength() != 5 {
		t.Fatal("len wrong")
	}
	if !reflect.DeepEqual(q.TupleValues(), []any{1, 2, 3, 4, 5}) {
		t.Fatalf("values=%v", q.TupleValues())
	}
	if NewTuple5[int, int, int, int, int](1, 2, 3, 4, 5) != q {
		t.Fatal("NewTuple5 mismatch")
	}
}

func TestSextuple(t *testing.T) {
	s := NewSextuple[int, int, int, int, int, int](1, 2, 3, 4, 5, 6)
	if s.TupleLength() != 6 {
		t.Fatal("len wrong")
	}
	if !reflect.DeepEqual(s.TupleValues(), []any{1, 2, 3, 4, 5, 6}) {
		t.Fatalf("values=%v", s.TupleValues())
	}
	if NewTuple6[int, int, int, int, int, int](1, 2, 3, 4, 5, 6) != s {
		t.Fatal("NewTuple6 mismatch")
	}
}

func TestSeptuple(t *testing.T) {
	s := NewSeptuple[int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7)
	if s.TupleLength() != 7 {
		t.Fatal("len wrong")
	}
	if !reflect.DeepEqual(s.TupleValues(), []any{1, 2, 3, 4, 5, 6, 7}) {
		t.Fatalf("values=%v", s.TupleValues())
	}
	if NewTuple7[int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7) != s {
		t.Fatal("NewTuple7 mismatch")
	}
}

func TestOctuple(t *testing.T) {
	o := NewOctuple[int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8)
	if o.TupleLength() != 8 {
		t.Fatal("len wrong")
	}
	if !reflect.DeepEqual(o.TupleValues(), []any{1, 2, 3, 4, 5, 6, 7, 8}) {
		t.Fatalf("values=%v", o.TupleValues())
	}
	if NewTuple8[int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8) != o {
		t.Fatal("NewTuple8 mismatch")
	}
}

func TestNonuple(t *testing.T) {
	n := NewNonuple[int, int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8, 9)
	if n.TupleLength() != 9 {
		t.Fatal("len wrong")
	}
	if !reflect.DeepEqual(n.TupleValues(), []any{1, 2, 3, 4, 5, 6, 7, 8, 9}) {
		t.Fatalf("values=%v", n.TupleValues())
	}
	if NewTuple9[int, int, int, int, int, int, int, int, int](1, 2, 3, 4, 5, 6, 7, 8, 9) != n {
		t.Fatal("NewTuple9 mismatch")
	}
}

func TestValueGroupInterface(t *testing.T) {
	var vg ValueGroup = NewTuple[int, string](1, "a")
	if vg.TupleLength() != 2 {
		t.Fatal("interface length wrong")
	}
}