batch_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 (
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

func TestParseBatch(t *testing.T) {
	t.Run("simple batch", func(t *testing.T) {
		data := []byte("BHS|^~\\&|SEND|FAC|REC|RFAC|20240101\rMSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||111\rMSH|^~\\&|S|F|R|RF|20240101||ADT^A08|2|P|2.5.1\rPID|1||222\rBTS|2")
		batch, err := ParseBatch(data)
		if err != nil {
			t.Fatalf("ParseBatch failed: %v", err)
		}
		if batch.Header == nil {
			t.Error("expected BHS header")
		}
		if batch.Trailer == nil {
			t.Error("expected BTS trailer")
		}
		if len(batch.Messages) != 2 {
			t.Fatalf("expected 2 messages, got %d", len(batch.Messages))
		}
		if got := batch.Messages[0].Get("MSH-10").String(); got != "1" {
			t.Errorf("msg1 MSH-10 = %q, want 1", got)
		}
		if got := batch.Messages[1].Get("MSH-10").String(); got != "2" {
			t.Errorf("msg2 MSH-10 = %q, want 2", got)
		}
	})

	t.Run("batch without header/trailer", func(t *testing.T) {
		data := []byte("MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||111\rMSH|^~\\&|S|F|R|RF|20240101||ADT^A08|2|P|2.5.1\rPID|1||222")
		batch, err := ParseBatch(data)
		if err != nil {
			t.Fatalf("ParseBatch failed: %v", err)
		}
		if batch.Header != nil {
			t.Error("expected nil BHS header")
		}
		if batch.Trailer != nil {
			t.Error("expected nil BTS trailer")
		}
		if len(batch.Messages) != 2 {
			t.Fatalf("expected 2 messages, got %d", len(batch.Messages))
		}
	})

	t.Run("single message batch", func(t *testing.T) {
		data := []byte("MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1")
		batch, err := ParseBatch(data)
		if err != nil {
			t.Fatalf("ParseBatch failed: %v", err)
		}
		if len(batch.Messages) != 1 {
			t.Fatalf("expected 1 message, got %d", len(batch.Messages))
		}
	})
}

func TestParseFile(t *testing.T) {
	t.Run("file with batch", func(t *testing.T) {
		data := []byte("FHS|^~\\&|SEND|FAC|REC|RFAC|20240101\rBHS|^~\\&|SEND|FAC|REC|RFAC|20240101\rMSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||111\rBTS|1\rFTS|1")
		file, err := ParseFile(data)
		if err != nil {
			t.Fatalf("ParseFile failed: %v", err)
		}
		if file.Header == nil {
			t.Error("expected FHS header")
		}
		if file.Trailer == nil {
			t.Error("expected FTS trailer")
		}
		if len(file.Batches) != 1 {
			t.Fatalf("expected 1 batch, got %d", len(file.Batches))
		}
		if len(file.Batches[0].Messages) != 1 {
			t.Fatalf("expected 1 message in batch, got %d", len(file.Batches[0].Messages))
		}
	})

	t.Run("file with multiple batches", func(t *testing.T) {
		data := []byte("FHS|^~\\&|S|F|R|RF|20240101\rBHS|^~\\&|S|F|R|RF|20240101\rMSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rBTS|1\rBHS|^~\\&|S|F|R|RF|20240101\rMSH|^~\\&|S|F|R|RF|20240101||ADT^A08|2|P|2.5.1\rBTS|1\rFTS|2")
		file, err := ParseFile(data)
		if err != nil {
			t.Fatalf("ParseFile failed: %v", err)
		}
		if len(file.Batches) != 2 {
			t.Fatalf("expected 2 batches, got %d", len(file.Batches))
		}
	})

	t.Run("golden batch file", func(t *testing.T) {
		data, err := os.ReadFile(filepath.Join("testdata", "batch.hl7"))
		if err != nil {
			t.Fatalf("failed to read test file: %v", err)
		}
		file, err := ParseFile(data)
		if err != nil {
			t.Fatalf("ParseFile failed: %v", err)
		}
		if file.Header == nil {
			t.Error("expected FHS header")
		}
		if file.Trailer == nil {
			t.Error("expected FTS trailer")
		}
		if len(file.Batches) != 1 {
			t.Fatalf("expected 1 batch, got %d", len(file.Batches))
		}
		batch := file.Batches[0]
		if batch.Header == nil {
			t.Error("expected BHS header in batch")
		}
		if batch.Trailer == nil {
			t.Error("expected BTS trailer in batch")
		}
		if len(batch.Messages) != 2 {
			t.Fatalf("expected 2 messages in batch, got %d", len(batch.Messages))
		}
		if got := batch.Messages[0].Get("PID-5.1").String(); got != "Alpha" {
			t.Errorf("msg1 PID-5.1 = %q, want Alpha", got)
		}
		if got := batch.Messages[1].Get("PID-5.1").String(); got != "Beta" {
			t.Errorf("msg2 PID-5.1 = %q, want Beta", got)
		}
	})
}

func TestParseFileImplicitBatch(t *testing.T) {
	// Messages without BHS/BTS wrappers should be placed in an implicit batch.
	data := []byte("FHS|^~\\&|S|F|R|RF|20240101\rMSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rFTS|1")
	file, err := ParseFile(data)
	if err != nil {
		t.Fatalf("ParseFile failed: %v", err)
	}
	if len(file.Batches) != 1 {
		t.Fatalf("expected 1 implicit batch, got %d", len(file.Batches))
	}
	if file.Batches[0].Header != nil {
		t.Error("implicit batch should have nil header")
	}
}

func TestSegmentTypeEdgeCases(t *testing.T) {
	if got := segmentType([]byte("AB")); got != "" {
		t.Errorf("segmentType(AB) = %q, want empty", got)
	}
	if got := segmentType([]byte("")); got != "" {
		t.Errorf("segmentType(empty) = %q, want empty", got)
	}
	if got := segmentType([]byte("MSH|data")); got != "MSH" {
		t.Errorf("segmentType(MSH|data) = %q, want MSH", got)
	}
}

func TestExtractHeaderDelimitersEdgeCases(t *testing.T) {
	t.Run("NonHeaderSegment", func(t *testing.T) {
		got, err := extractHeaderDelimiters([]byte("PID|^~\\&|data"))
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		if got != DefaultDelimiters() {
			t.Errorf("expected DefaultDelimiters for non-header segment, got %+v", got)
		}
	})

	t.Run("TooShort", func(t *testing.T) {
		_, err := extractHeaderDelimiters([]byte("BHS|^~"))
		if err != ErrInvalidMSH {
			t.Errorf("expected ErrInvalidMSH, got %v", err)
		}
	})

	t.Run("InvalidDelimiters", func(t *testing.T) {
		// Duplicate delimiters — should fall back to default.
		got, err := extractHeaderDelimiters([]byte("BHS||~\\&|data"))
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		if got != DefaultDelimiters() {
			t.Errorf("expected DefaultDelimiters on invalid, got %+v", got)
		}
	})

	t.Run("FHSSegment", func(t *testing.T) {
		got, err := extractHeaderDelimiters([]byte("FHS|^~\\&|data"))
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		if got != DefaultDelimiters() {
			t.Errorf("expected DefaultDelimiters, got %+v", got)
		}
	})

	t.Run("BHSCustomDelimiters", func(t *testing.T) {
		got, err := extractHeaderDelimiters([]byte("BHS#@!$%data"))
		if err != nil {
			t.Fatalf("unexpected error: %v", err)
		}
		want := Delimiters{Field: '#', Component: '@', Repetition: '!', Escape: '$', SubComponent: '%'}
		if got != want {
			t.Errorf("got %+v, want %+v", got, want)
		}
	})
}

func TestParseBatchEmpty(t *testing.T) {
	_, err := ParseBatch([]byte(""))
	if err != ErrMessageTooShort {
		t.Errorf("expected ErrMessageTooShort, got %v", err)
	}
}

func TestParseFileEmpty(t *testing.T) {
	_, err := ParseFile([]byte(""))
	if err != ErrMessageTooShort {
		t.Errorf("expected ErrMessageTooShort, got %v", err)
	}
}

func TestParseBatchMalformedMSH(t *testing.T) {
	// First MSH is valid, second is malformed (too short).
	data := []byte("MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||111\rMSH|bad\rMSH|^~\\&|S|F|R|RF|20240102||ADT^A08|2|P|2.5.1\rPID|1||222")
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	// Malformed MSH should be skipped; we should get 2 valid messages.
	if len(batch.Messages) != 2 {
		t.Errorf("expected 2 messages, got %d", len(batch.Messages))
	}
}

func TestParseFileBTSWithoutBHS(t *testing.T) {
	data := []byte("FHS|^~\\&|S|F|R|RF|20240101\rMSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rBTS|1\rFTS|1")
	file, err := ParseFile(data)
	if err != nil {
		t.Fatalf("ParseFile: %v", err)
	}
	// Should still parse — BTS flushes an implicit batch.
	if len(file.Batches) < 1 {
		t.Error("expected at least 1 batch")
	}
}

func TestParseFileMultipleImplicitBatches(t *testing.T) {
	data := []byte("MSH|^~\\&|S|F|R|RF|20240101||ADT^A01|1|P|2.5.1\rPID|1||111\rMSH|^~\\&|S|F|R|RF|20240102||ADT^A08|2|P|2.5.1\rPID|1||222")
	file, err := ParseFile(data)
	if err != nil {
		t.Fatalf("ParseFile: %v", err)
	}
	// Both messages end up in one implicit batch.
	if len(file.Batches) != 1 {
		t.Fatalf("expected 1 batch, got %d", len(file.Batches))
	}
	if len(file.Batches[0].Messages) != 2 {
		t.Errorf("expected 2 messages in batch, got %d", len(file.Batches[0].Messages))
	}
}

func TestSplitLinesEdgeCases(t *testing.T) {
	t.Run("CRLF", func(t *testing.T) {
		lines := splitLines([]byte("line1\r\nline2\r\nline3"))
		if len(lines) != 3 {
			t.Errorf("expected 3 lines, got %d", len(lines))
		}
	})

	t.Run("MixedEndings", func(t *testing.T) {
		lines := splitLines([]byte("line1\rline2\nline3\r\nline4"))
		if len(lines) != 4 {
			t.Errorf("expected 4 lines, got %d", len(lines))
		}
	})

	t.Run("EmptyInput", func(t *testing.T) {
		lines := splitLines([]byte(""))
		if len(lines) != 0 {
			t.Errorf("expected 0 lines, got %d", len(lines))
		}
	})

	t.Run("OnlyNewlines", func(t *testing.T) {
		lines := splitLines([]byte("\r\n\r\n"))
		if len(lines) != 0 {
			t.Errorf("expected 0 lines, got %d", len(lines))
		}
	})
}

func TestJoinLinesEdgeCases(t *testing.T) {
	t.Run("Empty", func(t *testing.T) {
		got := joinLines(nil)
		if got != nil {
			t.Errorf("expected nil, got %q", got)
		}
	})

	t.Run("Single", func(t *testing.T) {
		got := joinLines([][]byte{[]byte("MSH")})
		if string(got) != "MSH" {
			t.Errorf("got %q, want MSH", got)
		}
	})

	t.Run("Multiple", func(t *testing.T) {
		got := joinLines([][]byte{[]byte("MSH"), []byte("PID")})
		if string(got) != "MSH\rPID" {
			t.Errorf("got %q, want MSH\\rPID", got)
		}
	})
}

func TestParseBatchBodyEmpty(t *testing.T) {
	// BHS and BTS present but no messages between them.
	data := []byte("BHS|^~\\&|S|F|R|RF|20240101\rBTS|0")
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if batch.Header == nil {
		t.Error("expected non-nil BHS header")
	}
	if batch.Trailer == nil {
		t.Error("expected non-nil BTS trailer")
	}
	if len(batch.Messages) != 0 {
		t.Errorf("expected 0 messages, got %d", len(batch.Messages))
	}
}

func TestParseBatchNonMSHOnlyLines(t *testing.T) {
	// No MSH, no BHS/BTS — only ZZZ segments.
	data := []byte("ZZZ|some|data\rZZZ|more|data")
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if len(batch.Messages) != 0 {
		t.Errorf("expected 0 messages, got %d", len(batch.Messages))
	}
}

func TestParseFileBTSNoBatch(t *testing.T) {
	// BTS before any BHS: flushBatch is a no-op since no current batch.
	data := []byte("FHS|^~\\&|S|F|R|RF|20240101\rBTS|0\rFTS|1")
	file, err := ParseFile(data)
	if err != nil {
		t.Fatalf("ParseFile: %v", err)
	}
	if len(file.Batches) != 0 {
		t.Errorf("expected 0 batches, got %d", len(file.Batches))
	}
}

func TestParseBatchCustomDelimiters(t *testing.T) {
	data := []byte("BHS#@!$%SEND#FAC#REC#RFAC#20240101\rMSH#@!$%S#F#R#RF#20240101##ADT@A01#1#P#2.5.1\rPID#1##123\rBTS#1")
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if batch.Header == nil {
		t.Error("expected BHS header")
	}
	if len(batch.Messages) != 1 {
		t.Fatalf("expected 1 message, got %d", len(batch.Messages))
	}
}

// --- BatchBuilder tests ---

func TestBatchBuilderEmpty(t *testing.T) {
	bb := NewBatchBuilder()
	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if batch.Header == nil {
		t.Error("expected BHS header")
	}
	if batch.Trailer == nil {
		t.Error("expected BTS trailer")
	}
	if len(batch.Messages) != 0 {
		t.Errorf("expected 0 messages, got %d", len(batch.Messages))
	}
	// BTS-1 should be "0"
	if got := batch.Trailer.Field(1).String(); got != "0" {
		t.Errorf("BTS-1 = %q, want 0", got)
	}
}

func TestBatchBuilderSingleMessage(t *testing.T) {
	msg, err := ParseMessage([]byte("MSH|^~\\&|APP|FAC|||20240101||ADT^A01|001|P|2.5.1\rPID|1||123"))
	if err != nil {
		t.Fatalf("ParseMessage: %v", err)
	}
	bb := NewBatchBuilder()
	bb.Add(msg)
	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if len(batch.Messages) != 1 {
		t.Fatalf("expected 1 message, got %d", len(batch.Messages))
	}
	if got := batch.Messages[0].Get("MSH-10").String(); got != "001" {
		t.Errorf("MSH-10 = %q, want 001", got)
	}
	if got := batch.Trailer.Field(1).String(); got != "1" {
		t.Errorf("BTS-1 = %q, want 1", got)
	}
}

func TestBatchBuilderMultipleMessages(t *testing.T) {
	msg1, _ := ParseMessage([]byte("MSH|^~\\&|APP|FAC|||20240101||ADT^A01|001|P|2.5.1"))
	msg2, _ := ParseMessage([]byte("MSH|^~\\&|APP|FAC|||20240102||ADT^A08|002|P|2.5.1"))
	msg3, _ := ParseMessage([]byte("MSH|^~\\&|APP|FAC|||20240103||ADT^A03|003|P|2.5.1"))

	bb := NewBatchBuilder()
	bb.Add(msg1).Add(msg2).Add(msg3)
	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if len(batch.Messages) != 3 {
		t.Fatalf("expected 3 messages, got %d", len(batch.Messages))
	}
	if got := batch.Trailer.Field(1).String(); got != "3" {
		t.Errorf("BTS-1 = %q, want 3", got)
	}
	// Verify message identity
	for i, want := range []string{"001", "002", "003"} {
		if got := batch.Messages[i].Get("MSH-10").String(); got != want {
			t.Errorf("msg%d MSH-10 = %q, want %q", i+1, got, want)
		}
	}
}

func TestBatchBuilderCustomHeaderFields(t *testing.T) {
	bb := NewBatchBuilder()
	bb.SetHeader(3, "SENDAPP")
	bb.SetHeader(4, "SENDFAC")
	bb.SetHeader(5, "RECVAPP")
	bb.SetHeader(6, "RECVFAC")
	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if batch.Header == nil {
		t.Fatal("expected BHS header")
	}
	// BHS uses MSH-style numbering: Field(3) = BHS-3
	if got := batch.Header.Field(3).String(); got != "SENDAPP" {
		t.Errorf("BHS-3 = %q, want SENDAPP", got)
	}
	if got := batch.Header.Field(4).String(); got != "SENDFAC" {
		t.Errorf("BHS-4 = %q, want SENDFAC", got)
	}
	if got := batch.Header.Field(5).String(); got != "RECVAPP" {
		t.Errorf("BHS-5 = %q, want RECVAPP", got)
	}
	if got := batch.Header.Field(6).String(); got != "RECVFAC" {
		t.Errorf("BHS-6 = %q, want RECVFAC", got)
	}
}

func TestBatchBuilderResetAndRebuild(t *testing.T) {
	msg1, _ := ParseMessage([]byte("MSH|^~\\&|APP|FAC|||20240101||ADT^A01|001|P|2.5.1"))
	msg2, _ := ParseMessage([]byte("MSH|^~\\&|APP|FAC|||20240102||ADT^A08|002|P|2.5.1"))

	bb := NewBatchBuilder()
	bb.SetHeader(3, "MYAPP")
	bb.Add(msg1).Add(msg2)

	data1, err := bb.Build()
	if err != nil {
		t.Fatalf("Build (first): %v", err)
	}
	batch1, err := ParseBatch(data1)
	if err != nil {
		t.Fatalf("ParseBatch (first): %v", err)
	}
	if len(batch1.Messages) != 2 {
		t.Fatalf("first build: expected 2 messages, got %d", len(batch1.Messages))
	}

	// Reset clears messages but keeps header fields
	bb.Reset()
	bb.Add(msg2)

	data2, err := bb.Build()
	if err != nil {
		t.Fatalf("Build (second): %v", err)
	}
	batch2, err := ParseBatch(data2)
	if err != nil {
		t.Fatalf("ParseBatch (second): %v", err)
	}
	if len(batch2.Messages) != 1 {
		t.Fatalf("second build: expected 1 message, got %d", len(batch2.Messages))
	}
	if got := batch2.Messages[0].Get("MSH-10").String(); got != "002" {
		t.Errorf("second build: MSH-10 = %q, want 002", got)
	}
	// Header field should be preserved
	if batch2.Header == nil {
		t.Fatal("second build: expected BHS header")
	}
	if got := batch2.Header.Field(3).String(); got != "MYAPP" {
		t.Errorf("second build: BHS-3 = %q, want MYAPP (header not preserved)", got)
	}
}

func TestBatchBuilderRoundTrip(t *testing.T) {
	msg1, _ := ParseMessage([]byte("MSH|^~\\&|APP1|FAC1|REC1|RFAC1|20240115160001||ADT^A08|MSG001|P|2.5.1\rPID|1||111^^^MRN||Smith^John"))
	msg2, _ := ParseMessage([]byte("MSH|^~\\&|APP1|FAC1|REC1|RFAC1|20240115160002||ADT^A08|MSG002|P|2.5.1\rPID|1||222^^^MRN||Doe^Jane"))

	bb := NewBatchBuilder()
	bb.SetHeader(3, "APP1")
	bb.SetHeader(4, "FAC1")
	bb.SetHeader(7, "20240115160000")
	bb.Add(msg1).Add(msg2)

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

	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch round-trip: %v", err)
	}
	if batch.Header == nil {
		t.Fatal("expected BHS header")
	}
	if batch.Trailer == nil {
		t.Fatal("expected BTS trailer")
	}
	if len(batch.Messages) != 2 {
		t.Fatalf("expected 2 messages, got %d", len(batch.Messages))
	}
	if got := batch.Header.Field(3).String(); got != "APP1" {
		t.Errorf("BHS-3 = %q, want APP1", got)
	}
	if got := batch.Header.Field(7).String(); got != "20240115160000" {
		t.Errorf("BHS-7 = %q, want 20240115160000", got)
	}
	if got := batch.Messages[0].Get("PID-5.1").String(); got != "Smith" {
		t.Errorf("msg1 PID-5.1 = %q, want Smith", got)
	}
	if got := batch.Messages[1].Get("PID-5.1").String(); got != "Doe" {
		t.Errorf("msg2 PID-5.1 = %q, want Doe", got)
	}
	if got := batch.Trailer.Field(1).String(); got != "2" {
		t.Errorf("BTS-1 = %q, want 2", got)
	}
}

func TestBatchBuilderWithBatchDelimiters(t *testing.T) {
	d := Delimiters{Field: '#', Component: '@', Repetition: '!', Escape: '$', SubComponent: '%'}
	bb := NewBatchBuilder(WithBatchDelimiters(d))
	bb.SetHeader(3, "APP")
	// Build with a standard-delimiter message
	msg, _ := ParseMessage([]byte("MSH|^~\\&|APP|FAC|||20240101||ADT^A01|001|P|2.5.1"))
	bb.Add(msg)

	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	// Verify BHS uses custom delimiters
	if !strings.HasPrefix(string(data), "BHS#@!$%") {
		t.Errorf("BHS does not start with expected delimiter encoding: %q", string(data[:12]))
	}
}

func TestBatchBuilderBHS7DefaultDatetime(t *testing.T) {
	before := time.Now().Format("20060102150405")
	bb := NewBatchBuilder()
	data, err := bb.Build()
	after := time.Now().Format("20060102150405")
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if batch.Header == nil {
		t.Fatal("expected BHS header")
	}
	got := batch.Header.Field(7).String()
	if got < before || got > after {
		t.Errorf("BHS-7 = %q, want between %q and %q", got, before, after)
	}
}

func TestBatchBuilderBHS7Explicit(t *testing.T) {
	bb := NewBatchBuilder()
	bb.SetHeader(7, "20240601120000")
	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if got := batch.Header.Field(7).String(); got != "20240601120000" {
		t.Errorf("BHS-7 = %q, want 20240601120000", got)
	}
}

func TestBatchBuilderSetHeaderEscaping(t *testing.T) {
	// Value containing field separator should be escaped
	bb := NewBatchBuilder()
	bb.SetHeader(3, "APP|NAME") // | is the field separator
	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	// Parsing should recover the original value via unescape
	if got := batch.Header.Field(3).String(); got != "APP|NAME" {
		t.Errorf("BHS-3 = %q, want APP|NAME", got)
	}
}

func TestBatchBuilderSetHeaderHighField(t *testing.T) {
	// Set a field beyond BHS-7 to test variable-length header
	bb := NewBatchBuilder()
	bb.SetHeader(11, "BATCHCTRL001")
	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if batch.Header == nil {
		t.Fatal("expected BHS header")
	}
	if got := batch.Header.Field(11).String(); got != "BATCHCTRL001" {
		t.Errorf("BHS-11 = %q, want BATCHCTRL001", got)
	}
}

func TestBatchBuilderInvalidDelimiters(t *testing.T) {
	// Duplicate delimiters should cause Build to return an error
	d := Delimiters{Field: '|', Component: '|', Repetition: '~', Escape: '\\', SubComponent: '&'}
	bb := NewBatchBuilder(WithBatchDelimiters(d))
	_, err := bb.Build()
	if err == nil {
		t.Error("expected error for invalid delimiters, got nil")
	}
}

func TestBatchBuilderBuildIsReusable(t *testing.T) {
	msg, _ := ParseMessage([]byte("MSH|^~\\&|APP|FAC|||20240101||ADT^A01|001|P|2.5.1"))
	bb := NewBatchBuilder()
	bb.Add(msg)

	// Build twice without Reset — should produce identical results
	data1, err := bb.Build()
	if err != nil {
		t.Fatalf("first Build: %v", err)
	}
	data2, err := bb.Build()
	if err != nil {
		t.Fatalf("second Build: %v", err)
	}
	// BTS-1 should still be 1 in both
	batch1, _ := ParseBatch(data1)
	batch2, _ := ParseBatch(data2)
	if got := batch1.Trailer.Field(1).String(); got != "1" {
		t.Errorf("first build BTS-1 = %q, want 1", got)
	}
	if got := batch2.Trailer.Field(1).String(); got != "1" {
		t.Errorf("second build BTS-1 = %q, want 1", got)
	}
}

func TestBatchBuilderSetHeaderReservedFieldNums(t *testing.T) {
	// SetHeader with keys 0, 1, 2 are silently ignored by Build() (loop starts at i=3).
	bb := NewBatchBuilder()
	bb.SetHeader(0, "ZERO")
	bb.SetHeader(1, "SEP")
	bb.SetHeader(2, "ENC")
	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if batch.Header == nil {
		t.Fatal("expected BHS header")
	}
	// Field(1) must still be the literal field separator.
	if got := batch.Header.Field(1).String(); got != "|" {
		t.Errorf("BHS-1 = %q, want |", got)
	}
	// Field(2) must still be the encoding chars.
	if got := batch.Header.Field(2).String(); got != "^~\\&" {
		t.Errorf("BHS-2 = %q, want ^~\\&", got)
	}
	// Field(3) must be empty — "ZERO" should not have leaked in.
	if got := batch.Header.Field(3); !got.IsEmpty() {
		t.Errorf("BHS-3 = %q, want empty (reserved field 0 must not bleed through)", got.String())
	}
}

func TestBatchBuilderMessageWithoutTrailingCR(t *testing.T) {
	// ParseMessage never appends a trailing \r. Build() detects this and adds one.
	raw := []byte("MSH|^~\\&|APP|FAC|||20240101||ADT^A01|001|P|2.5.1")
	msg, err := ParseMessage(raw)
	if err != nil {
		t.Fatalf("ParseMessage: %v", err)
	}
	// Confirm the precondition: no trailing \r.
	msgRaw := msg.Raw()
	if len(msgRaw) > 0 && msgRaw[len(msgRaw)-1] == '\r' {
		t.Skip("message unexpectedly ends with \\r; precondition not met")
	}

	bb := NewBatchBuilder()
	bb.Add(msg)
	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch round-trip: %v", err)
	}
	if len(batch.Messages) != 1 {
		t.Fatalf("expected 1 message, got %d", len(batch.Messages))
	}
	if got := batch.Messages[0].Get("MSH-10").String(); got != "001" {
		t.Errorf("MSH-10 = %q, want 001", got)
	}
}

func TestBatchBuilderSetHeaderEmptyValue(t *testing.T) {
	// Empty string stored and passed through Escape fast-path; BHS-3 should be empty.
	bb := NewBatchBuilder()
	bb.SetHeader(3, "")
	data, err := bb.Build()
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if batch.Header == nil {
		t.Fatal("expected BHS header")
	}
	if got := batch.Header.Field(3); !got.IsEmpty() {
		t.Errorf("BHS-3 = %q, want empty", got.String())
	}
}

func TestBatchBuilderBHS7RefreshAfterReset(t *testing.T) {
	// After Reset(), Build() calls time.Now() again, so BHS-7 is never stale.
	bb := NewBatchBuilder()
	before := time.Now().Format("20060102150405")
	bb.Reset()
	data, err := bb.Build()
	after := time.Now().Format("20060102150405")
	if err != nil {
		t.Fatalf("Build: %v", err)
	}
	batch, err := ParseBatch(data)
	if err != nil {
		t.Fatalf("ParseBatch: %v", err)
	}
	if batch.Header == nil {
		t.Fatal("expected BHS header")
	}
	got := batch.Header.Field(7).String()
	if got < before || got > after {
		t.Errorf("BHS-7 = %q after Reset, want between %q and %q", got, before, after)
	}
}

func BenchmarkBatchBuilder1Message(b *testing.B) {
	msg, _ := ParseMessage([]byte("MSH|^~\\&|APP|FAC|REC|RFAC|20240101||ADT^A01|001|P|2.5.1\rPID|1||123^^^MRN||Smith^John|||M"))
	bb := NewBatchBuilder()
	bb.SetHeader(3, "APP")
	bb.SetHeader(4, "FAC")
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bb.Reset()
		bb.Add(msg)
		_, _ = bb.Build()
	}
}

func BenchmarkBatchBuilder10Messages(b *testing.B) {
	msgs := make([]*Message, 10)
	for i := range msgs {
		msgs[i], _ = ParseMessage([]byte("MSH|^~\\&|APP|FAC|REC|RFAC|20240101||ADT^A01|001|P|2.5.1\rPID|1||123^^^MRN||Smith^John|||M"))
	}
	bb := NewBatchBuilder()
	bb.SetHeader(3, "APP")
	bb.SetHeader(4, "FAC")
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bb.Reset()
		for _, msg := range msgs {
			bb.Add(msg)
		}
		_, _ = bb.Build()
	}
}