package pds

import (
	"os"
	"testing"
	"testing/internal/testdeps"
)



type opType uint8
const (
	opType_NewVectorEmpty opType = iota
	opType_NewVector
	opType_NewVectorOfEmpty
	opType_NewVectorOf
	opType_Len
	opType_Get
	opType_Set
	opType_Append
	opType_Prepend
	opType_Slice
)

var (
	opTable = []opType{
		opType_NewVectorEmpty,
		opType_NewVector,
		opType_NewVectorOfEmpty,
		opType_NewVectorOf,
		opType_Len,
		opType_Get,
		opType_Set,
		opType_Append,
		opType_Prepend,
		opType_Slice,
	}
)



func asOp(n uint8) opType {
	idx := n % uint8(len(opTable))
	return opTable[idx]
}

func fn(f *testing.F) {
	f.Fuzz(func(
		t *testing.T,
		operations []uint8,
		i int,
		j int,
		a1 byte,
		a2 []byte,
	) {
		builtin    := []byte{}
		persistent := NewVector[byte]()
		for _, operation := range operations {
			switch asOp(operation) {
				case opType_NewVectorEmpty:
					builtin    = []byte{}
					persistent = NewVector[byte]()
				case opType_NewVector:
					builtin    = []byte{}
					builtin    = append(builtin, a2...)
					persistent = NewVector(a2...)
				case opType_NewVectorOfEmpty:
					builtin    = []byte{}
					persistent = NewVectorOf([]byte{})
				case opType_NewVectorOf:
					builtin    = []byte{}
					builtin    = append(builtin, a2...)
					persistent = NewVectorOf(a2)
				case opType_Len:
					if len(builtin) != persistent.Len() {
						t.Errorf(
							"bad length: %v != %v",
							len(builtin),
							persistent.Len(),
						)
					}
				case opType_Get:
					if i >= len(builtin) || i < 0 {
						break
					}
					lhs := builtin[i]
					rhs := persistent.Get(i)
					if lhs != rhs {
						t.Errorf(
							"bad Get: %v != %v",
							lhs,
							rhs,
						)
					}
				case opType_Set:
					if i >= len(builtin) || i < 0 {
						break
					}
					builtin[i] = a1
					persistent = persistent.Set(i, a1)
				case opType_Append:
					builtin    = append(builtin, a1)
					persistent = persistent.Append(a1)
				case opType_Prepend:
					pre := []byte{a1}
					builtin    = append(pre, builtin...)
					persistent = persistent.Prepend(a1)
				case opType_Slice:
					if i > j {
						break
					}
					if i >= len(builtin) || i < 0 {
						break
					}
					if j >= len(builtin) || j < 0 {
						break
					}
					builtin    = builtin[i:j]
					persistent = persistent.Slice(i, j)
				default:
					panic("bad op")
			}
		}
	})
}



func MainTest() {
	fuzzTargets := []testing.InternalFuzzTarget{
		{ "vector model", fn },
	}

	deps := testdeps.TestDeps{}
	tests      := []testing.InternalTest     {}
	benchmarks := []testing.InternalBenchmark{}
	examples   := []testing.InternalExample  {}
	m := testing.MainStart(deps, tests, benchmarks, fuzzTargets, examples)
	os.Exit(m.Run())
}