transform_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 (
	"bytes"
	"errors"
	"os"
	"path/filepath"
	"testing"
)

func parseTestMessage(t *testing.T, raw string) *Message {
	t.Helper()
	msg, err := ParseMessage([]byte(raw))
	if err != nil {
		t.Fatalf("ParseMessage failed: %v", err)
	}
	return msg
}

func TestTransformReplace(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	result, err := msg.Transform(Replace("PID-5.1", "Smith"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "Smith" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Smith")
	}
	// Other components should be preserved.
	if got := result.Get("PID-5.2").String(); got != "John" {
		t.Errorf("PID-5.2 = %q, want %q", got, "John")
	}
}

func TestTransformNull(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John||19800101")

	result, err := msg.Transform(Null("PID-7"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	var pid *Segment
	for i := range result.Segments() {
		if result.Segments()[i].Type() == "PID" {
			pid = &result.Segments()[i]
			break
		}
	}
	if pid == nil {
		t.Fatal("PID not found")
	}
	if !pid.Field(7).IsNull() {
		t.Errorf("PID-7 should be null, got %q", pid.Field(7).String())
	}
}

func TestTransformOmit(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John||19800101|M")

	result, err := msg.Transform(Omit("PID-7"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	var pid *Segment
	for i := range result.Segments() {
		if result.Segments()[i].Type() == "PID" {
			pid = &result.Segments()[i]
			break
		}
	}
	if pid == nil {
		t.Fatal("PID not found")
	}
	if !pid.Field(7).IsEmpty() {
		t.Errorf("PID-7 should be empty, got %q", pid.Field(7).String())
	}
	// Field after omitted field should still be present.
	if got := pid.Field(8).String(); got != "M" {
		t.Errorf("PID-8 = %q, want %q", got, "M")
	}
}

func TestTransformMove(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123^MRN||Doe^John")

	result, err := msg.Transform(Move("PID-5.1", "PID-3.1"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Destination should have source value.
	if got := result.Get("PID-5.1").String(); got != "123" {
		t.Errorf("PID-5.1 (dst) = %q, want %q", got, "123")
	}
	// Source should be cleared.
	if got := result.Get("PID-3.1").String(); got != "" {
		t.Errorf("PID-3.1 (src) = %q, want empty", got)
	}
	// Other components at source should be preserved.
	if got := result.Get("PID-3.2").String(); got != "MRN" {
		t.Errorf("PID-3.2 = %q, want %q", got, "MRN")
	}
	// Other components at destination should be preserved.
	if got := result.Get("PID-5.2").String(); got != "John" {
		t.Errorf("PID-5.2 = %q, want %q", got, "John")
	}
}

func TestTransformMultipleChanges(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John||19800101")

	result, err := msg.Transform(
		Replace("PID-5.1", "Smith"),
		Replace("PID-5.2", "Jane"),
		Null("PID-7"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "Smith" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Smith")
	}
	if got := result.Get("PID-5.2").String(); got != "Jane" {
		t.Errorf("PID-5.2 = %q, want %q", got, "Jane")
	}

	var pid *Segment
	for i := range result.Segments() {
		if result.Segments()[i].Type() == "PID" {
			pid = &result.Segments()[i]
			break
		}
	}
	if pid == nil {
		t.Fatal("PID not found")
	}
	if !pid.Field(7).IsNull() {
		t.Errorf("PID-7 should be null")
	}
}

func TestTransformFieldLevelReplace(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	result, err := msg.Transform(Replace("PID-5", "NewValue"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "NewValue" {
		t.Errorf("PID-5.1 = %q, want %q", got, "NewValue")
	}
}

func TestTransformFieldLevelSupersedes(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	// Component-level then field-level: field-level wins because it comes last.
	result, err := msg.Transform(
		Replace("PID-5.1", "Smith"),
		Replace("PID-5", "FullReplace"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "FullReplace" {
		t.Errorf("PID-5.1 = %q, want %q", got, "FullReplace")
	}
}

func TestTransformOrderFieldThenComponent(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	// Field-level then component-level: the component change comes last
	// and should override the affected component, keeping the field-level
	// value as the base for other components.
	result, err := msg.Transform(
		Replace("PID-5", "Reset"),
		Replace("PID-5.1", "Override"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "Override" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Override")
	}
}

func TestTransformOrderFieldThenTwoComponents(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	// Field-level reset, then set two components on top.
	result, err := msg.Transform(
		Replace("PID-5", "Base"),
		Replace("PID-5.1", "Smith"),
		Replace("PID-5.2", "Jane"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "Smith" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Smith")
	}
	if got := result.Get("PID-5.2").String(); got != "Jane" {
		t.Errorf("PID-5.2 = %q, want %q", got, "Jane")
	}
}

func TestTransformOrderOmitThenComponent(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	// Omit field, then set a component — the component should appear.
	result, err := msg.Transform(
		Omit("PID-5"),
		Replace("PID-5.2", "Jane"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "" {
		t.Errorf("PID-5.1 = %q, want empty", got)
	}
	if got := result.Get("PID-5.2").String(); got != "Jane" {
		t.Errorf("PID-5.2 = %q, want %q", got, "Jane")
	}
}

func TestTransformOrderComponentThenSubcomponent(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123&MRN&AUTH||Doe^John")

	// Component-level reset, then subcomponent override.
	result, err := msg.Transform(
		Replace("PID-3.1", "NewBase"),
		Replace("PID-3.1.2", "SubOverride"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-3.1.1").String(); got != "NewBase" {
		t.Errorf("PID-3.1.1 = %q, want %q", got, "NewBase")
	}
	if got := result.Get("PID-3.1.2").String(); got != "SubOverride" {
		t.Errorf("PID-3.1.2 = %q, want %q", got, "SubOverride")
	}
}

func TestTransformOrderReplaceThenMove(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	// Replace PID-5.1, then move PID-5.1 to PID-3.1.
	// The move should carry the replaced value, not the original.
	result, err := msg.Transform(
		Replace("PID-5.1", "Smith"),
		Move("PID-3.1", "PID-5.1"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-3.1").String(); got != "Smith" {
		t.Errorf("PID-3.1 = %q, want %q", got, "Smith")
	}
	// Source should be cleared by the move.
	if got := result.Get("PID-5.1").String(); got != "" {
		t.Errorf("PID-5.1 = %q, want empty", got)
	}
}

func TestTransformDelimiterConversion(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	newDelims := Delimiters{
		Field:        '#',
		Component:    '@',
		Repetition:   '!',
		Escape:       '$',
		SubComponent: '%',
	}

	result, err := msg.TransformWith(newDelims,
		Replace("PID-5.1", "Smith"),
	)
	if err != nil {
		t.Fatalf("TransformWith failed: %v", err)
	}

	if result.Delimiters() != newDelims {
		t.Errorf("delimiters = %+v, want %+v", result.Delimiters(), newDelims)
	}

	if got := result.Get("PID-5.1").String(); got != "Smith" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Smith")
	}
	if got := result.Get("PID-5.2").String(); got != "John" {
		t.Errorf("PID-5.2 = %q, want %q", got, "John")
	}
	if got := result.Get("MSH-9.1").String(); got != "ADT" {
		t.Errorf("MSH-9.1 = %q, want %q", got, "ADT")
	}
}

func TestTransformDelimiterConversionNoChanges(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	newDelims := Delimiters{
		Field:        '#',
		Component:    '@',
		Repetition:   '!',
		Escape:       '$',
		SubComponent: '%',
	}

	result, err := msg.TransformWith(newDelims)
	if err != nil {
		t.Fatalf("TransformWith failed: %v", err)
	}

	if result.Delimiters() != newDelims {
		t.Errorf("delimiters = %+v, want %+v", result.Delimiters(), newDelims)
	}
	if got := result.Get("PID-5.1").String(); got != "Doe" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Doe")
	}
	if got := result.Get("MSH-9.1").String(); got != "ADT" {
		t.Errorf("MSH-9.1 = %q, want %q", got, "ADT")
	}
}

func TestTransformMSHReconstruction(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|MSG001|P|2.5.1\rPID|1||123")

	result, err := msg.Transform(Replace("MSH-10", "NEWID"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("MSH-10").String(); got != "NEWID" {
		t.Errorf("MSH-10 = %q, want %q", got, "NEWID")
	}
	// Other MSH fields should be preserved.
	if got := result.Get("MSH-3").String(); got != "S" {
		t.Errorf("MSH-3 = %q, want %q", got, "S")
	}
	if got := result.Get("MSH-9.1").String(); got != "ADT" {
		t.Errorf("MSH-9.1 = %q, want %q", got, "ADT")
	}
}

func TestTransformExtendField(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")

	// PID-5 doesn't exist — extend the segment.
	result, err := msg.Transform(Replace("PID-5.1", "Doe"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "Doe" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Doe")
	}
	// Earlier fields should be preserved.
	if got := result.Get("PID-3").String(); got != "123" {
		t.Errorf("PID-3 = %q, want %q", got, "123")
	}
}

func TestTransformExtendNewSegment(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	result, err := msg.Transform(Replace("PID-3", "12345"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-3").String(); got != "12345" {
		t.Errorf("PID-3 = %q, want %q", got, "12345")
	}
}

func TestTransformMoveEmptySource(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	// PID-19 doesn't exist — move empty value.
	result, err := msg.Transform(Move("PID-5.1", "PID-19"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Destination gets the empty value.
	if got := result.Get("PID-5.1").String(); got != "" {
		t.Errorf("PID-5.1 = %q, want empty", got)
	}
}

func TestTransformMSHDelimiterRejection(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	_, err := msg.Transform(Replace("MSH-1", "X"))
	if !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("expected ErrMSHDelimiterField, got %v", err)
	}

	_, err = msg.Transform(Replace("MSH-2", "XXXX"))
	if !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("expected ErrMSHDelimiterField, got %v", err)
	}
}

func TestTransformInvalidLocation(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	_, err := msg.Transform(Replace("invalid", "val"))
	if !errors.Is(err, ErrInvalidLocation) {
		t.Errorf("expected ErrInvalidLocation, got %v", err)
	}
}

func TestTransformNoChanges(t *testing.T) {
	raw := "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John"
	msg := parseTestMessage(t, raw)

	result, err := msg.Transform()
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "Doe" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Doe")
	}
}

func TestTransformOriginalUnchanged(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	_, err := msg.Transform(Replace("PID-5.1", "Smith"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Original should not be modified.
	if got := msg.Get("PID-5.1").String(); got != "Doe" {
		t.Errorf("original PID-5.1 = %q, want %q", got, "Doe")
	}
}

func TestTransformEscapeSequencesInSource(t *testing.T) {
	// PID-5.1 contains "Doe\T\Smith" (escaped subcomponent separator).
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe\\T\\Smith^John")

	// Replace PID-5.2, leaving PID-5.1 with escape sequences intact.
	result, err := msg.Transform(Replace("PID-5.2", "Jane"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "Doe&Smith" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Doe&Smith")
	}
	if got := result.Get("PID-5.2").String(); got != "Jane" {
		t.Errorf("PID-5.2 = %q, want %q", got, "Jane")
	}
}

func TestTransformSubcomponentLevel(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123&MRN&AUTH||Doe^John")

	result, err := msg.Transform(Replace("PID-3.1.2", "NEWMRN"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-3.1.1").String(); got != "123" {
		t.Errorf("PID-3.1.1 = %q, want %q", got, "123")
	}
	if got := result.Get("PID-3.1.2").String(); got != "NEWMRN" {
		t.Errorf("PID-3.1.2 = %q, want %q", got, "NEWMRN")
	}
	if got := result.Get("PID-3.1.3").String(); got != "AUTH" {
		t.Errorf("PID-3.1.3 = %q, want %q", got, "AUTH")
	}
}

func TestTransformInvalidDelimiters(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	// Duplicate delimiter.
	_, err := msg.TransformWith(Delimiters{
		Field: '|', Component: '|', Repetition: '~', Escape: '\\', SubComponent: '&',
	})
	if err == nil {
		t.Error("expected error for invalid delimiters")
	}
}

func TestTransformReplaceWithDelimiterChars(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	// Value contains pipe character — should be escaped in output.
	result, err := msg.Transform(Replace("PID-5.1", "Doe|Smith"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "Doe|Smith" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Doe|Smith")
	}
}

func TestTransformMoveWithDelimiterConversion(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	newDelims := Delimiters{
		Field:        '#',
		Component:    '@',
		Repetition:   '!',
		Escape:       '$',
		SubComponent: '%',
	}

	result, err := msg.TransformWith(newDelims,
		Move("PID-5.1", "PID-3"),
		Replace("MSH-10", "NEW_CONTROL_ID"),
	)
	if err != nil {
		t.Fatalf("TransformWith failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "123" {
		t.Errorf("PID-5.1 = %q, want %q", got, "123")
	}
	if got := result.Get("PID-3").String(); got != "" {
		t.Errorf("PID-3 = %q, want empty", got)
	}
	if got := result.Get("MSH-10").String(); got != "NEW_CONTROL_ID" {
		t.Errorf("MSH-10 = %q, want %q", got, "NEW_CONTROL_ID")
	}
}

func TestTransformLastWriteWins(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	result, err := msg.Transform(
		Replace("PID-5.1", "First"),
		Replace("PID-5.1", "Second"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Last write wins — component-level, last change at same location.
	if got := result.Get("PID-5.1").String(); got != "Second" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Second")
	}
}

func TestTransformSecondSegmentOccurrence(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ORU^R01|1|P|2.5.1\rOBX|1|NM|code1||val1\rOBX|2|NM|code2||val2")

	result, err := msg.Transform(Replace("OBX(1)-5", "newval"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("OBX(0)-5").String(); got != "val1" {
		t.Errorf("OBX(0)-5 = %q, want %q", got, "val1")
	}
	if got := result.Get("OBX(1)-5").String(); got != "newval" {
		t.Errorf("OBX(1)-5 = %q, want %q", got, "newval")
	}
}

func TestTransformMoveSourceClearsSource(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	result, err := msg.Transform(Move("PID-3", "PID-5"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Destination has the moved value.
	if got := result.Get("PID-3").String(); got != "Doe^John" {
		t.Errorf("PID-3 = %q, want %q", got, "Doe^John")
	}
	// Source should be cleared.
	if got := result.Get("PID-5").String(); got != "" {
		t.Errorf("PID-5 = %q, want empty", got)
	}
}

func TestTransformDelimiterConversionResolvesEscapes(t *testing.T) {
	// Source field OBX-5 contains escaped delimiter characters: \F\ (|), \S\ (^), \T\ (&).
	// When converting to a delimiter set where those characters are NOT delimiters,
	// the escape sequences must resolve to their literal source values — not be
	// symbolically remapped (e.g. \F\ must become literal "|", not "$F$" which
	// would mean "#" in the destination).
	msg := parseTestMessage(t, `MSH|^~\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1`+"\r"+
		`OBX|1|ST|code||value\F\with\S\delims\T\here`)

	newDelims := Delimiters{
		Field:        '#',
		Component:    '@',
		Repetition:   '!',
		Escape:       '$',
		SubComponent: '%',
	}

	result, err := msg.TransformWith(newDelims)
	if err != nil {
		t.Fatalf("TransformWith failed: %v", err)
	}

	// The escaped source delimiters should appear as literal characters in the
	// output because |, ^, and & are not delimiters in the destination set.
	if got := result.Get("OBX-5").String(); got != "value|with^delims&here" {
		t.Errorf("OBX-5 = %q, want %q", got, "value|with^delims&here")
	}
}

func TestTransformDelimiterConversionReEscapes(t *testing.T) {
	// Source field contains \F\ which resolves to "|". The destination set
	// also uses "|" as a delimiter (the component separator), so the literal
	// "|" must be re-escaped for the destination.
	msg := parseTestMessage(t, `MSH|^~\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1`+"\r"+
		`OBX|1|ST|code||before\F\after`)

	newDelims := Delimiters{
		Field:        '#',
		Component:    '|', // "|" is now the component separator
		Repetition:   '!',
		Escape:       '$',
		SubComponent: '%',
	}

	result, err := msg.TransformWith(newDelims)
	if err != nil {
		t.Fatalf("TransformWith failed: %v", err)
	}

	// The literal "|" collides with dst.Component, so it must be re-escaped.
	if got := result.Get("OBX-5").String(); got != "before|after" {
		t.Errorf("OBX-5 = %q, want %q", got, "before|after")
	}

	// Verify the raw bytes contain the escape sequence, not a bare "|".
	if raw := string(result.Get("OBX-5").Raw()); raw != "before$S$after" {
		t.Errorf("OBX-5 raw = %q, want %q", raw, "before$S$after")
	}
}

func TestTransformDelimiterConversionEscapesNewCollisions(t *testing.T) {
	// Source field PID-5.1 contains the literal character "#" which is plain
	// text under the source delimiter set (|^~\&). When converting to a
	// destination set where "#" is the field separator, the literal "#" must
	// be escaped so it is not misinterpreted as structure.
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Do#e^John")

	newDelims := Delimiters{
		Field:        '#',
		Component:    '@',
		Repetition:   '!',
		Escape:       '$',
		SubComponent: '%',
	}

	result, err := msg.TransformWith(newDelims)
	if err != nil {
		t.Fatalf("TransformWith failed: %v", err)
	}

	if got := result.Get("PID-5.1").String(); got != "Do#e" {
		t.Errorf("PID-5.1 = %q, want %q", got, "Do#e")
	}
	// Raw bytes should contain the escape sequence, not a bare "#".
	if raw := string(result.Get("PID-5.1").Raw()); raw != "Do$F$e" {
		t.Errorf("PID-5.1 raw = %q, want %q", raw, "Do$F$e")
	}
}

func BenchmarkTransform(b *testing.B) {
	data, err := os.ReadFile(filepath.Join("testdata", "oru_r01.hl7"))
	if err != nil {
		b.Fatalf("failed to read test file: %v", err)
	}

	msg, err := ParseMessage(data)
	if err != nil {
		b.Fatalf("ParseMessage failed: %v", err)
	}

	b.ResetTimer()
	b.ReportAllocs()
	for b.Loop() {
		_, _ = msg.Transform(
			Replace("PID-5.1", "Smith"),
			Replace("MSH-10", "NEWID"),
			Null("PID-7"),
			Copy("PID-4", "PID-3"),
		)
	}
}

func TestExtractFromFieldEdgeCases(t *testing.T) {
	d := DefaultDelimiters()

	t.Run("ComponentWithoutSubcomponent", func(t *testing.T) {
		// comp > 0, sub == 0: should return the component
		raw := []byte("val1^val2^val3")
		got := extractFromField(raw, d, 0, 2, 0)
		if string(got) != "val2" {
			t.Errorf("got %q, want %q", got, "val2")
		}
	})

	t.Run("OutOfRangeRepetition", func(t *testing.T) {
		raw := []byte("val1~val2")
		got := extractFromField(raw, d, 5, 0, 0)
		if got != nil {
			t.Errorf("got %q, want nil", got)
		}
	})

	t.Run("OutOfRangeComponent", func(t *testing.T) {
		raw := []byte("val1^val2")
		got := extractFromField(raw, d, 0, 99, 0)
		if got != nil {
			t.Errorf("got %q, want nil", got)
		}
	})

	t.Run("OutOfRangeSubcomponent", func(t *testing.T) {
		raw := []byte("val1&val2")
		got := extractFromField(raw, d, 0, 1, 99)
		if got != nil {
			t.Errorf("got %q, want nil", got)
		}
	})

	t.Run("RepZeroCompZero", func(t *testing.T) {
		// rep=0, comp=0: returns the first repetition
		raw := []byte("val1~val2")
		got := extractFromField(raw, d, 0, 0, 0)
		if string(got) != "val1" {
			t.Errorf("got %q, want %q", got, "val1")
		}
	})
}

func TestReadFieldBytesEdgeCases(t *testing.T) {
	d := DefaultDelimiters()

	t.Run("FieldNumLessThan1", func(t *testing.T) {
		got := readFieldBytes([]byte("PID|1||123"), d, 0)
		if got != nil {
			t.Errorf("got %q, want nil", got)
		}
	})

	t.Run("SegmentTooShort", func(t *testing.T) {
		got := readFieldBytes([]byte("PI"), d, 1)
		if got != nil {
			t.Errorf("got %q, want nil", got)
		}
	})

	t.Run("MSHField1", func(t *testing.T) {
		got := readFieldBytes([]byte("MSH|^~\\&|SEND"), d, 1)
		if string(got) != "|" {
			t.Errorf("got %q, want %q", got, "|")
		}
	})

	t.Run("MSHField2", func(t *testing.T) {
		got := readFieldBytes([]byte("MSH|^~\\&|SEND"), d, 2)
		if string(got) != "^~\\&" {
			t.Errorf("got %q, want %q", got, "^~\\&")
		}
	})

	t.Run("MSHShortForField1", func(t *testing.T) {
		got := readFieldBytes([]byte("MSH"), d, 1)
		if got != nil {
			t.Errorf("got %q, want nil", got)
		}
	})

	t.Run("MSHShortForField2", func(t *testing.T) {
		got := readFieldBytes([]byte("MSH|"), d, 2)
		if got != nil {
			t.Errorf("got %q, want nil", got)
		}
	})

	t.Run("NormalFieldBeyondRange", func(t *testing.T) {
		got := readFieldBytes([]byte("PID|1||123"), d, 99)
		if got != nil {
			t.Errorf("got %q, want nil", got)
		}
	})
}

func TestReencodeDataEdgeCases(t *testing.T) {
	src := DefaultDelimiters()
	dst := Delimiters{Field: '#', Component: '@', Repetition: '!', Escape: '$', SubComponent: '%'}

	t.Run("UnclosedEscape", func(t *testing.T) {
		data := []byte("MSH|^~\\&|val\\oops")
		got := reencodeData(data, src, dst)
		// Unclosed escape is treated as literal; the backslash should be escaped if it collides with dst
		if len(got) == 0 {
			t.Error("expected non-empty output")
		}
	})

	t.Run("MultiByteEscapeBody", func(t *testing.T) {
		// Hex escape sequence \X41\ should be preserved with remapped escape char
		data := []byte("MSH|^~\\&|val\\X41\\end")
		got := reencodeData(data, src, dst)
		if !containsByte(got, '$') {
			t.Error("expected remapped escape character in output")
		}
	})

	t.Run("NonMSHData", func(t *testing.T) {
		data := []byte("PID|1||123")
		got := reencodeData(data, src, dst)
		// Should still reencode delimiters even without MSH header
		if !containsByte(got, '#') {
			t.Error("expected # as field separator")
		}
	})

	t.Run("SingleByteUnknownEscapeCode", func(t *testing.T) {
		data := []byte("MSH|^~\\&|\\Q\\val")
		got := reencodeData(data, src, dst)
		// Unknown single-byte escape \Q\ should be preserved with remapped escape
		if len(got) == 0 {
			t.Error("expected non-empty output")
		}
	})
}

func containsByte(data []byte, b byte) bool {
	for _, c := range data {
		if c == b {
			return true
		}
	}
	return false
}

func TestTransformMoveNonExistentSource(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	// ZZZ doesn't exist — move from non-existent segment.
	result, err := msg.Transform(Move("PID-5.1", "ZZZ-1"))
	if err != nil {
		t.Fatalf("Transform: %v", err)
	}
	// Destination gets nil/empty since source doesn't exist.
	if got := result.Get("PID-5.1").String(); got != "" {
		t.Errorf("PID-5.1 = %q, want empty", got)
	}
}

func TestTransformRepetitionLevel(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123~456||Doe^John")

	result, err := msg.Transform(Replace("PID-3[1].1", "789"))
	if err != nil {
		t.Fatalf("Transform: %v", err)
	}
	if got := result.Get("PID-3[0].1").String(); got != "123" {
		t.Errorf("PID-3[0].1 = %q, want 123", got)
	}
	if got := result.Get("PID-3[1].1").String(); got != "789" {
		t.Errorf("PID-3[1].1 = %q, want 789", got)
	}
}

func TestTransformWithInvalidMoveSource(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	_, err := msg.Transform(Move("PID-3", "invalid"))
	if !errors.Is(err, ErrInvalidLocation) {
		t.Errorf("expected ErrInvalidLocation, got %v", err)
	}
}

func TestTransformWithInvalidMoveDest(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	_, err := msg.Transform(Move("invalid", "PID-3"))
	if !errors.Is(err, ErrInvalidLocation) {
		t.Errorf("expected ErrInvalidLocation, got %v", err)
	}
}

func TestTransformNullInvalidLocation(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	_, err := msg.Transform(Null("invalid"))
	if !errors.Is(err, ErrInvalidLocation) {
		t.Errorf("expected ErrInvalidLocation, got %v", err)
	}
}

func TestTransformOmitInvalidLocation(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	_, err := msg.Transform(Omit("invalid"))
	if !errors.Is(err, ErrInvalidLocation) {
		t.Errorf("expected ErrInvalidLocation, got %v", err)
	}
}

func TestTransformCopy(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123^MRN||Doe^John")

	result, err := msg.Transform(Copy("PID-5.1", "PID-3.1"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Destination should have source value.
	if got := result.Get("PID-5.1").String(); got != "123" {
		t.Errorf("PID-5.1 (dst) = %q, want %q", got, "123")
	}
	// Source should be preserved (unlike Move).
	if got := result.Get("PID-3.1").String(); got != "123" {
		t.Errorf("PID-3.1 (src) = %q, want %q", got, "123")
	}
	// Other components at source should be preserved.
	if got := result.Get("PID-3.2").String(); got != "MRN" {
		t.Errorf("PID-3.2 = %q, want %q", got, "MRN")
	}
	// Other components at destination should be preserved.
	if got := result.Get("PID-5.2").String(); got != "John" {
		t.Errorf("PID-5.2 = %q, want %q", got, "John")
	}
}

func TestTransformCopyEmptySource(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	// PID-19 doesn't exist — copy empty value.
	result, err := msg.Transform(Copy("PID-5.1", "PID-19"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Destination gets the empty value.
	if got := result.Get("PID-5.1").String(); got != "" {
		t.Errorf("PID-5.1 = %q, want empty", got)
	}
}

func TestTransformCopyNonExistentSource(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	// ZZZ doesn't exist — copy from non-existent segment.
	result, err := msg.Transform(Copy("PID-5.1", "ZZZ-1"))
	if err != nil {
		t.Fatalf("Transform: %v", err)
	}
	// Destination gets nil/empty since source doesn't exist.
	if got := result.Get("PID-5.1").String(); got != "" {
		t.Errorf("PID-5.1 = %q, want empty", got)
	}
}

func TestTransformCopyFieldLevel(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	result, err := msg.Transform(Copy("PID-3", "PID-5"))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Destination has the copied value.
	if got := result.Get("PID-3").String(); got != "Doe^John" {
		t.Errorf("PID-3 = %q, want %q", got, "Doe^John")
	}
	// Source should be preserved.
	if got := result.Get("PID-5").String(); got != "Doe^John" {
		t.Errorf("PID-5 = %q, want %q", got, "Doe^John")
	}
}

func TestTransformCopyMSHDelimRejected(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")

	_, err := msg.Transform(Copy("MSH-1", "PID-3"))
	if !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("expected ErrMSHDelimiterField, got %v", err)
	}

	_, err = msg.Transform(Copy("PID-3", "MSH-2"))
	if !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("expected ErrMSHDelimiterField for src MSH-2, got %v", err)
	}
}

func TestTransformCopyInvalidLocation(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	_, err := msg.Transform(Copy("PID-3", "invalid"))
	if !errors.Is(err, ErrInvalidLocation) {
		t.Errorf("expected ErrInvalidLocation for src, got %v", err)
	}

	_, err = msg.Transform(Copy("invalid", "PID-3"))
	if !errors.Is(err, ErrInvalidLocation) {
		t.Errorf("expected ErrInvalidLocation for dst, got %v", err)
	}
}

func TestTransformMoveMSHDelimRejected(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")

	_, err := msg.Transform(Move("MSH-1", "PID-3"))
	if !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("expected ErrMSHDelimiterField, got %v", err)
	}

	_, err = msg.Transform(Move("PID-3", "MSH-2"))
	if !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("expected ErrMSHDelimiterField for src MSH-2, got %v", err)
	}
}

// segTypes returns the type of each segment in the message, in order.
func segTypes(msg *Message) []string {
	segs := msg.Segments()
	types := make([]string, len(segs))
	for i, s := range segs {
		types[i] = s.Type()
	}
	return types
}

func TestDeleteSegment(t *testing.T) {
	t.Run("MiddleSegment", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123\rNTE|1||Note\rOBX|1|NM|code||val")
		result, err := msg.Transform(DeleteSegment("NTE", 0))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "PID", "OBX"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
	})

	t.Run("NotFound_NoOp", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")
		result, err := msg.Transform(DeleteSegment("ZZZ", 0))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "PID"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
	})

	t.Run("DeleteMSH_Error", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")
		_, err := msg.Transform(DeleteSegment("MSH", 0))
		if !errors.Is(err, ErrCannotDeleteMSH) {
			t.Errorf("expected ErrCannotDeleteMSH, got %v", err)
		}
	})

	t.Run("FirstOfMultiple", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rNTE|1||First\rNTE|2||Second\rPID|1||123")
		result, err := msg.Transform(DeleteSegment("NTE", 0))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "NTE", "PID"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
		// Remaining NTE should be the second one.
		if got := result.Get("NTE-3").String(); got != "Second" {
			t.Errorf("NTE-3 = %q, want %q", got, "Second")
		}
	})

	t.Run("LastOfMultiple", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rNTE|1||First\rNTE|2||Second\rPID|1||123")
		result, err := msg.Transform(DeleteSegment("NTE", 1))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "NTE", "PID"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
		// Remaining NTE should be the first one.
		if got := result.Get("NTE-3").String(); got != "First" {
			t.Errorf("NTE-3 = %q, want %q", got, "First")
		}
	})

	t.Run("IndexOutOfRange_NoOp", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rNTE|1||Note")
		result, err := msg.Transform(DeleteSegment("NTE", 5))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		if len(got) != 2 {
			t.Errorf("segments = %v, want [MSH NTE]", got)
		}
	})
}

func TestDeleteAllSegments(t *testing.T) {
	t.Run("DeleteAllNTE", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123\rNTE|1||First\rNTE|2||Second\rNTE|3||Third\rOBX|1|NM|code||val")
		result, err := msg.Transform(DeleteAllSegments("NTE"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "PID", "OBX"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
	})

	t.Run("TypeNotPresent_NoOp", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")
		result, err := msg.Transform(DeleteAllSegments("ZZZ"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		if len(segTypes(result)) != 2 {
			t.Errorf("segments = %v, want [MSH PID]", segTypes(result))
		}
	})

	t.Run("DeleteMSH_Error", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")
		_, err := msg.Transform(DeleteAllSegments("MSH"))
		if !errors.Is(err, ErrCannotDeleteMSH) {
			t.Errorf("expected ErrCannotDeleteMSH, got %v", err)
		}
	})

	t.Run("NonTargetSegmentsUntouched", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123\rNTE|1||Note\rOBX|1|NM|code||42")
		result, err := msg.Transform(DeleteAllSegments("NTE"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		if got := result.Get("PID-3").String(); got != "123" {
			t.Errorf("PID-3 = %q, want %q", got, "123")
		}
		if got := result.Get("OBX-5").String(); got != "42" {
			t.Errorf("OBX-5 = %q, want %q", got, "42")
		}
	})
}

func TestInsertSegmentAfter(t *testing.T) {
	t.Run("AfterFirstPID", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123\rOBX|1|NM|code||val")
		result, err := msg.Transform(InsertSegmentAfter("PID", 0, "ZPD"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "PID", "ZPD", "OBX"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
	})

	t.Run("NotFound_Error", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")
		_, err := msg.Transform(InsertSegmentAfter("ZZZ", 0, "ZPD"))
		if !errors.Is(err, ErrSegmentNotFound) {
			t.Errorf("expected ErrSegmentNotFound, got %v", err)
		}
	})

	t.Run("LastOccurrence_NegativeIndex", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rOBX|1|NM|code||v1\rOBX|2|NM|code||v2\rPID|1||123")
		result, err := msg.Transform(InsertSegmentAfter("OBX", -1, "ZPD"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "OBX", "OBX", "ZPD", "PID"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
	})

	t.Run("ChainWithReplace", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")
		result, err := msg.Transform(
			InsertSegmentAfter("PID", 0, "ZPD"),
			Replace("ZPD-1", "42"),
		)
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		if got := result.Get("ZPD-1").String(); got != "42" {
			t.Errorf("ZPD-1 = %q, want %q", got, "42")
		}
	})

	t.Run("AfterLastSegment", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")
		result, err := msg.Transform(InsertSegmentAfter("PID", 0, "ZPD"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		if len(got) != 3 || got[2] != "ZPD" {
			t.Errorf("segments = %v, want [MSH PID ZPD]", got)
		}
	})
}

func TestInsertSegmentBefore(t *testing.T) {
	t.Run("BeforeFirstOBX", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123\rOBX|1|NM|code||val")
		result, err := msg.Transform(InsertSegmentBefore("OBX", 0, "ZPD"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "PID", "ZPD", "OBX"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
	})

	t.Run("NotFound_Error", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")
		_, err := msg.Transform(InsertSegmentBefore("ZZZ", 0, "ZPD"))
		if !errors.Is(err, ErrSegmentNotFound) {
			t.Errorf("expected ErrSegmentNotFound, got %v", err)
		}
	})

	t.Run("LastOccurrence_NegativeIndex", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rNTE|1||First\rNTE|2||Second\rOBX|1|NM|code||val")
		result, err := msg.Transform(InsertSegmentBefore("NTE", -1, "ZPD"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "NTE", "ZPD", "NTE", "OBX"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
	})

	t.Run("BeforeFirstSegment", func(t *testing.T) {
		// Inserting before MSH — MSH is at index 0, so new segment is at index 0.
		// But MSH must remain first for ParseMessage to succeed, so this inserts before MSH.
		// We test with a non-MSH segment instead to keep message valid.
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123\rOBX|1|NM|code||val")
		result, err := msg.Transform(InsertSegmentBefore("PID", 0, "ZPD"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "ZPD", "PID", "OBX"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
	})
}

func TestAppendSegment(t *testing.T) {
	t.Run("AppendsAfterLast", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123\rOBX|1|NM|code||val")
		result, err := msg.Transform(AppendSegment("ZPD"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "PID", "OBX", "ZPD"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
	})

	t.Run("MinimalMSHOnly", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")
		result, err := msg.Transform(AppendSegment("ZPD"))
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		if len(got) != 2 || got[1] != "ZPD" {
			t.Errorf("segments = %v, want [MSH ZPD]", got)
		}
	})

	t.Run("ChainWithFieldChanges", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")
		result, err := msg.Transform(
			AppendSegment("ZPD"),
			Replace("ZPD-3", "CustomValue"),
		)
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		if got := result.Get("ZPD-3").String(); got != "CustomValue" {
			t.Errorf("ZPD-3 = %q, want %q", got, "CustomValue")
		}
		got := segTypes(result)
		if len(got) != 3 || got[2] != "ZPD" {
			t.Errorf("segments = %v, want [MSH PID ZPD]", got)
		}
	})

	t.Run("MultipleAppends", func(t *testing.T) {
		msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")
		result, err := msg.Transform(
			AppendSegment("ZPD"),
			AppendSegment("ZAP"),
		)
		if err != nil {
			t.Fatalf("Transform failed: %v", err)
		}
		got := segTypes(result)
		want := []string{"MSH", "ZPD", "ZAP"}
		if len(got) != len(want) {
			t.Fatalf("segments = %v, want %v", got, want)
		}
		for i := range want {
			if got[i] != want[i] {
				t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
			}
		}
	})
}

func TestSegmentOpsWithFieldChanges(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")

	result, err := msg.Transform(
		InsertSegmentAfter("PID", 0, "ZPD"),
		Replace("ZPD-1", "InsertedValue"),
		Replace("PID-3", "456"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	got := segTypes(result)
	want := []string{"MSH", "PID", "ZPD"}
	if len(got) != len(want) {
		t.Fatalf("segments = %v, want %v", got, want)
	}
	for i := range want {
		if got[i] != want[i] {
			t.Errorf("segment[%d] = %q, want %q", i, got[i], want[i])
		}
	}

	if v := result.Get("ZPD-1").String(); v != "InsertedValue" {
		t.Errorf("ZPD-1 = %q, want %q", v, "InsertedValue")
	}
	if v := result.Get("PID-3").String(); v != "456" {
		t.Errorf("PID-3 = %q, want %q", v, "456")
	}
}

func TestSegmentOpsPreserveOriginal(t *testing.T) {
	raw := "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123\rNTE|1||Note"
	msg := parseTestMessage(t, raw)

	_, err := msg.Transform(
		DeleteSegment("NTE", 0),
		InsertSegmentAfter("PID", 0, "ZPD"),
		AppendSegment("ZAP"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Original must be unmodified.
	got := segTypes(msg)
	want := []string{"MSH", "PID", "NTE"}
	if len(got) != len(want) {
		t.Fatalf("original segments = %v, want %v", got, want)
	}
	for i := range want {
		if got[i] != want[i] {
			t.Errorf("original segment[%d] = %q, want %q", i, got[i], want[i])
		}
	}
}

func BenchmarkDeleteSegment(b *testing.B) {
	data, err := os.ReadFile(filepath.Join("testdata", "oru_r01.hl7"))
	if err != nil {
		b.Fatalf("failed to read test file: %v", err)
	}
	// Append an NTE segment to the ORU_R01 message for deletion testing.
	data = append(data, []byte("\rNTE|1||BenchmarkNote")...)

	msg, err := ParseMessage(data)
	if err != nil {
		b.Fatalf("ParseMessage failed: %v", err)
	}

	b.ResetTimer()
	b.ReportAllocs()
	for b.Loop() {
		_, _ = msg.Transform(DeleteSegment("NTE", 0))
	}
}

func BenchmarkDeleteAllSegments(b *testing.B) {
	// Build a message with 3 NTE segments.
	raw := "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123\r" +
		"NTE|1||First\rNTE|2||Second\rNTE|3||Third\rOBX|1|NM|code||val"

	msg, err := ParseMessage([]byte(raw))
	if err != nil {
		b.Fatalf("ParseMessage failed: %v", err)
	}

	b.ResetTimer()
	b.ReportAllocs()
	for b.Loop() {
		_, _ = msg.Transform(DeleteAllSegments("NTE"))
	}
}

func BenchmarkInsertSegmentAfter(b *testing.B) {
	data, err := os.ReadFile(filepath.Join("testdata", "oru_r01.hl7"))
	if err != nil {
		b.Fatalf("failed to read test file: %v", err)
	}

	msg, err := ParseMessage(data)
	if err != nil {
		b.Fatalf("ParseMessage failed: %v", err)
	}

	b.ResetTimer()
	b.ReportAllocs()
	for b.Loop() {
		_, _ = msg.Transform(InsertSegmentAfter("PID", 0, "ZPD"))
	}
}

func BenchmarkInsertSegmentBefore(b *testing.B) {
	data, err := os.ReadFile(filepath.Join("testdata", "oru_r01.hl7"))
	if err != nil {
		b.Fatalf("failed to read test file: %v", err)
	}

	msg, err := ParseMessage(data)
	if err != nil {
		b.Fatalf("ParseMessage failed: %v", err)
	}

	b.ResetTimer()
	b.ReportAllocs()
	for b.Loop() {
		_, _ = msg.Transform(InsertSegmentBefore("OBX", 0, "OBR"))
	}
}

func BenchmarkAppendSegment(b *testing.B) {
	data, err := os.ReadFile(filepath.Join("testdata", "oru_r01.hl7"))
	if err != nil {
		b.Fatalf("failed to read test file: %v", err)
	}

	msg, err := ParseMessage(data)
	if err != nil {
		b.Fatalf("ParseMessage failed: %v", err)
	}

	b.ResetTimer()
	b.ReportAllocs()
	for b.Loop() {
		_, _ = msg.Transform(AppendSegment("ZPD"))
	}
}

// --- MapAllValues tests ---

func TestMapAllValuesIdentity(t *testing.T) {
	raw := "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John||19800101"
	msg := parseTestMessage(t, raw)

	identity := func(v Value) ([]byte, error) { return v.Bytes(), nil }

	result, err := msg.Transform(MapAllValues(identity))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Delimiters unchanged.
	if result.Delimiters() != msg.Delimiters() {
		t.Errorf("delimiters changed: got %+v, want %+v", result.Delimiters(), msg.Delimiters())
	}
	// All sampled values unchanged.
	for _, loc := range []string{"PID-3", "PID-5.1", "PID-5.2", "PID-7", "MSH-9.1", "MSH-9.2"} {
		got := result.Get(loc).String()
		want := msg.Get(loc).String()
		if got != want {
			t.Errorf("identity: %s = %q, want %q", loc, got, want)
		}
	}
}

func TestMapAllValuesUppercase(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||doe^john")

	upper := func(v Value) ([]byte, error) { return bytes.ToUpper(v.Bytes()), nil }

	result, err := msg.Transform(MapAllValues(upper))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// PID-5 components uppercased.
	if got := result.Get("PID-5.1").String(); got != "DOE" {
		t.Errorf("PID-5.1 = %q, want %q", got, "DOE")
	}
	if got := result.Get("PID-5.2").String(); got != "JOHN" {
		t.Errorf("PID-5.2 = %q, want %q", got, "JOHN")
	}
	// Component separator preserved (not uppercased to something else).
	if result.Delimiters().Component != '^' {
		t.Errorf("component separator changed: %c", result.Delimiters().Component)
	}
	// PID-3 uppercased.
	if got := result.Get("PID-3").String(); got != "123" {
		t.Errorf("PID-3 = %q, want %q", got, "123") // digits: already "uppercase"
	}
	// MSH-9 components uppercased.
	if got := result.Get("MSH-9.1").String(); got != "ADT" {
		t.Errorf("MSH-9.1 = %q, want %q", got, "ADT")
	}
}

func TestMapAllValuesNull(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||\"\"|")

	callCount := 0
	capture := func(v Value) ([]byte, error) {
		callCount++
		return v.Bytes(), nil // pass through
	}

	result, err := msg.Transform(MapAllValues(capture))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}
	// Mapper should have been called, including for the null field (PID-3 = "").
	if callCount == 0 {
		t.Error("mapper was never called")
	}
	// PID-3 was null ("") — after identity mapper it should still be null.
	pid3 := result.Segments()[1].Field(3)
	if !pid3.IsNull() {
		t.Errorf("PID-3 should still be null, got %q", pid3.String())
	}
}

func TestMapAllValuesNullReplaced(t *testing.T) {
	// Mapper returns non-empty for a null ("") leaf — value should be stored.
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||\"\"")

	replaceNull := func(v Value) ([]byte, error) {
		if v.IsNull() {
			return []byte("REPLACED"), nil
		}
		return v.Bytes(), nil
	}

	result, err := msg.Transform(MapAllValues(replaceNull))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}
	if got := result.Get("PID-3").String(); got != "REPLACED" {
		t.Errorf("PID-3 = %q, want %q", got, "REPLACED")
	}
}

func TestMapAllValuesEmpty(t *testing.T) {
	// Mapper IS called with empty bytes; it can return a value.
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1|||5678")

	replaceEmpty := func(v Value) ([]byte, error) {
		if v.IsEmpty() {
			return []byte("FILLED"), nil
		}
		return v.Bytes(), nil
	}

	result, err := msg.Transform(MapAllValues(replaceEmpty))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}
	// PID-3 was empty — mapper returns "FILLED".
	if got := result.Get("PID-3").String(); got != "FILLED" {
		t.Errorf("PID-3 = %q, want %q", got, "FILLED")
	}
	// PID-4 was "5678" — mapper returns it unchanged.
	if got := result.Get("PID-4").String(); got != "5678" {
		t.Errorf("PID-4 = %q, want %q", got, "5678")
	}
}

func TestMapAllValuesMSHDelimFields(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")

	upper := func(v Value) ([]byte, error) { return bytes.ToUpper(v.Bytes()), nil }

	result, err := msg.Transform(MapAllValues(upper))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// MSH-1 and MSH-2 must never be modified.
	d := result.Delimiters()
	if d.Field != '|' {
		t.Errorf("MSH-1 (field sep) changed: %q", d.Field)
	}
	if got := result.Segments()[0].Field(2).Bytes(); string(got) != "^~\\&" {
		t.Errorf("MSH-2 changed: %q", got)
	}
}

func TestMapAllValuesSubcomponents(t *testing.T) {
	// Field a&b — mapper applied to each subcomponent ("a" and "b") independently.
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||a&b")


	upper := func(v Value) ([]byte, error) { return bytes.ToUpper(v.Bytes()), nil }

	result, err := msg.Transform(MapAllValues(upper))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Each subcomponent is independently uppercased; & separator is preserved.
	if got := result.Get("PID-3.1.1").String(); got != "A" {
		t.Errorf("PID-3.1.1 = %q, want %q", got, "A")
	}
	if got := result.Get("PID-3.1.2").String(); got != "B" {
		t.Errorf("PID-3.1.2 = %q, want %q", got, "B")
	}
}

func TestMapAllValuesSubcomponentsPartialChange(t *testing.T) {
	// Only the SECOND subcomponent changes: "A&b" → expected "A&B".
	// Exercises the lazy-init separator logic when i > 0 is the first change.
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||A&b")

	upper := func(v Value) ([]byte, error) { return bytes.ToUpper(v.Bytes()), nil }

	result, err := msg.Transform(MapAllValues(upper))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-3.1.1").String(); got != "A" {
		t.Errorf("PID-3.1.1 = %q, want %q", got, "A")
	}
	if got := result.Get("PID-3.1.2").String(); got != "B" {
		t.Errorf("PID-3.1.2 = %q, want %q", got, "B")
	}
}

func TestMapAllValuesRepetitions(t *testing.T) {
	// Field val1~val2 — mapper applied to each repetition independently.
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||rep1~rep2")

	upper := func(v Value) ([]byte, error) { return bytes.ToUpper(v.Bytes()), nil }

	result, err := msg.Transform(MapAllValues(upper))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-3[0]").String(); got != "REP1" {
		t.Errorf("PID-3[0] = %q, want %q", got, "REP1")
	}
	if got := result.Get("PID-3[1]").String(); got != "REP2" {
		t.Errorf("PID-3[1] = %q, want %q", got, "REP2")
	}
}

func TestMapAllValuesEscapeRoundTrip(t *testing.T) {
	// PID-3 contains \F\ (escaped field separator).
	// Mapper receives unescaped "|"; output is re-escaped before storage.
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||before\\F\\after")

	identity := func(v Value) ([]byte, error) { return v.Bytes(), nil }

	result, err := msg.Transform(MapAllValues(identity))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// String() should return the unescaped value unchanged.
	if got := result.Get("PID-3").String(); got != "before|after" {
		t.Errorf("PID-3 = %q, want %q", got, "before|after")
	}
	// Raw bytes should contain the re-escaped sequence.
	if raw := result.Get("PID-3").Raw(); !bytes.Contains(raw, []byte(`\F\`)) {
		t.Errorf("PID-3 raw %q should contain \\F\\", raw)
	}
}

func TestMapAllValuesError(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")

	sentinel := errors.New("mapper error")
	errMapper := func(v Value) ([]byte, error) {
		if v.HasValue() {
			return nil, sentinel
		}
		return v.Bytes(), nil
	}

	_, err := msg.Transform(MapAllValues(errMapper))
	if !errors.Is(err, sentinel) {
		t.Errorf("expected sentinel error, got %v", err)
	}
}

func TestMapAllValuesMixedChanges(t *testing.T) {
	// MapAllValues and Replace in the same Transform call.
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||doe^john")

	upper := func(v Value) ([]byte, error) { return bytes.ToUpper(v.Bytes()), nil }

	result, err := msg.Transform(
		MapAllValues(upper),
		Replace("PID-5.2", "Override"),
	)
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// MapAllValues ran first, uppercasing everything; then Replace overwrote PID-5.2.
	if got := result.Get("PID-5.1").String(); got != "DOE" {
		t.Errorf("PID-5.1 = %q, want %q", got, "DOE")
	}
	if got := result.Get("PID-5.2").String(); got != "Override" {
		t.Errorf("PID-5.2 = %q, want %q", got, "Override")
	}
}

func BenchmarkMapAllValues(b *testing.B) {
	data, err := os.ReadFile(filepath.Join("testdata", "oru_r01.hl7"))
	if err != nil {
		b.Fatalf("failed to read test file: %v", err)
	}

	msg, err := ParseMessage(data)
	if err != nil {
		b.Fatalf("ParseMessage failed: %v", err)
	}

	identity := func(v Value) ([]byte, error) { return v.Bytes(), nil }

	b.ResetTimer()
	b.ReportAllocs()
	for b.Loop() {
		_, _ = msg.Transform(MapAllValues(identity))
	}
}

// --- MapValue tests ---

func TestMapValue(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123||Doe^John")

	upper := func(v Value) ([]byte, error) { return bytes.ToUpper(v.Bytes()), nil }

	result, err := msg.Transform(MapValue("PID-5.1", upper))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	// Only PID-5.1 is modified.
	if got := result.Get("PID-5.1").String(); got != "DOE" {
		t.Errorf("PID-5.1 = %q, want %q", got, "DOE")
	}
	// PID-5.2 unchanged.
	if got := result.Get("PID-5.2").String(); got != "John" {
		t.Errorf("PID-5.2 = %q, want %q", got, "John")
	}
	// PID-3 unchanged.
	if got := result.Get("PID-3").String(); got != "123" {
		t.Errorf("PID-3 = %q, want %q", got, "123")
	}
}

func TestMapValueAbsentLocation(t *testing.T) {
	// PID-19 doesn't exist; mapper is called with nil; if it returns
	// non-nil, a new field should be created.
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")

	fill := func(v Value) ([]byte, error) {
		if v.IsEmpty() {
			return []byte("CREATED"), nil
		}
		return v.Bytes(), nil
	}

	result, err := msg.Transform(MapValue("PID-19", fill))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if got := result.Get("PID-19").String(); got != "CREATED" {
		t.Errorf("PID-19 = %q, want %q", got, "CREATED")
	}
}

func TestMapValueInvalidLocation(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	identity := func(v Value) ([]byte, error) { return v.Bytes(), nil }

	_, err := msg.Transform(MapValue("invalid", identity))
	if !errors.Is(err, ErrInvalidLocation) {
		t.Errorf("expected ErrInvalidLocation, got %v", err)
	}
}

func TestMapValueError(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||123")

	sentinel := errors.New("map error")
	errMapper := func(v Value) ([]byte, error) { return nil, sentinel }

	_, err := msg.Transform(MapValue("PID-3", errMapper))
	if !errors.Is(err, sentinel) {
		t.Errorf("expected sentinel error, got %v", err)
	}
}

func TestMapValueMSHDelimReject(t *testing.T) {
	msg := parseTestMessage(t, "MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")

	identity := func(v Value) ([]byte, error) { return v.Bytes(), nil }

	_, err := msg.Transform(MapValue("MSH-1", identity))
	if !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("expected ErrMSHDelimiterField for MSH-1, got %v", err)
	}

	_, err = msg.Transform(MapValue("MSH-2", identity))
	if !errors.Is(err, ErrMSHDelimiterField) {
		t.Errorf("expected ErrMSHDelimiterField for MSH-2, got %v", err)
	}
}

func BenchmarkMapValue(b *testing.B) {
	data, err := os.ReadFile(filepath.Join("testdata", "oru_r01.hl7"))
	if err != nil {
		b.Fatalf("failed to read test file: %v", err)
	}

	msg, err := ParseMessage(data)
	if err != nil {
		b.Fatalf("ParseMessage failed: %v", err)
	}

	upper := func(v Value) ([]byte, error) { return bytes.ToUpper(v.Bytes()), nil }

	b.ResetTimer()
	b.ReportAllocs()
	for b.Loop() {
		_, _ = msg.Transform(MapValue("PID-5.1", upper))
	}
}

func TestMapAllValuesLatin1ToUTF8(t *testing.T) {
	// The raw message contains Latin-1 bytes in several PID fields:
	//   \xFC = ü (PID-5.1 "Müller", PID-11.3 "München")
	//   \xE7 = ç (PID-5.2 "François")
	//   \xDF = ß (PID-11.1 "Straße 5")
	raw := "MSH|^~\\&|LAB|FAC|EMR|FAC2|20240101||ADT^A01|1|P|2.5.1\r" +
		"PID|1||123||M\xFCller^Fran\xE7ois^J||19800101|F|||Stra\xDFe 5^^M\xFCnchen"

	msg := parseTestMessage(t, raw)

	result, err := msg.Transform(MapAllValues(latin1ToUTF8))
	if err != nil {
		t.Fatalf("Transform(MapAllValues) failed: %v", err)
	}

	// Verify delimiters are unchanged.
	if result.Delimiters() != msg.Delimiters() {
		t.Errorf("delimiters changed: got %v, want %v", result.Delimiters(), msg.Delimiters())
	}

	cases := []struct {
		loc  string
		want string
	}{
		{"MSH-9.1", "ADT"},       // ASCII component — unchanged
		{"PID-3", "123"},         // ASCII field — unchanged
		{"PID-5.1", "Müller"},    // \xFC → ü
		{"PID-5.2", "François"},  // \xE7 → ç
		{"PID-5.3", "J"},         // ASCII component inside mixed-charset field — unchanged
		{"PID-7", "19800101"},    // ASCII date — unchanged
		{"PID-11.1", "Straße 5"}, // \xDF → ß; space is ASCII
		{"PID-11.3", "München"},  // \xFC → ü; PID-11.2 is empty
	}

	for _, tc := range cases {
		got := result.Get(tc.loc).String()
		if got != tc.want {
			t.Errorf("%s = %q, want %q", tc.loc, got, tc.want)
		}
	}
}

func TestMapAllValuesUTF16ToUTF8(t *testing.T) {
	// enc encodes a UTF-8 string as UTF-16 LE bytes (BMP only).
	enc := func(s string) string {
		b := make([]byte, 0, len(s)*2)
		for _, r := range s {
			b = append(b, byte(r), byte(r>>8))
		}
		return string(b)
	}

	// ALL field values are UTF-16 LE encoded so the strict mapper (which errors
	// on odd-length input) succeeds on every leaf including pure-ASCII fields.
	// Structural bytes (segment type, field/component separators, \r) remain ASCII.
	raw := "MSH|^~\\&|" + enc("LAB") + "|" + enc("FAC") + "|" + enc("EMR") + "|" +
		enc("FAC2") + "|" + enc("20240101") + "||" + enc("ADT") + "^" + enc("A01") +
		"|" + enc("1") + "|" + enc("P") + "|" + enc("2.5.1") + "\r" +
		"PID|" + enc("1") + "||" + enc("123") + "||" +
		enc("Müller") + "^" + enc("François") + "^" + enc("J") +
		"||" + enc("19800101") + "|" + enc("F") + "|||" +
		enc("Straße 5") + "^^" + enc("München")

	msg := parseTestMessage(t, raw)

	result, err := msg.Transform(MapAllValues(utf16LEToUTF8))
	if err != nil {
		t.Fatalf("Transform(MapAllValues) failed: %v", err)
	}

	if result.Delimiters() != msg.Delimiters() {
		t.Errorf("delimiters changed: got %v, want %v", result.Delimiters(), msg.Delimiters())
	}

	cases := []struct {
		loc  string
		want string
	}{
		{"MSH-9.1", "ADT"},       // pure-ASCII UTF-16 decoded correctly
		{"PID-3", "123"},         // pure-ASCII UTF-16 decoded correctly
		{"PID-5.1", "Müller"},    // \xFC\x00 → ü
		{"PID-5.2", "François"},  // \xE7\x00 → ç
		{"PID-5.3", "J"},         // ASCII inside multi-component field
		{"PID-7", "19800101"},    // date: pure-ASCII UTF-16
		{"PID-11.1", "Straße 5"}, // \xDF\x00 → ß; space and digit pass through
		{"PID-11.3", "München"},  // \xFC\x00 → ü; PID-11.2 is empty (^^ skips it)
	}

	for _, tc := range cases {
		got := result.Get(tc.loc).String()
		if got != tc.want {
			t.Errorf("%s = %q, want %q", tc.loc, got, tc.want)
		}
	}
}

func TestMapAllValuesNullPreservedStrictMapper(t *testing.T) {
	// utf16LEToUTF8 is a strict mapper that decodes every leaf as UTF-16 LE.
	// The HL7 null sentinel ("") is ASCII (0x22 0x22). A strict UTF-16 LE mapper
	// that does not guard against null will decode 0x22 0x22 as U+2222 (∢),
	// silently corrupting the null field. This test asserts that null is preserved.
	enc := func(s string) string {
		b := make([]byte, 0, len(s)*2)
		for _, r := range s {
			b = append(b, byte(r), byte(r>>8))
		}
		return string(b)
	}

	raw := "MSH|^~\\&|" + enc("LAB") + "|" + enc("FAC") + "\r" +
		"PID|" + enc("1") + "||\"\"||" + enc("Smith")

	msg := parseTestMessage(t, raw)

	result, err := msg.Transform(MapAllValues(utf16LEToUTF8))
	if err != nil {
		t.Fatalf("Transform(MapAllValues) failed: %v", err)
	}

	if !result.Segments()[1].Field(3).IsNull() {
		t.Errorf("PID-3 should be null after MapAllValues(utf16LEToUTF8), got %q",
			result.Get("PID-3").String())
	}
}

func TestMapAllValuesNullCombinedWithNullChange(t *testing.T) {
	// Null("PID-3") writes "" into PID-3; MapAllValues(utf16LEToUTF8) runs next.
	// A mapper without a null guard would decode "" (0x22 0x22) as U+2222, corrupting
	// the explicit null that was just written. This test asserts the null survives.
	enc := func(s string) string {
		b := make([]byte, 0, len(s)*2)
		for _, r := range s {
			b = append(b, byte(r), byte(r>>8))
		}
		return string(b)
	}

	raw := "MSH|^~\\&|" + enc("LAB") + "|" + enc("FAC") + "\r" +
		"PID|" + enc("1") + "||" + enc("123") + "||" + enc("Smith")

	msg := parseTestMessage(t, raw)

	result, err := msg.Transform(Null("PID-3"), MapAllValues(utf16LEToUTF8))
	if err != nil {
		t.Fatalf("Transform failed: %v", err)
	}

	if !result.Segments()[1].Field(3).IsNull() {
		t.Errorf("PID-3 should be null after Null+MapAllValues, got %q",
			result.Get("PID-3").String())
	}
}