builder_test.go

// Copyright 2026 Joshua Jones <joshua.jones.software@gmail.com>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package hl7

import (
	"errors"
	"strings"
	"testing"
)

func findSeg(msg *Message, typ string) *Segment {
	for i := range msg.Segments() {
		if msg.Segments()[i].Type() == typ {
			return &msg.Segments()[i]
		}
	}
	return nil
}

func TestBuilderBasic(t *testing.T) {
	b, err := NewMessageBuilder()
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	if err := b.Set("MSH-9.1", "ADT"); err != nil {
		t.Fatalf("Set MSH-9.1: %v", err)
	}
	if err := b.Set("MSH-9.2", "A01"); err != nil {
		t.Fatalf("Set MSH-9.2: %v", err)
	}
	if err := b.Set("MSH-10", "CTRL123"); err != nil {
		t.Fatalf("Set MSH-10: %v", err)
	}

	msg, err := b.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}

	if got := msg.Get("MSH-9.1").String(); got != "ADT" {
		t.Errorf("MSH-9.1 = %q, want %q", got, "ADT")
	}
	if got := msg.Get("MSH-9.2").String(); got != "A01" {
		t.Errorf("MSH-9.2 = %q, want %q", got, "A01")
	}
	if got := msg.Get("MSH-10").String(); got != "CTRL123" {
		t.Errorf("MSH-10 = %q, want %q", got, "CTRL123")
	}
}

func TestBuilderMultipleSegments(t *testing.T) {
	b, err := NewMessageBuilder()
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	b.Set("MSH-9.1", "ADT")
	b.Set("MSH-9.2", "A01")
	b.Set("PID-3.1", "12345")
	b.Set("PID-5.1", "Doe")
	b.Set("PID-5.2", "John")
	b.Set("PV1-2", "I")
	b.Set("OBX-5", "Normal")

	msg, err := b.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}

	if count := len(msg.Segments()); count != 4 {
		t.Errorf("segment count = %d, want 4", count)
	}

	if got := msg.Get("PID-3.1").String(); got != "12345" {
		t.Errorf("PID-3.1 = %q, want %q", got, "12345")
	}
	if got := msg.Get("PID-5.1").String(); got != "Doe" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Doe")
	}
	if got := msg.Get("PID-5.2").String(); got != "John" {
		t.Errorf("PID-5.2 = %q, want %q", got, "John")
	}
	if got := msg.Get("PV1-2").String(); got != "I" {
		t.Errorf("PV1-2 = %q, want %q", got, "I")
	}
	if got := msg.Get("OBX-5").String(); got != "Normal" {
		t.Errorf("OBX-5 = %q, want %q", got, "Normal")
	}
}

func TestBuilderComponentSubcomponent(t *testing.T) {
	b, err := NewMessageBuilder()
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	b.Set("PID-3.1", "12345")
	b.Set("PID-3.4.1", "AUTH")
	b.Set("PID-3.4.2", "SYSTEM")

	msg, err := b.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}

	if got := msg.Get("PID-3.1").String(); got != "12345" {
		t.Errorf("PID-3.1 = %q, want %q", got, "12345")
	}
	if got := msg.Get("PID-3.4.1").String(); got != "AUTH" {
		t.Errorf("PID-3.4.1 = %q, want %q", got, "AUTH")
	}
	if got := msg.Get("PID-3.4.2").String(); got != "SYSTEM" {
		t.Errorf("PID-3.4.2 = %q, want %q", got, "SYSTEM")
	}
}

func TestBuilderRepetitions(t *testing.T) {
	b, err := NewMessageBuilder()
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	b.Set("PID-3[0].1", "ID1")
	b.Set("PID-3[1].1", "ID2")

	msg, err := b.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}

	pid := findSeg(msg, "PID")
	if pid == nil {
		t.Fatal("PID segment not found")
	}

	field := pid.Field(3)
	if got := field.RepetitionCount(); got != 2 {
		t.Errorf("RepetitionCount = %d, want 2", got)
	}
	if got := field.Rep(0).Component(1).String(); got != "ID1" {
		t.Errorf("PID-3[0].1 = %q, want %q", got, "ID1")
	}
	if got := field.Rep(1).Component(1).String(); got != "ID2" {
		t.Errorf("PID-3[1].1 = %q, want %q", got, "ID2")
	}
}

func TestBuilderSetNull(t *testing.T) {
	b, err := NewMessageBuilder()
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	b.Set("PID-3", "12345")
	b.SetNull("PID-7")

	msg, err := b.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}

	pid := findSeg(msg, "PID")
	if pid == nil {
		t.Fatal("PID segment not found")
	}

	if !pid.Field(7).IsNull() {
		t.Error("PID-7 should be null")
	}
}

func TestBuilderEscaping(t *testing.T) {
	b, err := NewMessageBuilder()
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	// Value contains all delimiter characters.
	value := "a|b^c~d\\e&f"
	b.Set("PID-3", value)

	msg, err := b.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}

	// String() should round-trip through unescape.
	if got := msg.Get("PID-3").String(); got != value {
		t.Errorf("PID-3 = %q, want %q", got, value)
	}

	// Raw bytes should contain escape sequences.
	pid := findSeg(msg, "PID")
	raw := pid.Field(3).Raw()
	rawStr := string(raw)
	for _, seq := range []string{`\F\`, `\S\`, `\R\`, `\E\`, `\T\`} {
		if !strings.Contains(rawStr, seq) {
			t.Errorf("raw bytes %q should contain escape sequence %q", rawStr, seq)
		}
	}
}

func TestBuilderMSHDelimiterRejection(t *testing.T) {
	b, err := NewMessageBuilder()
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	if err := b.Set("MSH-1", "X"); !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("Set MSH-1 err = %v, want ErrMSHDelimiterField", err)
	}
	if err := b.Set("MSH-2", "X"); !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("Set MSH-2 err = %v, want ErrMSHDelimiterField", err)
	}
	if err := b.SetNull("MSH-1"); !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("SetNull MSH-1 err = %v, want ErrMSHDelimiterField", err)
	}
}

func TestBuilderInvalidLocation(t *testing.T) {
	b, err := NewMessageBuilder()
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	if err := b.Set("", "X"); !errors.Is(err, ErrInvalidLocation) {
		t.Errorf("Set empty err = %v, want ErrInvalidLocation", err)
	}
	if err := b.Set("garbage", "X"); !errors.Is(err, ErrInvalidLocation) {
		t.Errorf("Set garbage err = %v, want ErrInvalidLocation", err)
	}
}

func TestBuilderCustomDelimiters(t *testing.T) {
	d := Delimiters{
		Field:        '#',
		Component:    '@',
		Repetition:   '!',
		Escape:       '?',
		SubComponent: '%',
	}

	b, err := NewMessageBuilder(WithDelimiters(d))
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	b.Set("MSH-9.1", "ADT")
	msg, err := b.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}

	// MSH-1 should be the custom field separator.
	msh := findSeg(msg, "MSH")
	if msh == nil {
		t.Fatal("MSH not found")
	}
	if got := msh.Field(1).String(); got != "#" {
		t.Errorf("MSH-1 = %q, want %q", got, "#")
	}
	if got := msh.Field(2).String(); got != "@!?%" {
		t.Errorf("MSH-2 = %q, want %q", got, "@!?%")
	}
	if got := msg.Get("MSH-9.1").String(); got != "ADT" {
		t.Errorf("MSH-9.1 = %q, want %q", got, "ADT")
	}
}

func TestBuilderInvalidDelimiters(t *testing.T) {
	d := Delimiters{Field: '|', Component: '|'} // duplicate
	_, err := NewMessageBuilder(WithDelimiters(d))
	if err == nil {
		t.Error("expected error for duplicate delimiters")
	}
}

func TestBuilderBuildReusability(t *testing.T) {
	b, err := NewMessageBuilder()
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	b.Set("MSH-9.1", "ADT")
	b.Set("PID-3", "AAA")

	msg1, err := b.Build()
	if err != nil {
		t.Fatalf("Build 1: %v", err)
	}

	// Set more fields and build again.
	b.Set("PID-5.1", "Doe")
	b.Set("PID-3", "BBB")

	msg2, err := b.Build()
	if err != nil {
		t.Fatalf("Build 2: %v", err)
	}

	// First message should be unchanged (ParseMessage copies).
	if got := msg1.Get("PID-3").String(); got != "AAA" {
		t.Errorf("msg1 PID-3 = %q, want %q", got, "AAA")
	}
	if got := msg1.Get("PID-5.1").String(); got != "" {
		t.Errorf("msg1 PID-5.1 = %q, want empty", got)
	}

	// Second message should have the updated values.
	if got := msg2.Get("PID-3").String(); got != "BBB" {
		t.Errorf("msg2 PID-3 = %q, want %q", got, "BBB")
	}
	if got := msg2.Get("PID-5.1").String(); got != "Doe" {
		t.Errorf("msg2 PID-5.1 = %q, want %q", got, "Doe")
	}
}

func TestBuilderRoundTrip(t *testing.T) {
	b, err := NewMessageBuilder()
	if err != nil {
		t.Fatalf("NewMessageBuilder: %v", err)
	}

	b.Set("MSH-9.1", "ORU")
	b.Set("MSH-9.2", "R01")
	b.Set("MSH-10", "MSG001")
	b.Set("MSH-11", "P")
	b.Set("MSH-12", "2.5.1")
	b.Set("PID-3.1", "PAT123")
	b.Set("PID-5.1", "Smith")
	b.Set("PID-5.2", "Jane")
	b.Set("OBX-3.1", "1234-5")
	b.Set("OBX-5", "42")

	msg, err := b.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}

	// Re-parse the raw bytes to confirm the message is well-formed.
	msg2, err := ParseMessage(msg.Raw())
	if err != nil {
		t.Fatalf("re-parse: %v", err)
	}

	checks := []struct {
		loc  string
		want string
	}{
		{"MSH-9.1", "ORU"},
		{"MSH-9.2", "R01"},
		{"MSH-10", "MSG001"},
		{"MSH-11", "P"},
		{"MSH-12", "2.5.1"},
		{"PID-3.1", "PAT123"},
		{"PID-5.1", "Smith"},
		{"PID-5.2", "Jane"},
		{"OBX-3.1", "1234-5"},
		{"OBX-5", "42"},
	}
	for _, c := range checks {
		if got := msg2.Get(c.loc).String(); got != c.want {
			t.Errorf("re-parsed %s = %q, want %q", c.loc, got, c.want)
		}
	}
}

func BenchmarkBuilder(b *testing.B) {
	b.ReportAllocs()
	for range b.N {
		mb, _ := NewMessageBuilder()
		mb.Set("MSH-9.1", "ADT")
		mb.Set("MSH-9.2", "A01")
		mb.Set("MSH-10", "CTRL001")
		mb.Set("MSH-11", "P")
		mb.Set("MSH-12", "2.5.1")
		mb.Set("PID-3.1", "12345")
		mb.Set("PID-5.1", "Doe")
		mb.Set("PID-5.2", "John")
		mb.Set("PV1-2", "I")
		mb.Set("OBX-5", "Normal")
		mb.Build()
	}
}