package basic

import (
	"strings"
	"testing"
)

// TestMarkdown_Execute_Normal covers table, list, heading and metadata ops.
func TestMarkdown_Execute_Normal(t *testing.T) {
	t.Parallel()
	tool := markdown{}

	t.Run("table", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{
			"operation": "table",
			"headers":   []any{"name", "score"},
			"rows":      []any{[]any{"ada", "90"}, []any{"grace", "100"}},
		})
		assertNoErr(t, err)
		want := "| name | score |\n| --- | --- |\n| ada | 90 |\n| grace | 100 |\n"
		if got := fieldString(t, mapResult(t, got), "result"); got != want {
			t.Fatalf("table = %q, want %q", got, want)
		}
	})

	t.Run("bulleted list", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "list", "items": []any{"a", "b"}})
		assertNoErr(t, err)
		if want := "- a\n- b\n"; fieldString(t, mapResult(t, got), "result") != want {
			t.Fatalf("got %q", fieldString(t, mapResult(t, got), "result"))
		}
	})

	t.Run("ordered list", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "list", "items": []any{"a", "b"}, "ordered": true})
		assertNoErr(t, err)
		if want := "1. a\n2. b\n"; fieldString(t, mapResult(t, got), "result") != want {
			t.Fatalf("got %q", fieldString(t, mapResult(t, got), "result"))
		}
	})

	t.Run("heading", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "heading", "level": 2, "text": "Title"})
		assertNoErr(t, err)
		if want := "## Title\n"; fieldString(t, mapResult(t, got), "result") != want {
			t.Fatalf("got %q", fieldString(t, mapResult(t, got), "result"))
		}
	})

	t.Run("metadata with front matter", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "metadata", "content": "---\ntitle: Hi\n---\nBody text"})
		assertNoErr(t, err)
		m := mapResult(t, got)
		meta := m["meta"].(map[string]string)
		if meta["title"] != "Hi" {
			t.Fatalf("meta = %v, want title=Hi", meta)
		}
		if got := m["body"].(string); got != "Body text" {
			t.Fatalf("body = %q, want Body text", got)
		}
	})

	t.Run("metadata without front matter", func(t *testing.T) {
		t.Parallel()
		got, err := run(t, tool, map[string]any{"operation": "metadata", "content": "just body"})
		assertNoErr(t, err)
		m := mapResult(t, got)
		if meta := m["meta"].(map[string]string); len(meta) != 0 {
			t.Fatalf("meta = %v, want empty", meta)
		}
		if got := m["body"].(string); got != "just body" {
			t.Fatalf("body = %q", got)
		}
	})
}

// TestMarkdown_Execute_Errors covers bad operation inputs.
func TestMarkdown_Execute_Errors(t *testing.T) {
	t.Parallel()
	tool := markdown{}
	cases := []struct {
		name   string
		args   map[string]any
		target error
	}{
		{name: "unknown operation", args: map[string]any{"operation": "quote"}, target: ErrUnsupported},
		{name: "table without headers", args: map[string]any{"operation": "table", "rows": []any{}}, target: ErrInvalidArgument},
		{name: "list without items", args: map[string]any{"operation": "list"}, target: ErrInvalidArgument},
		{name: "heading level too low", args: map[string]any{"operation": "heading", "level": 0, "text": "x"}, target: ErrInvalidArgument},
		{name: "heading level too high", args: map[string]any{"operation": "heading", "level": 7, "text": "x"}, target: ErrInvalidArgument},
		{name: "heading without text", args: map[string]any{"operation": "heading", "level": 1}, target: ErrInvalidArgument},
		{name: "metadata without content", args: map[string]any{"operation": "metadata"}, target: ErrInvalidArgument},
	}
	for _, tc := range cases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			_, err := run(t, tool, tc.args)
			assertIs(t, err, tc.target)
		})
	}
}

// TestMarkdown_Schema verifies required operation.
func TestMarkdown_Schema(t *testing.T) {
	t.Parallel()
	p, err := markdown{}.Parameters()
	assertNoErr(t, err)
	reqs := p["required"].([]any)
	if len(reqs) != 1 || reqs[0] != "operation" {
		t.Fatalf("required = %v, want [operation]", reqs)
	}
	if !strings.Contains(p["properties"].(map[string]any)["operation"].(map[string]any)["enum"].([]any)[0].(string), "table") {
		t.Fatalf("enum should include table")
	}
}