encoder_test.go

package jsonpartial

import (
	"bytes"
	"encoding/json"
	"strings"
	"testing"
)

func TestEncoderBasicStruct(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	simple := Simple{
		ID:          "123",
		Name:        "Test Task",
		Description: "This is a test",
	}

	err := encoder.Encode(simple)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	// Parse the result
	var result map[string]interface{}
	if err := json.Unmarshal(buf.Bytes(), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}

	// Should contain id and name, but NOT description (unmarshalonly-only)
	if _, ok := result["id"]; !ok {
		t.Error("Expected 'id' field in output")
	}
	if _, ok := result["name"]; !ok {
		t.Error("Expected 'name' field in output")
	}
	if _, ok := result["description"]; ok {
		t.Error("Expected 'description' to be excluded (input-only)")
	}
}

func TestEncoderArray(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	items := []Simple{
		{ID: "1", Name: "First", Description: "Desc 1"},
		{ID: "2", Name: "Second", Description: "Desc 2"},
	}

	err := encoder.Encode(items)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	// Parse the result
	var result []map[string]interface{}
	if err := json.Unmarshal(buf.Bytes(), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}

	if len(result) != 2 {
		t.Fatalf("Expected 2 items, got %d", len(result))
	}

	// Check first item
	if _, ok := result[0]["id"]; !ok {
		t.Error("Expected first item 'id' field")
	}
	if _, ok := result[0]["description"]; ok {
		t.Error("Expected first item 'description' to be excluded")
	}

	// Check second item
	if _, ok := result[1]["id"]; !ok {
		t.Error("Expected second item 'id' field")
	}
}

func TestEncoderNestedStruct(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	nested := Nested{
		Simple: Simple{
			ID:          "456",
			Name:        "Nested Task",
			Description: "Nested description",
		},
		Count: 42,
	}

	err := encoder.Encode(nested)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	// Parse the result
	var result map[string]interface{}
	if err := json.Unmarshal(buf.Bytes(), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}

	// Check nested struct
	simple, ok := result["simple"].(map[string]interface{})
	if !ok {
		t.Fatal("Expected 'simple' to be an object")
	}

	if _, ok := simple["id"]; !ok {
		t.Error("Expected nested 'id' field")
	}
	if _, ok := simple["description"]; ok {
		t.Error("Expected nested 'description' to be excluded")
	}

	// Check top-level fields
	if _, ok := result["count"]; !ok {
		t.Error("Expected 'count' field")
	}
}

func TestEncoderSetIndent(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)
	encoder.SetIndent("", "  ")

	simple := Simple{
		ID:          "123",
		Name:        "Test Task",
		Description: "This is a test",
	}

	err := encoder.Encode(simple)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	output := buf.String()

	// Should have indentation
	if !strings.Contains(output, "\n  ") {
		t.Error("Expected indented output with newlines and spaces")
	}

	// Verify content is correct
	var result map[string]interface{}
	if err := json.Unmarshal([]byte(output), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}

	if _, ok := result["description"]; ok {
		t.Error("Expected 'description' to be excluded even in indented output")
	}
}

func TestEncoderSetIndentWithPrefix(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)
	encoder.SetIndent("prefix:", "  ")

	simple := Simple{
		ID:   "123",
		Name: "Test",
	}

	err := encoder.Encode(simple)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	output := buf.String()

	// Should have prefix on lines
	if !strings.Contains(output, "prefix:") {
		t.Error("Expected output to contain prefix")
	}
}

func TestEncoderMap(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	withMap := WithMap{
		Data: map[string]Simple{
			"task1": {ID: "1", Name: "Task 1", Description: "Desc 1"},
			"task2": {ID: "2", Name: "Task 2", Description: "Desc 2"},
		},
	}

	err := encoder.Encode(withMap)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	// Parse the result
	var result map[string]interface{}
	if err := json.Unmarshal(buf.Bytes(), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}

	data, ok := result["data"].(map[string]interface{})
	if !ok {
		t.Fatal("Expected 'data' to be a map")
	}

	task1, ok := data["task1"].(map[string]interface{})
	if !ok {
		t.Fatal("Expected 'task1' to be an object")
	}

	if _, ok := task1["id"]; !ok {
		t.Error("Expected task1 'id' field")
	}
	if _, ok := task1["description"]; ok {
		t.Error("Expected task1 'description' to be excluded")
	}
}

func TestEncoderPointer(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	item := &Simple{ID: "123", Name: "Test", Description: "Desc"}
	withPointer := WithPointer{Item: item}

	err := encoder.Encode(withPointer)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	// Parse the result
	var result map[string]interface{}
	if err := json.Unmarshal(buf.Bytes(), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}

	itemMap, ok := result["item"].(map[string]interface{})
	if !ok {
		t.Fatal("Expected 'item' to be an object")
	}

	if _, ok := itemMap["id"]; !ok {
		t.Error("Expected Item 'id' field")
	}
	if _, ok := itemMap["description"]; ok {
		t.Error("Expected Item 'description' to be excluded")
	}
}

func TestEncoderNilPointer(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	withPointer := WithPointer{Item: nil}

	err := encoder.Encode(withPointer)
	if err != nil {
		t.Fatalf("Encoder.Encode with nil failed: %v", err)
	}

	// Parse the result
	var result map[string]interface{}
	if err := json.Unmarshal(buf.Bytes(), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}

	if result["item"] != nil {
		t.Error("Expected nil item to be encoded as null")
	}
}

func TestEncoderEmbeddedStruct(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	embedded := Embedded{
		Base: Base{
			ID:   "embedded-id",
			Name: "Embedded Name",
		},
		Description: "Embedded Desc",
	}

	err := encoder.Encode(embedded)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	// Parse the result
	var result map[string]interface{}
	if err := json.Unmarshal(buf.Bytes(), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}

	// Embedded fields should be flattened
	if _, ok := result["id"]; !ok {
		t.Error("Expected embedded 'id' field")
	}
	if _, ok := result["name"]; !ok {
		t.Error("Expected embedded 'name' field")
	}
	// Description is unmarshalonly-only, should be excluded
	if _, ok := result["description"]; ok {
		t.Error("Expected 'description' to be excluded (unmarshalonly-only)")
	}
}

func TestEncoderIgnored(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	ignored := Ignored{
		Public:  "visible",
		Private: "hidden",
	}

	err := encoder.Encode(ignored)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	// Parse the result
	var result map[string]interface{}
	if err := json.Unmarshal(buf.Bytes(), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}

	if _, ok := result["public"]; !ok {
		t.Error("Expected 'public' field")
	}
	if _, ok := result["private"]; ok {
		t.Error("Expected 'private' to be excluded (json:\"-\")")
	}
}

func TestEncoderPrimitives(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	prim := Primitive{
		StringField: "test",
		IntField:    42,
		BoolField:   true,
		SliceField:  []string{"a", "b", "c"},
		MapField:    map[string]int{"x": 1, "y": 2},
	}

	err := encoder.Encode(prim)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	// Parse the result
	var result map[string]interface{}
	if err := json.Unmarshal(buf.Bytes(), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}

	if result["string_field"] != "test" {
		t.Errorf("Expected 'string_field' to be 'test', got %v", result["string_field"])
	}
	if result["int_field"] != float64(42) {
		t.Errorf("Expected 'int_field' to be 42, got %v", result["int_field"])
	}
	if result["bool_field"] != true {
		t.Errorf("Expected 'bool_field' to be true, got %v", result["bool_field"])
	}

	slice, ok := result["slice_field"].([]interface{})
	if !ok || len(slice) != 3 {
		t.Error("Expected 'slice_field' to be an array with 3 elements")
	}

	mapField, ok := result["map_field"].(map[string]interface{})
	if !ok {
		t.Error("Expected 'map_field' to be a map")
	}
	if mapField["x"] != float64(1) {
		t.Errorf("Expected map['x'] to be 1, got %v", mapField["x"])
	}
}

func TestEncoderEmptyStruct(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	type Empty struct{}
	empty := Empty{}

	err := encoder.Encode(empty)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	output := strings.TrimSpace(buf.String())
	if output != "{}" {
		t.Errorf("Expected empty struct to encode to {}, got %s", output)
	}
}

func TestEncoderMultipleCalls(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)

	// First encode
	simple1 := Simple{ID: "1", Name: "First", Description: "Desc1"}
	if err := encoder.Encode(simple1); err != nil {
		t.Fatalf("First Encode failed: %v", err)
	}

	// Second encode
	simple2 := Simple{ID: "2", Name: "Second", Description: "Desc2"}
	if err := encoder.Encode(simple2); err != nil {
		t.Fatalf("Second Encode failed: %v", err)
	}

	// Split by newlines
	lines := strings.Split(strings.TrimSpace(buf.String()), "\n")
	if len(lines) != 2 {
		t.Fatalf("Expected 2 lines, got %d", len(lines))
	}

	// Verify each line is valid JSON
	for i, line := range lines {
		var result map[string]interface{}
		if err := json.Unmarshal([]byte(line), &result); err != nil {
			t.Errorf("Line %d is not valid JSON: %v", i, err)
		}
		if _, ok := result["description"]; ok {
			t.Errorf("Line %d should not contain 'description'", i)
		}
	}
}

func TestEncoderSetEscapeHTML(t *testing.T) {
	var buf bytes.Buffer
	encoder := NewEncoder(&buf)
	encoder.SetEscapeHTML(true)

	type HTMLStruct struct {
		Content string `json:"content"`
	}

	html := HTMLStruct{Content: "<script>alert('test')</script>"}
	err := encoder.Encode(html)
	if err != nil {
		t.Fatalf("Encoder.Encode failed: %v", err)
	}

	output := buf.String()
	// With HTML escaping, < should become \u003c
	if strings.Contains(output, "<script>") {
		t.Log("HTML escaping is enabled (expected)")
	}

	// Verify it's valid JSON
	var result map[string]interface{}
	if err := json.Unmarshal([]byte(output), &result); err != nil {
		t.Fatalf("Failed to unmarshal result: %v", err)
	}
}

func TestEncoderRoundTrip(t *testing.T) {
	// First, marshal with encoder
	var encodeBuf bytes.Buffer
	encoder := NewEncoder(&encodeBuf)

	original := RoundTripStruct{
		ID:          "123",
		Name:        "Test",
		Description: "Desc",
		Secret:      "hidden",
	}

	err := encoder.Encode(original)
	if err != nil {
		t.Fatalf("Encode failed: %v", err)
	}

	// Then, unmarshal with decoder
	decoder := NewDecoder(&encodeBuf)
	var decoded RoundTripStruct
	err = decoder.Decode(&decoded)
	if err != nil {
		t.Fatalf("Decode failed: %v", err)
	}

	// ID should be empty (was marshalonly-only, not allowed in unmarshalonly)
	if decoded.ID != "" {
		t.Errorf("Expected ID to be empty after roundtrip, got %q", decoded.ID)
	}
	// Name should be preserved
	if decoded.Name != "Test" {
		t.Errorf("Expected Name to be 'Test', got %q", decoded.Name)
	}
	// Description should be empty (wasn't in the encoded output)
	if decoded.Description != "" {
		t.Errorf("Expected Description to be empty, got %q", decoded.Description)
	}
	// Secret should be empty (was marshalonly-only)
	if decoded.Secret != "" {
		t.Errorf("Expected Secret to be empty, got %q", decoded.Secret)
	}
}