package htmlform

import "testing"

func TestMultilineGroupingSeparateGroups(t *testing.T) {
	md := `Prefix [field idx="0" type="text" label="A" group="group1"] [field idx="1" type="text" label="B" group="group1"] [field idx="2" type="text" label="C" group="group1"] middle [field idx="3" type="text" label="D"] suffix [field idx="4" type="text" label="E" group="group2"] [field idx="5" type="text" label="F" group="group2"] end`

	result := Render(md, nil)

	// Group 1: idx=0 becomes textarea, idx=1 and idx=2 are skipped
	if !containsStr(result, "id=\"field_0\"") {
		t.Errorf("Group 1 first field should be present as textarea, got: %s", result)
	}
	if !containsStr(result, "<textarea") {
		t.Errorf("Group 1 first field should render as textarea, got: %s", result)
	}
	if containsStr(result, "id=\"field_1\"") {
		t.Errorf("Group 1 second field should be skipped")
	}
	if containsStr(result, "id=\"field_2\"") {
		t.Errorf("Group 1 third field should be skipped")
	}

	// Group 2: idx=4 becomes textarea, idx=5 is skipped
	if !containsStr(result, "id=\"field_3\"") {
		t.Errorf("Non-grouped field should be present")
	}
	if !containsStr(result, "id=\"field_4\"") {
		t.Errorf("Group 2 first field should be present as textarea, got: %s", result)
	}

	// Count textareas - should be exactly 2 (one per group)
	count := countStr(result, "<textarea")
	if count != 2 {
		t.Errorf("Expected 2 textareas, got %d", count)
	}
}

func TestMultilineSingleFieldGroup(t *testing.T) {
	// A group with only 1 member should NOT become multiline
	md := "[field idx=\"0\" type=\"text\" label=\"Single\" group=\"solo\"]"
	result := Render(md, nil)

	if containsStr(result, "<textarea") {
		t.Errorf("Single-field group should NOT render as textarea, got: %s", result)
	}
	if !containsStr(result, "id=\"field_0\"") {
		t.Errorf("Field should be present, got: %s", result)
	}
}

func TestCheckboxGroupRendersDataAttr(t *testing.T) {
	md := "[field idx=\"0\" type=\"button\" label=\"Yes\" group=\"grp\"] [field idx=\"1\" type=\"button\" label=\"No\" group=\"grp\"]"
	result := Render(md, nil)

	if !containsStr(result, `data-checkbox-group="grp"`) {
		t.Errorf("checkbox_group should render data-checkbox-group attr, got: %s", result)
	}
	if !containsStr(result, "id=\"field_0\"") {
		t.Errorf("Field 0 should be present")
	}
	if !containsStr(result, "id=\"field_1\"") {
		t.Errorf("Field 1 should be present")
	}
}

func TestRadioGroupRendersDataAttr(t *testing.T) {
	md := "[field idx=\"0\" type=\"radio\" label=\"Yes\" group=\"grp\"] [field idx=\"1\" type=\"radio\" label=\"No\" group=\"grp\"]"
	result := Render(md, nil)

	if !containsStr(result, `data-radio-group="grp"`) {
		t.Errorf("radio_group should render data-radio-group attr, got: %s", result)
	}
	if !containsStr(result, "id=\"field_0\"") {
		t.Errorf("Field 0 should be present")
	}
	if !containsStr(result, "id=\"field_1\"") {
		t.Errorf("Field 1 should be present")
	}
}

func TestTypeOverride(t *testing.T) {
	// A text field overridden to button should render as checkbox
	md := "[field idx=\"0\" type=\"button\" label=\"Agree\"]"
	result := Render(md, nil)

	if !containsStr(result, `type="checkbox"`) {
		t.Errorf("Button type should render as checkbox, got: %s", result)
	}
}

func TestEmailType(t *testing.T) {
	md := "[field idx=\"0\" type=\"email\" label=\"Email\"]"
	result := Render(md, nil)

	if !containsStr(result, `type="email"`) {
		t.Errorf("Email type should render as email input, got: %s", result)
	}
}

func TestLabelFromShortcode(t *testing.T) {
	md := "[field idx=\"0\" type=\"text\" label=\"My Label\"]"
	result := Render(md, nil)

	if !containsStr(result, "My Label") {
		t.Errorf("Label from shortcode should appear, got: %s", result)
	}
}

func TestNoLabelWhenNotSpecified(t *testing.T) {
	md := "[field idx=\"0\" type=\"text\"]"
	result := Render(md, nil)

	if containsStr(result, "<label") {
		t.Errorf("No label element should be rendered when label not specified, got: %s", result)
	}
	if !containsStr(result, "id=\"field_0\"") {
		t.Errorf("Field should still be present, got: %s", result)
	}
}

func TestDefaultTypeFromPDF(t *testing.T) {
	// Legacy marker with no explicit type should use default from PDF
	md := "Name: [F0] Agree: [F1]"
	defaultTypes := DefaultFieldTypes{
		0: "text",
		1: "button",
	}
	result := Render(md, defaultTypes)

	if !containsStr(result, `type="text"`) {
		t.Errorf("Field 0 should use default text type, got: %s", result)
	}
	if !containsStr(result, `type="checkbox"`) {
		t.Errorf("Field 1 should use default button type (rendered as checkbox), got: %s", result)
	}
}

func TestShortcodeTypeOverridesDefault(t *testing.T) {
	// Explicit shortcode type should override PDF default
	md := "[field idx=\"0\" type=\"email\" label=\"Email\"]"
	defaultTypes := DefaultFieldTypes{
		0: "button", // PDF says button, but shortcode says email
	}
	result := Render(md, defaultTypes)

	if !containsStr(result, `type="email"`) {
		t.Errorf("Shortcode type should override default, got: %s", result)
	}
	if containsStr(result, `type="checkbox"`) {
		t.Errorf("Should not have checkbox from PDF default, got: %s", result)
	}
}

func TestDefaultFallsBackToText(t *testing.T) {
	// When no default is available, fall back to text
	md := "[F0]"
	result := Render(md, nil)

	if !containsStr(result, `type="text"`) {
		t.Errorf("Should fall back to text type, got: %s", result)
	}
}

func TestLegacyMarkers(t *testing.T) {
	// Legacy [FN] markers should still work as shorthand for text fields
	md := "Name: [F0] Age: [F1]"
	result := Render(md, nil)

	if !containsStr(result, "id=\"field_0\"") {
		t.Errorf("Legacy F0 should render, got: %s", result)
	}
	if !containsStr(result, "id=\"field_1\"") {
		t.Errorf("Legacy F1 should render, got: %s", result)
	}
	// Legacy markers have no label, so no <label> element
	if containsStr(result, "<label") {
		t.Errorf("Legacy markers should not produce labels, got: %s", result)
	}
}

func containsStr(haystack, needle string) bool {
	return len(haystack) > 0 && len(needle) > 0 && len(haystack) >= len(needle) &&
		findStr(haystack, needle) >= 0
}

func findStr(haystack, needle string) int {
	for i := 0; i <= len(haystack)-len(needle); i++ {
		if haystack[i:i+len(needle)] == needle {
			return i
		}
	}
	return -1
}

func countStr(haystack, needle string) int {
	count := 0
	start := 0
	for {
		idx := findStr(haystack[start:], needle)
		if idx < 0 {
			break
		}
		count++
		start += idx + len(needle)
	}
	return count
}