package gigaparsec_test

import (
	"bytes"
	"errors"
	"testing"

	"git.codemonkeysoftware.net/b/gigaparsec"
	"git.codemonkeysoftware.net/b/gigaparsec/cursor"
	ptest "git.codemonkeysoftware.net/b/gigaparsec/test"
	"github.com/shoenig/test"
	"github.com/shoenig/test/must"
	"pgregory.net/rapid"
)

func Todo(t *testing.T) {
	t.Errorf("TODO")
}

func not[T any](pred func(T) bool) func(T) bool {
	return func(x T) bool { return !pred(x) }
}

func hasPrefix(prefix []byte) func([]byte) bool {
	return func(b []byte) bool { return bytes.HasPrefix(b, prefix) }
}

func TestSlice(t *testing.T) {
	assertParseFails := func(t rapid.TB, input []byte, p gigaparsec.Parser[byte, []byte]) {
		t.Helper()
		start := gigaparsec.MakeState(cursor.NewSlice(input))
		result, err := p(start)
		must.NoError(t, err)
		failed, consumed, _ := result.Failed()
		test.True(t, failed)
		test.False(t, consumed)
		if t.Failed() {
			t.FailNow()
		}
	}

	t.Run("fails with wrong contents", rapid.MakeCheck(func(t *rapid.T) {
		s := rapid.SliceOfN(rapid.Byte(), 1, -1).Draw(t, "s")
		input := rapid.SliceOfN(rapid.Byte(), len(s), -1).
			Filter(not(hasPrefix(s))).Draw(t, "input")
		assertParseFails(t, input, gigaparsec.Slice(s))
	}))
	t.Run("fails at end of input", rapid.MakeCheck(func(t *rapid.T) {
		s := rapid.SliceOfN(rapid.Byte(), 1, -1).Draw(t, "s")
		inputLen := rapid.IntRange(0, len(s)-1).Draw(t, "inputLen")
		input := s[:inputLen]
		assertParseFails(t, input, gigaparsec.Slice(s))
	}))
	t.Run("fails when read fails", rapid.MakeCheck(func(t *rapid.T) {
		expectedErr := rapid.Map(rapid.StringN(0, 100, -1), errors.New).Draw(t, "err")
		c := ptest.ErrCursor[byte](expectedErr)
		s := rapid.SliceOfN(rapid.Byte(), 0, 100).Draw(t, "s")
		result, err := gigaparsec.Slice(s)(gigaparsec.MakeState(c))
		failed, _, _ := result.Failed()
		test.ErrorIs(t, err, expectedErr)
		test.True(t, failed)
	}))
	t.Run("succeeds when contents match", rapid.MakeCheck(func(t *rapid.T) {
		input := rapid.SliceOfN(rapid.Byte(), 1, -1).Draw(t, "input")
		sLen := rapid.IntRange(0, len(input)).Draw(t, "sLen")
		s := input[:sLen]
		start := gigaparsec.MakeState(cursor.NewSlice(input))

		result, err := gigaparsec.Slice(s)(start)
		must.NoError(t, err)
		succeeded, consumed, value, next, _ := result.Succeeded()
		test.True(t, succeeded)
		test.True(t, consumed)
		test.SliceEqOp(t, s, value)
		test.EqOp(t, uint64(len(s)), next.Pos())
	}))
}

func TestChoose(t *testing.T) {
	Todo(t)
}

func TestBind(t *testing.T) {
	Todo(t)
}

func TestReturn(t *testing.T) {
	Todo(t)
}

func TestMap(t *testing.T) {
	Todo(t)
}

func TestSatisfy(t *testing.T) {
	Todo(t)
}

func Try(t *testing.T) {
	Todo(t)
}

func TestLabel(t *testing.T) {
	Todo(t)
}

func TestEnd(t *testing.T) {
	Todo(t)
}