package xpath

import (
	"strings"
	"testing"

	"github.com/antchfx/xmlquery"
)

// Parse test XML data once at the beginning for use in multiple tests
func parseTestXML(t *testing.T, xmlData string) *xmlquery.Node {
	doc, err := xmlquery.Parse(strings.NewReader(xmlData))
	if err != nil {
		t.Fatalf("Failed to parse test XML: %v", err)
	}
	return doc
}

// XML test data as a string for our tests
var testXML = `
<store>
  <book category="fiction">
    <title lang="en">The Fellowship of the Ring</title>
    <author>J.R.R. Tolkien</author>
    <year>1954</year>
    <price>22.99</price>
  </book>
  <book category="fiction">
    <title lang="en">The Two Towers</title>
    <author>J.R.R. Tolkien</author>
    <year>1954</year>
    <price>23.45</price>
  </book>
  <book category="technical">
    <title lang="en">Learning XML</title>
    <author>Erik T. Ray</author>
    <year>2003</year>
    <price>39.95</price>
  </book>
  <bicycle>
    <color>red</color>
    <price>199.95</price>
  </bicycle>
</store>
`

func TestEvaluator(t *testing.T) {
	// Parse the test XML data once for all test cases
	doc := parseTestXML(t, testXML)

	tests := []struct {
		name  string
		path  string
		error bool
	}{
		{
			name: "simple_element_access",
			path: "/store/bicycle/color",
		},
		{
			name: "recursive_element_access",
			path: "//price",
		},
		{
			name: "wildcard_element_access",
			path: "/store/book/*",
		},
		{
			name: "attribute_exists_predicate",
			path: "//title[@lang]",
		},
		{
			name: "attribute_equals_predicate",
			path: "//title[@lang='en']",
		},
		{
			name:  "value_comparison_predicate",
			path:  "/store/book[price>35.00]/title",
			error: true,
		},
		{
			name:  "last_predicate",
			path:  "/store/book[last()]/title",
			error: true,
		},
		{
			name:  "last_minus_predicate",
			path:  "/store/book[last()-1]/title",
			error: true,
		},
		{
			name:  "position_predicate",
			path:  "/store/book[position()<3]/title",
			error: true,
		},
		{
			name:  "invalid_index",
			path:  "/store/book[10]/title",
			error: true,
		},
		{
			name: "nonexistent_element",
			path: "/store/nonexistent",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, err := Get(doc, tt.path)

			// Handle expected errors
			if tt.error {
				if err == nil && len(result) == 0 {
					// If we expected an error but got empty results instead, that's okay
					return
				}
				if err != nil {
					// If we got an error as expected, that's okay
					return
				}
			} else if err != nil {
				// If we didn't expect an error but got one, that's a test failure
				t.Errorf("Get(%q) returned unexpected error: %v", tt.path, err)
				return
			}

			// Special cases where we don't care about exact matches
			switch tt.name {
			case "wildcard_element_access":
				// Just check that we got some elements
				if len(result) == 0 {
					t.Errorf("Expected multiple elements for wildcard, got none")
				}
				return
			case "attribute_exists_predicate", "attribute_equals_predicate":
				// Just check that we got some titles
				if len(result) == 0 {
					t.Errorf("Expected titles with lang attribute, got none")
				}
				// Ensure all are title elements
				for _, node := range result {
					if node.Data != "title" {
						t.Errorf("Expected title elements, got: %s", node.Data)
					}
				}
				return
			case "nonexistent_element":
				// Just check that we got empty results
				if len(result) != 0 {
					t.Errorf("Expected empty results for nonexistent element, got %d items", len(result))
				}
				return
			}

			// For other cases, just verify we got results
			if len(result) == 0 {
				t.Errorf("Expected results for path %s, got none", tt.path)
			}
		})
	}
}

func TestEdgeCases(t *testing.T) {
	t.Run("nil_node", func(t *testing.T) {
		result, err := Get(nil, "/store/book")
		if err == nil {
			t.Errorf("Expected error for nil node")
			return
		}
		if len(result) > 0 {
			t.Errorf("Expected empty result, got %v", result)
		}
	})

	t.Run("invalid_xml", func(t *testing.T) {
		invalidXML, err := xmlquery.Parse(strings.NewReader("<invalid>xml"))
		if err != nil {
			// If parsing fails, that's expected
			return
		}

		_, err = Get(invalidXML, "/store")
		if err == nil {
			t.Error("Expected error for invalid XML structure")
		}
	})

	// For these tests with the simple XML, we expect just one result
	simpleXML := `<root><book><title lang="en">Test</title></book></root>`
	doc := parseTestXML(t, simpleXML)

	t.Run("current_node", func(t *testing.T) {
		result, err := Get(doc, "/root/book/.")
		if err != nil {
			t.Errorf("Get() returned error: %v", err)
			return
		}
		if len(result) > 1 {
			t.Errorf("Expected at most 1 result, got %d", len(result))
		}
		if len(result) > 0 {
			// Verify it's the book node
			if result[0].Data != "book" {
				t.Errorf("Expected book node, got %v", result[0].Data)
			}
		}
	})

	t.Run("attributes", func(t *testing.T) {
		result, err := Get(doc, "/root/book/title/@lang")
		if err != nil {
			t.Errorf("Get() returned error: %v", err)
			return
		}
		if len(result) != 1 || result[0].InnerText() != "en" {
			t.Errorf("Expected 'en', got %v", result[0].InnerText())
		}
	})
}

func TestGetWithPaths(t *testing.T) {
	// Use a simplified, well-formed XML document
	simpleXML := `<store>
  <book category="fiction">
    <title lang="en">The Book Title</title>
    <author>Author Name</author>
    <price>19.99</price>
  </book>
  <bicycle>
    <color>red</color>
    <price>199.95</price>
  </bicycle>
</store>`

	// Parse the XML for testing
	doc := parseTestXML(t, simpleXML)

	// Debug: Print the test XML
	t.Logf("Test XML:\n%s", simpleXML)

	tests := []struct {
		name          string
		path          string
		expectedValue string
	}{
		{
			name:          "simple_element_access",
			path:          "/store/bicycle/color",
			expectedValue: "red",
		},
		{
			name:          "attribute_access",
			path:          "/store/book/title/@lang",
			expectedValue: "en",
		},
		{
			name:          "recursive_with_attribute",
			path:          "//title[@lang='en']",
			expectedValue: "The Book Title",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Debug: Print the path we're looking for
			t.Logf("Looking for path: %s", tt.path)

			result, err := Get(doc, tt.path)
			if err != nil {
				t.Errorf("Get(%q) returned error: %v", tt.path, err)
				return
			}

			// Debug: Print the results
			t.Logf("Got %d results", len(result))
			for i, r := range result {
				t.Logf("Result %d: Node=%s, Value=%v", i, r.Data, r.InnerText())
			}

			// Check that we got results
			if len(result) == 0 {
				t.Errorf("Get(%q) returned no results", tt.path)
				return
			}

			// For attribute access test, do more specific checks
			if tt.name == "attribute_access" {
				// Check the first result's value matches expected
				if result[0].InnerText() != tt.expectedValue {
					t.Errorf("Attribute value: got %v, expected %s", result[0].InnerText(), tt.expectedValue)
				}
			}

			// For simple element access, check the text content
			if tt.name == "simple_element_access" {
				if text := result[0].InnerText(); text != tt.expectedValue {
					t.Errorf("Element text: got %s, expected %s", text, tt.expectedValue)
				}
			}

			// For recursive with attribute test, check title elements with lang="en"
			if tt.name == "recursive_with_attribute" {
				for _, node := range result {
					// Check the node is a title
					if node.Data != "title" {
						t.Errorf("Expected title element, got %s", node.Data)
					}

					// Check text content
					if text := node.InnerText(); text != tt.expectedValue {
						t.Errorf("Text content: got %s, expected %s", text, tt.expectedValue)
					}

					// Check attributes - find the lang attribute
					hasLang := false
					for _, attr := range node.Attr {
						if attr.Name.Local == "lang" && attr.Value == "en" {
							hasLang = true
							break
						}
					}
					if !hasLang {
						t.Errorf("Expected lang=\"en\" attribute, but it was not found")
					}
				}
			}
		})
	}
}

func TestSet(t *testing.T) {
	t.Run("simple element", func(t *testing.T) {
		xmlData := `<root><name>John</name></root>`
		doc := parseTestXML(t, xmlData)

		err := Set(doc, "/root/name", "Jane")
		if err != nil {
			t.Errorf("Set() returned error: %v", err)
			return
		}

		// Verify the change
		result, err := Get(doc, "/root/name")
		if err != nil {
			t.Errorf("Get() returned error: %v", err)
			return
		}
		if len(result) != 1 {
			t.Errorf("Expected 1 result, got %d", len(result))
			return
		}

		// Check text content
		if text := result[0].InnerText(); text != "Jane" {
			t.Errorf("Expected text 'Jane', got '%s'", text)
		}
	})

	t.Run("attribute", func(t *testing.T) {
		xmlData := `<root><element id="123"></element></root>`
		doc := parseTestXML(t, xmlData)

		err := Set(doc, "/root/element/@id", "456")
		if err != nil {
			t.Errorf("Set() returned error: %v", err)
			return
		}

		// Verify the change
		result, err := Get(doc, "/root/element/@id")
		if err != nil {
			t.Errorf("Get() returned error: %v", err)
			return
		}
		if len(result) != 1 {
			t.Errorf("Expected 1 result, got %d", len(result))
			return
		}

		// For attributes, check the inner text
		if text := result[0].InnerText(); text != "456" {
			t.Errorf("Expected attribute value '456', got '%s'", text)
		}
	})

	t.Run("indexed element", func(t *testing.T) {
		xmlData := `<root><items><item>first</item><item>second</item></items></root>`
		doc := parseTestXML(t, xmlData)

		err := Set(doc, "/root/items/item[1]", "changed")
		if err != nil {
			t.Errorf("Set() returned error: %v", err)
			return
		}

		// Verify the change using XPath that specifically targets the first item
		result, err := Get(doc, "/root/items/item[1]")
		if err != nil {
			t.Errorf("Get() returned error: %v", err)
			return
		}

		// Check if we have results
		if len(result) == 0 {
			t.Errorf("Expected at least one result for /root/items/item[1]")
			return
		}

		// Check text content
		if text := result[0].InnerText(); text != "changed" {
			t.Errorf("Expected text 'changed', got '%s'", text)
		}
	})
}

func TestSetAll(t *testing.T) {
	t.Run("multiple elements", func(t *testing.T) {
		xmlData := `<root><items><item>first</item><item>second</item></items></root>`
		doc := parseTestXML(t, xmlData)

		err := SetAll(doc, "//item", "changed")
		if err != nil {
			t.Errorf("SetAll() returned error: %v", err)
			return
		}

		// Verify all items are changed
		result, err := Get(doc, "//item")
		if err != nil {
			t.Errorf("Get() returned error: %v", err)
			return
		}
		if len(result) != 2 {
			t.Errorf("Expected 2 results, got %d", len(result))
			return
		}

		// Check each node
		for i, node := range result {
			if text := node.InnerText(); text != "changed" {
				t.Errorf("Item %d: expected text 'changed', got '%s'", i, text)
			}
		}
	})

	t.Run("attributes", func(t *testing.T) {
		xmlData := `<root><item id="1"/><item id="2"/></root>`
		doc := parseTestXML(t, xmlData)

		err := SetAll(doc, "//item/@id", "new")
		if err != nil {
			t.Errorf("SetAll() returned error: %v", err)
			return
		}

		// Verify all attributes are changed
		result, err := Get(doc, "//item/@id")
		if err != nil {
			t.Errorf("Get() returned error: %v", err)
			return
		}
		if len(result) != 2 {
			t.Errorf("Expected 2 results, got %d", len(result))
			return
		}

		// For attributes, check inner text
		for i, node := range result {
			if text := node.InnerText(); text != "new" {
				t.Errorf("Attribute %d: expected value 'new', got '%s'", i, text)
			}
		}
	})
}