package main

import (
	"encoding/xml"
	"fmt"
	"strings"
)

// Define a struct to hold our XML data without explicit namespace handling first
// This often leads to omissions when namespaces are present.
type BookNoNamespace struct {
	Title  string `xml:"title"`
	Author string `xml:"author"`
	Year   int    `xml:"year"`
}

// Define a struct that attempts to capture a namespace-prefixed element
// This will demonstrate the 'pitfall' of not correctly specifying the namespace URI.
type BookPrefixedNoURI struct {
	Title  string `xml:"book:title"` // Incorrect: 'book' is just a prefix, not the actual URI
	Author string `xml:"author"`
	Year   int    `xml:"year"`
}

// Correct struct for handling the 'book' namespace explicitly
// using the 'namespace localname' syntax.
type BookWithNamespace struct {
	XMLName xml.Name `xml:"http://www.example.com/books book"` // Captures the root element with its namespace
	Title   string   `xml:"http://www.example.com/books title"`
	Author  string   `xml:"author"` // Assuming author is in no namespace or default (inherited)
	Year    int      `xml:"http://www.example.com/books year"`
}

func main() {
	// Sample XML data with a default namespace and a prefixed element
	// The default namespace applies to 'book', 'title', 'year'.
	// 'Author' is implicitly in the default namespace here.
	// 'Editor' is explicitly in a different namespace.
	xmlData := `
		<book xmlns="http://www.example.com/books" xmlns:editor="http://www.example.com/editors">
			<title>Go XML Mastery</title>
			<author>Gopher Author</author>
			<year>2023</year>
			<editor:name>Editor Expert</editor:name>
		</book>`

	fmt.Println("\n--- Attempting Unmarshal without Namespace Awareness ---")
	var bookNoNS BookNoNamespace
	// Unmarshal without considering namespaces often leads to missing data
	err := xml.Unmarshal([]byte(xmlData), &bookNoNS)
	if err != nil {
		fmt.Printf("Error unmarshalling BookNoNamespace: %v\n", err)
	} else {
		fmt.Printf("BookNoNamespace: %+v (Note missing data)\n", bookNoNS)
	}

	fmt.Println("\n--- Attempting Unmarshal with Incorrect Prefix in Tag ---")
	var bookPrefixedNoURI BookPrefixedNoURI
	// This will also fail because 'book:title' in the tag implies a literal prefix match,
	// not resolution against the actual namespace URI.
	err = xml.Unmarshal([]byte(xmlData), &bookPrefixedNoURI)
	if err != nil {
		fmt.Printf("Error unmarshalling BookPrefixedNoURI: %v\n", err)
	} else {
		fmt.Printf("BookPrefixedNoURI: %+v (Still missing data)\n", bookPrefixedNoURI)
	}

	fmt.Println("\n--- Correct Unmarshal with Full Namespace Awareness ---")
	var bookWithNS BookWithNamespace
	err = xml.Unmarshal([]byte(xmlData), &bookWithNS)
	if err != nil {
		fmt.Printf("Error unmarshalling BookWithNamespace: %v\n", err)
	} else {
		fmt.Printf("BookWithNamespace: %+v\n", bookWithNS)
	}

	// Demonstrate unmarshalling an element from a different, prefixed namespace (e.g., editor:name)
	// For this, we often need a separate struct or custom UnmarshalXML.
	// Let's create a minimal struct to capture just the editor's name for demonstration.

	// To parse the 'editor:name' element, we need a struct that can capture it.
	// This requires a more complex root struct or iterative token processing for deeply nested/mixed content.
	// For simplicity, we assume we extract the editor part separately or add it to the main struct.

	// If we were to unmarshal the root again including the editor:
	type BookWithEditor struct {
		XMLName xml.Name `xml:"http://www.example.com/books book"`
		Title   string   `xml:"http://www.example.com/books title"`
		Author  string   `xml:"author"`
		Year    int      `xml:"http://www.example.com/books year"`
		Editor  string   `xml:"http://www.example.com/editors name"` // Correctly targets the editor's name
	}

	fmt.Println("\n--- Unmarshalling with Multiple Namespaces ---")
	var bookWithEditor BookWithEditor
	err = xml.Unmarshal([]byte(xmlData), &bookWithEditor)
	if err != nil {
		fmt.Printf("Error unmarshalling BookWithEditor: %v\n", err)
	} else {
		fmt.Printf("BookWithEditor: %+v\n", bookWithEditor)
	}

	// Another common pitfall: dealing with attributes in namespaces.
	// Let's define an XML with an attribute in a namespace.
	xmlWithAttr := `
		<item xmlns:attr="http://www.example.com/attributes" attr:id="123">
			<name>Special Item</name>
		</item>`

	type Item struct {
		XMLName xml.Name `xml:"item"`
		ID      string   `xml:"http://www.example.com/attributes id,attr"` // Namespace and 'attr' for attribute
		Name    string   `xml:"name"`
	}

	fmt.Println("\n--- Unmarshalling Attributes with Namespaces ---")
	var item Item
	err = xml.Unmarshal([]byte(xmlWithAttr), &item)
	if err != nil {
		fmt.Printf("Error unmarshalling Item: %v\n", err)
	} else {
		fmt.Printf("Item: %+v\n", item)
	}
}

package main

import (
	"encoding/xml"
	"fmt"
	"io"
	"strings"
)

// XML structure with a default namespace and a prefixed one.
// Note the 'library' element has a default namespace, and 'book' elements inherit it.
// 'catalog:id' is an attribute in a different namespace.
const complexXML = `
	<library xmlns="http://www.example.com/library" xmlns:catalog="http://www.example.com/catalog">
		<book id="B001">
			<title>The Go Programming Language</title>
			<author>Alan A. A. Donovan, Brian W. Kernighan</author>
			<publicationInfo catalog:id="PU001">
				<year>2015</year>
				<publisher>Addison-Wesley</publisher>
			</publicationInfo>
		</book>
		<book id="B002">
			<title>Go Concurrency Patterns</title>
			<author>Rob Pike</author>
			<publicationInfo catalog:id="PU002">
				<year>2012</year>
				<publisher>Google</publisher>
			</publicationInfo>
		</book>
		<metadata>
			<description>A collection of programming books.</description>
			<version>1.0</version>
		</metadata>
	</library>`

// Library represents the root element, explicitly declaring its default namespace.
type Library struct {
	XMLName  xml.Name `xml:"http://www.example.com/library library"`
	Books    []Book   `xml:"book"` // 'book' elements are in the default namespace
	Metadata Metadata `xml:"metadata"`
}

// Book represents a single book element, inheriting the default namespace.
type Book struct {
	ID              string          `xml:"id,attr"`
	Title           string          `xml:"title"`
	Author          string          `xml:"author"`
	PublicationInfo PublicationInfo `xml:"publicationInfo"`
}

// PublicationInfo contains publication details. catalog:id is an attribute in a different namespace.
type PublicationInfo struct {
	// Use the full namespace URI for the attribute `catalog:id`
	CatalogID string `xml:"http://www.example.com/catalog id,attr"`
	Year      int    `xml:"year"`
	Publisher string `xml:"publisher"`
}

// Metadata for the library, also inheriting the default namespace.
type Metadata struct {
	Description string `xml:"description"`	
	Version     string `xml:"version"`
}

func main() {
	var library Library
	err := xml.Unmarshal([]byte(complexXML), &library)
	if err != nil {
		fmt.Printf("Error unmarshalling complex XML: %v\n", err)
		return
	}

	fmt.Println("--- Successfully Unmarshalled Library ---")
	fmt.Printf("Library Name: %s (Space: %s, Local: %s)\n", library.XMLName.Local, library.XMLName.Space, library.XMLName.Local)
	fmt.Printf("Metadata Description: %s\n", library.Metadata.Description)

	for i, book := range library.Books {
		fmt.Printf("\nBook %d (ID: %s):\n", i+1, book.ID)
		fmt.Printf("  Title: %s\n", book.Title)
		fmt.Printf("  Author: %s\n", book.Author)
		fmt.Printf("  Publication Info:\n")
		fmt.Printf("    Catalog ID: %s\n", book.PublicationInfo.CatalogID)
		fmt.Printf("    Year: %d\n", book.PublicationInfo.Year)
		fmt.Printf("    Publisher: %s\n", book.PublicationInfo.Publisher)
	}

	// Demonstrate custom UnmarshalXML for granular control or error handling.
	// Imagine a scenario where a 'description' could be either a string or an object.
	// This requires implementing xml.Unmarshaler.

	// For a simpler demonstration, let's just implement a custom unmarshaler for Metadata
	// to upper-case the description, showing the interface in action.

	type CustomMetadata struct {
		Description string `xml:"description"`
		Version     string `xml:"version"`
		Raw         []byte `xml:"-"` // To store raw XML for debugging if needed
	}

	func (cm *CustomMetadata) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
		// Default unmarshalling for all fields that aren't custom handled.
		type Alias CustomMetadata
		aux := &struct{ *Alias }{Alias: (*Alias)(cm)}

		if err := d.DecodeElement(aux, &start); err != nil {
			return err
		}
		// Custom logic: convert description to uppercase
		cm.Description = strings.ToUpper(cm.Description)
		return nil
	}

	fmt.Println("\n--- Unmarshalling with Custom UnmarshalXML for Metadata ---")
	const customXML = `
		<library xmlns="http://www.example.com/library">
			<metadata>
				<description>A custom description here.</description>
				<version>2.0</version>
			</metadata>
		</library>`

	type CustomLibrary struct {
		XMLName  xml.Name       `xml:"http://www.example.com/library library"`
		Metadata CustomMetadata `xml:"metadata"`
	}

	var customLib CustomLibrary
	err = xml.Unmarshal([]byte(customXML), &customLib)
	if err != nil {
		fmt.Printf("Error unmarshalling custom XML: %v\n", err)
	} else {
		fmt.Printf("CustomLibrary Metadata Description (uppercase): %s\n", customLib.Metadata.Description)
		fmt.Printf("CustomLibrary Metadata Version: %s\n", customLib.Metadata.Version)
	}

	// Further demonstrating xml.Decoder for streaming and more explicit control.
	// This is crucial for very large XML files or when dealing with mixed content/unknown structures.
	fmt.Println("\n--- Streaming XML with xml.Decoder.Token() for granular control ---")
	decoder := xml.NewDecoder(strings.NewReader(complexXML))
	for {
		token, err := decoder.Token()
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Printf("Error decoding token: %v\n", err)
			return
		}

		switch se := token.(type) {
		case xml.StartElement:
			if se.Name.Space == "http://www.example.com/library" && se.Name.Local == "book" {
				var b Book
				// Decode an element directly into a struct.
				err := decoder.DecodeElement(&b, &se)
				if err != nil {
					fmt.Printf("Error decoding book element: %v\n", err)
					continue
				}
				fmt.Printf("  Streamed Book Title: %s (ID: %s)\n", b.Title, b.ID)
			}
		case xml.CharData:
			if text := strings.TrimSpace(string(se)); len(text) > 0 {
				// fmt.Printf("  CharData: %s\n", text) // Uncomment to see all character data
			}
		}
	}
}

package main

import (
	"encoding/xml"
	"fmt"
)

// XML example with deeply nested structures and optional/repeating elements.
const deepNestedXML = `
	<report xmlns="http://www.example.com/reports">
		<header>
			<title>Quarterly Performance</title>
			<date>2023-Q4</date>
			<author type="internal">Analyst Team</author>
		</header>
		<data>
			<section name="Sales">
				<metric type="revenue" unit="USD">1,200,000</metric>
				<metric type="growth" unit="percent">15</metric>
				<notes>
					<note>Strong performance in EMEA.</note>
					<note>APAC still challenging.</note>
				</notes>
			</section>
			<section name="Marketing">
				<metric type="leads">50,000</metric>
				<metric type="conversion" unit="percent">5</metric>
				<!-- Optional: <campaigns><campaign>...</campaign></campaigns> -->
			</section>
			<summary>
				Overall positive trend. <emphasis>Key area for improvement: APAC.</emphasis>
			</summary>
		</data>
	</report>`

// Define structs for the nested XML.

// Report is the root element
type Report struct {
	XMLName xml.Name `xml:"http://www.example.com/reports report"`
	Header  Header   `xml:"header"`
	Data    Data     `xml:"data"`
}

// Header contains report metadata
type Header struct {
	Title  string `xml:"title"`
	Date   string `xml:"date"`
	Author Author `xml:"author"`
}

// Author can have attributes
type Author struct {
	Type string `xml:"type,attr"`
	Name string `xml:",chardata"` // Capture text content of the element
}

// Data wraps sections and summary
type Data struct {
	Sections []Section `xml:"section"` // Use slice for repeating elements
	Summary  Summary   `xml:"summary"`
}

// Section contains metrics and notes
type Section struct {
	Name    string   `xml:"name,attr"`
	Metrics []Metric `xml:"metric"`
	Notes   []string `xml:"notes>note"` // Flattening: directly access notes from 'notes' parent
	// Use pointer for optional elements, e.g., Campaigns *Campaigns `xml:"campaigns,omitempty"`
}

// Metric details
type Metric struct {
	Type  string `xml:"type,attr"`
	Unit  string `xml:"unit,attr,omitempty"` // Optional attribute
	Value string `xml:",chardata"` // Capture text content
}

// Summary might contain mixed content (text + child elements like <emphasis>)
// For mixed content, xml.Unmarshal will only capture the first text block
// or require custom UnmarshalXML / xml.RawMessage.
type Summary struct {
	// Using string will only capture initial text before any child elements.
	// For full mixed content, xml.RawMessage or custom UnmarshalXML is required.
	RawSummary xml.RawMessage `xml:",innerxml"` // Capture all inner XML as bytes
	// Or parse selectively if inner structure is known:
	Text     string   `xml:",chardata"` // Catches text directly under summary
	Emphasis []string `xml:"emphasis"` // Catches emphasis tags, if they don't break chardata flow
}

func main() {
	var report Report
	err := xml.Unmarshal([]byte(deepNestedXML), &report)
	if err != nil {
		fmt.Printf("Error unmarshalling deep nested XML: %v\n", err)
		return
	}

	fmt.Println("--- Successfully Unmarshalled Deeply Nested XML ---")
	fmt.Printf("Report Title: %s\n", report.Header.Title)
	fmt.Printf("Report Author: %s (Type: %s)\n", report.Header.Author.Name, report.Header.Author.Type)

	for _, section := range report.Data.Sections {
		fmt.Printf("\nSection: %s\n", section.Name)
		for _, metric := range section.Metrics {
			unit := ""
			if metric.Unit != "" {
				unit = fmt.Sprintf(" (%s)", metric.Unit)
			}
			fmt.Printf("  Metric %s%s: %s\n", metric.Type, unit, metric.Value)
		}
		for i, note := range section.Notes {
			fmt.Printf("  Note %d: %s\n", i+1, note)
		}
	}

	fmt.Println("\nSummary (Raw Inner XML):")
	fmt.Printf("  %s\n", string(report.Data.Summary.RawSummary))

	// To demonstrate how `xml.RawMessage` can then be unmarshaled further:
	type InnerSummaryContent struct {
		Text     string   `xml:",chardata"`
		Emphasis string   `xml:"emphasis"`
	}

	var innerSummary InnerSummaryContent
	if len(report.Data.Summary.RawSummary) > 0 {
		// Wrap the raw summary in a dummy tag to make it a valid XML document fragment for unmarshalling.
		// This is a common pattern when dealing with innerxml.
		dummyXML := fmt.Sprintf("<root>%s</root>", report.Data.Summary.RawSummary)
		err = xml.Unmarshal([]byte(dummyXML), &struct { InnerSummaryContent }{})
		// This part requires careful handling of the context of RawSummary to avoid parsing issues.
		// A better approach often involves writing a custom UnmarshalXML for Summary if mixed content is complex.
		// For simple cases, `xml:",innerxml"` provides the raw bytes to parse manually.
		fmt.Println("  (Manual parsing of RawSummary for demonstration needs a wrapper or custom logic.)")
	}
}

package main

import (
	"encoding/xml"
	"fmt"
	"io"
	"os"
	"strings"
)

// A simple struct for demonstrating error handling during unmarshalling
type SimpleData struct {
	Value int `xml:"value"`
}

// Example of a robust error handling function that tries to provide context
func unmarshalWithContext(data []byte, v interface{}) error {
	decoder := xml.NewDecoder(strings.NewReader(string(data)))
	// Use Strict(false) to allow some malformed XML to be parsed up to the error point
	// or to ignore unknown elements/attributes (use with caution).
	// decoder.Strict = false

	// Custom CharsetReader can handle non-UTF-8 encodings, if specified in XML declaration.
	// decoder.CharsetReader = func(charset string, input io.Reader) (io.Reader, error) {
	// 	if strings.ToLower(charset) == "iso-8859-1" {
	// 		return transform.NewReader(input, latin1.NewDecoder()), nil
	// 	}
	// 	return nil, fmt.Errorf("unknown charset: %s", charset)
	// }

	err := decoder.Decode(v)
	if err != nil {
		// Enhance error messages for better debugging
		if e, ok := err.(*xml.SyntaxError); ok {
			line, col := e.Line, e.Column
			// Attempt to show the problematic line or surrounding context
			lines := strings.Split(string(data), "\n")
			context := ""
			if line > 0 && line <= len(lines) {
				context = lines[line-1]
				// Highlight column if possible, though exact char might be tricky with tabs/multi-byte chars
				if col > 0 && col <= len(context) {
					context = fmt.Sprintf("%s\n%s^", context, strings.Repeat(" ", col-1))
				}
			}
			return fmt.Errorf("XML Syntax Error at line %d, column %d: %s\nContext:\n%s", line, col, e.Error(), context)
		}
		return fmt.Errorf("XML Unmarshalling Error: %w", err)
	}
	return nil
}

// Demonstrate streaming for large files
// For a real-world scenario, read from os.Open(filename)
func processLargeXMLStream(reader io.Reader) error {
	decoder := xml.NewDecoder(reader)
	// Configure decoder for robustness	
	decoder.Strict = false // Allow parsing of malformed XML up to a point

	// Optionally ignore all comments, processing instructions, and directives
	decoder.Entity = nil // If you don't want DTD entity resolution
	
	fmt.Println("\n--- Processing XML stream ---")
	for {
		token, err := decoder.Token()
		if err == io.EOF {
			break // End of file
		}
		if err != nil {
			return fmt.Errorf("stream processing error: %w", err)
		}

		switch se := token.(type) {
		case xml.StartElement:
			// We are interested in <item> tags
			if se.Name.Local == "item" && se.Name.Space == "" { // Assume default or no namespace for item
				var item struct {
					Name  string `xml:"name"`
					Price float64 `xml:"price"`
				}
				err := decoder.DecodeElement(&item, &se)
				if err != nil {
					fmt.Printf("Warning: failed to decode item: %v\n", err)
					// Continue to next token, but skip current element's children
					// This requires more complex logic to skip children if DecodeElement fails mid-element
					// For simplicity, here it just logs and might move to next top-level token.
					continue
				}
				fmt.Printf("  Processed Item: %s (Price: %.2f)\n", item.Name, item.Price)
			}
		case xml.EndElement:
			// fmt.Printf("End: %s\n", se.Name.Local)
		case xml.CharData:
			// fmt.Printf("CharData: %s\n", strings.TrimSpace(string(se)))
		}
	}
	return nil
}

func main() {
	// Demonstrate robust error handling
	malformedXML := `<data><value>abc</value></data>` // 'abc' cannot be unmarshaled to int
	fmt.Println("--- Demonstrating Enhanced Error Handling ---")
	var sd SimpleData
	err := unmarshalWithContext([]byte(malformedXML), &sd)
	if err != nil {
		fmt.Printf("Caught expected error: %v\n", err)
	}

	// Example of a large-ish XML to demonstrate streaming potential
	largeXMLContent := `<catalog>`
	for i := 1; i <= 10; i++ {
		largeXMLContent += fmt.Sprintf(`
			<item>
				<name>Product %d</name>
				<price>%.2f</price>
			</item>`, i, float64(i)*10.50)
	}
	largeXMLContent += `</catalog>`

	err = processLargeXMLStream(strings.NewReader(largeXMLContent))
	if err != nil {
		fmt.Printf("Error processing stream: %v\n", err)
	}

	// Example: Handling unknown elements by discarding them (default behavior of strict=false)
	// If Strict=true, unknown elements will cause an error.
	fmt.Println("\n--- Handling Unknown Elements (Strict=false implicitly) ---")
	const unknownElemXML = `<root><known>Value</known><unknown>Ignored</unknown></root>`
	type Root struct {
		Known string `xml:"known"`
	}
	var root Root
	decoder := xml.NewDecoder(strings.NewReader(unknownElemXML))
	// By default, encoding/xml ignores elements not mapped in the struct,
	// unless Strict is set and an unexpected element is encountered as direct children.
	// For deeper unknown elements, it often depends on how DecodeElement is used.
	decoder.Strict = false // Explicitly allow unknown elements
	err = decoder.Decode(&root)
	if err != nil {
		fmt.Printf("Error with unknown elements: %v\n", err)
	} else {
		fmt.Printf("Parsed Root (unknown element ignored): %+v\n", root)
	}
}