serializer

func New(opts ...Option) *Policy

{
	p := &Policy{
		naming:      PascalCase,
		tagName:     "json",
		customTypes: make(map[reflect.Type]ConverterFactory),
	}
	for _, opt := range opts {
		opt(p)
	}
	return p
}

func setValue(fv reflect.Value, val any) error

{
	if val == nil {
		switch fv.Kind() {
		case reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice:
			fv.SetZero()
			return nil
		default:
			return errors.New("cannot assign null")
		}
	}
	rv := reflect.ValueOf(val)
	if rv.Type().AssignableTo(fv.Type()) {
		fv.Set(rv)
		return nil
	}
	if rv.Type().ConvertibleTo(fv.Type()) && isSafeConversion(rv.Kind(), fv.Kind()) {
		fv.Set(rv.Convert(fv.Type()))
		return nil
	}
	data, err := json.Marshal(val)
	if err != nil {
		return err
	}
	target := reflect.New(fv.Type())
	if err := json.Unmarshal(data, target.Interface()); err != nil {
		return err
	}
	fv.Set(target.Elem())
	return nil
}

func TestPolicy_Marshal_SnakeCase(t *testing.T)

{
	p := New(WithNaming(SnakeCase), WithTagName("json"))
	s := sample{FirstName: "John", LastName: "Doe", Age: 30}

	data, err := p.Marshal(s)
	if err != nil {
		t.Fatalf("Marshal failed: %v", err)
	}

	got := string(data)
	if !strings.Contains(got, `"first_name":"John"`) || !strings.Contains(got, `"last_name":"Doe"`) || !strings.Contains(got, `"age":30`) {
		t.Errorf("Marshal: got %q", got)
	}
}

func TestPolicy_Unmarshal_SnakeCase(t *testing.T)

{
	p := New(WithNaming(SnakeCase), WithTagName("json"))
	data := []byte(`{"first_name":"Jane","last_name":"Smith","age":25}`)

	var s sample
	if err := p.Unmarshal(data, &s); err != nil {
		t.Fatalf("Unmarshal failed: %v", err)
	}

	if s.FirstName != "Jane" {
		t.Errorf("FirstName: got %q, want %q", s.FirstName, "Jane")
	}
	if s.Age != 25 {
		t.Errorf("Age: got %d, want %d", s.Age, 25)
	}
}

func TestPolicy_IgnoreNil(t *testing.T)

{
	p := New(WithIgnoreNil(), WithTagName("json"))
	type withPtr struct {
		Name  string `json:"name"`
		Score *int   `json:"score"`
	}
	s := withPtr{Name: "test", Score: nil}
	data, err := p.Marshal(s)
	if err != nil {
		t.Fatalf("Marshal failed: %v", err)
	}
	got := string(data)
	if got != `{"name":"test"}` {
		t.Errorf("Marshal with IgnoreNil: got %q", got)
	}
}

func TestPolicy_IgnoreZero(t *testing.T)

{
	p := New(WithIgnoreZero(), WithTagName("json"))
	type withZero struct {
		Name string `json:"name"`
		Age  int    `json:"age"`
	}
	s := withZero{Name: "test", Age: 0}
	data, err := p.Marshal(s)
	if err != nil {
		t.Fatalf("Marshal failed: %v", err)
	}
	got := string(data)
	if got != `{"name":"test"}` {
		t.Errorf("Marshal with IgnoreZero: got %q", got)
	}
}

func TestPolicy_CamelCase(t *testing.T)

{
	p := New(WithNaming(CamelCase), WithTagName("json"))
	type camel struct {
		FirstName string
		LastName  string
	}
	s := camel{FirstName: "A", LastName: "B"}
	data, err := p.Marshal(s)
	if err != nil {
		t.Fatalf("Marshal failed: %v", err)
	}
	got := string(data)
	if got != `{"firstName":"A","lastName":"B"}` {
		t.Errorf("Marshal CamelCase: got %q", got)
	}
}

func TestPolicyCustomTypeRoundTrip(t *testing.T)

{
	policy := New(WithCustomType(reflect.TypeOf(customID("")), func() Converter {
		return customIDConverter{}
	}))
	input := struct {
		ID customID `json:"id"`
	}{ID: "42"}

	data, err := policy.Marshal(input)
	if err != nil {
		t.Fatal(err)
	}
	if string(data) != `{"id":"id:42"}` {
		t.Fatalf("Marshal() = %s", data)
	}
	var output struct {
		ID customID `json:"id"`
	}
	if err := policy.Unmarshal(data, &output); err != nil {
		t.Fatal(err)
	}
	if output.ID != "42" {
		t.Fatalf("ID = %q, want 42", output.ID)
	}
}

func TestPolicyHonorsJSONExclusion(t *testing.T)

{
	policy := New()
	data, err := policy.Marshal(struct {
		Name   string `json:"name"`
		Secret string `json:"-"`
	}{Name: "public", Secret: "private"})
	if err != nil {
		t.Fatal(err)
	}
	if string(data) != `{"name":"public"}` {
		t.Fatalf("Marshal() leaked excluded field: %s", data)
	}
}