package basic

import (
	"reflect"
	"testing"
)

// TestJson_Execute_Normal covers parse, format, validate and stringify.
func TestJson_Execute_Normal(t *testing.T) {
	t.Parallel()
	tool := jsonTool{}

	t.Run("parse", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "parse", "value": `{"a":1,"b":[true,null,"s"]}`})
		assertNoErr(t, err)
		m := mapResult(t, got)
		obj := m["result"].(map[string]any)
		if obj["a"] != float64(1) {
			t.Fatalf("a = %v, want 1", obj["a"])
		}
		if !reflect.DeepEqual(obj["b"], []any{true, nil, "s"}) {
			t.Fatalf("b = %v, want [true nil s]", obj["b"])
		}
	})

	t.Run("string value parse", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "parse", "value": `"hi"`})
		assertNoErr(t, err)
		if fieldString(t, mapResult(t, got), "result") != "hi" {
			t.Fatalf("result should be hi")
		}
	})

	t.Run("format", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "format", "value": `{"x":1}`})
		assertNoErr(t, err)
		m := mapResult(t, got)
		if want := "{\n  \"x\": 1\n}"; fieldString(t, m, "result") != want {
			t.Fatalf("result = %q, want %q", m["result"], want)
		}
	})

	t.Run("validate valid", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "validate", "value": `{"a":[1,2]}`})
		assertNoErr(t, err)
		if !fieldBool(t, mapResult(t, got), "valid") {
			t.Fatalf("valid should be true")
		}
	})

	t.Run("validate invalid", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "validate", "value": `{broken`})
		assertNoErr(t, err)
		if fieldBool(t, mapResult(t, got), "valid") {
			t.Fatalf("valid should be false")
		}
	})

	t.Run("stringify", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "stringify", "value": map[string]any{"x": 1}})
		assertNoErr(t, err)
		m := mapResult(t, got)
		if want := "{\n  \"x\": 1\n}"; fieldString(t, m, "result") != want {
			t.Fatalf("result = %q, want %q", m["result"], want)
		}
	})
}

// TestJson_Execute_Errors covers invalid inputs and unsupported operations.
func TestJson_Execute_Errors(t *testing.T) {
	t.Parallel()
	tool := jsonTool{}
	cases := []struct {
		name   string
		args   map[string]any
		target error
	}{
		{name: "invalid parse", args: map[string]any{"operation": "parse", "value": `{bad`}, target: nil},
		{name: "parse non-string", args: map[string]any{"operation": "parse", "value": 42}, target: ErrInvalidArgument},
		{name: "invalid format", args: map[string]any{"operation": "format", "value": `{bad`}, target: nil},
		{name: "validate non-string", args: map[string]any{"operation": "validate", "value": true}, target: ErrInvalidArgument},
		{name: "unknown operation", args: map[string]any{"operation": "csv", "value": "{}"}, target: ErrUnsupported},
		{name: "missing value", args: map[string]any{"operation": "stringify"}, target: ErrInvalidArgument},
		{name: "missing operation", args: map[string]any{}, target: ErrInvalidArgument},
	}
	for _, tc := range cases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			_, err := run(t, tool, tc.args)
			if err == nil {
				t.Fatalf("want error, got nil")
			}
			if tc.target != nil {
				assertIs(t, err, tc.target)
			}
		})
	}
}

// TestJson_Schema verifies required operation.
func TestJson_Schema(t *testing.T) {
	t.Parallel()
	p, err := jsonTool{}.Parameters()
	assertNoErr(t, err)
	reqs := p["required"].([]any)
	if len(reqs) != 1 || reqs[0] != "operation" {
		t.Fatalf("required = %v, want [operation]", reqs)
	}
	if _, ok := p["properties"].(map[string]any)["value"]; !ok {
		t.Fatalf("schema should include a value property")
	}
}