package basic

import (
	"strings"
	"testing"
)

// TestRandom_Execute_Normal covers integer range and string generation.
func TestRandom_Execute_Normal(t *testing.T) {
	t.Parallel()
	r := random{}

	t.Run("integer in range", func(t *testing.T) {
		t.Parallel()
		for i := 0; i < 200; i++ {
			got, err := run(t, r, map[string]any{"min": 5, "max": 9})
			assertNoErr(t, err)
			v := fieldInt(t, mapResult(t, got), "value")
			if v < 5 || v > 9 {
				t.Fatalf("value %d out of range [5,9]", v)
			}
		}
	})

	t.Run("string length and charset", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, r, map[string]any{"length": 12, "charset": "ab"})
		assertNoErr(t, err)
		s := fieldString(t, mapResult(t, got), "value")
		if len([]rune(s)) != 12 {
			t.Fatalf("length = %d, want 12", len([]rune(s)))
		}
		if strings.Trim(s, "ab") != "" {
			t.Fatalf("value %q contains characters outside charset", s)
		}
	})

	t.Run("single value range", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, r, map[string]any{"min": 7, "max": 7})
		assertNoErr(t, err)
		if v := fieldInt(t, mapResult(t, got), "value"); v != 7 {
			t.Fatalf("value = %d, want 7", v)
		}
	})
}

// TestRandom_Execute_Errors covers invalid parameters.
func TestRandom_Execute_Errors(t *testing.T) {
	t.Parallel()
	r := random{}
	cases := []struct {
		name string
		args map[string]any
	}{
		{name: "no args", args: map[string]any{}},
		{name: "inverted range", args: map[string]any{"min": 10, "max": 2}},
		{name: "min not integer", args: map[string]any{"min": "x", "max": 5}},
		{name: "zero length", args: map[string]any{"length": 0}},
		{name: "negative length", args: map[string]any{"length": -1}},
		{name: "length too big", args: map[string]any{"length": maxRandomLen + 1}},
		{name: "empty charset", args: map[string]any{"length": 4, "charset": ""}},
		{name: "non-string charset", args: map[string]any{"length": 4, "charset": 9}},
	}
	for _, tc := range cases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			_, err := run(t, r, tc.args)
			assertIs(t, err, ErrInvalidArgument)
		})
	}
}

// TestRandom_Schema verifies the JSON Schema contract.
func TestRandom_Schema(t *testing.T) {
	t.Parallel()
	p, err := random{}.Parameters()
	assertNoErr(t, err)
	props := p["properties"].(map[string]any)
	for _, field := range []string{"min", "max", "length"} {
		if props[field].(map[string]any)["type"] != "integer" {
			t.Fatalf("%s type should be integer", field)
		}
	}
}