batch.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"
	"strconv"
	"time"
)

// Batch represents an HL7 batch (BHS...BTS) containing one or more messages.
type Batch struct {
	Header   *Segment   // BHS segment, may be nil if absent
	Trailer  *Segment   // BTS segment, may be nil if absent
	Messages []*Message // Messages within the batch
}

// File represents an HL7 file (FHS...FTS) containing one or more batches.
type File struct {
	Header  *Segment // FHS segment, may be nil if absent
	Trailer *Segment // FTS segment, may be nil if absent
	Batches []Batch  // Batches within the file
}

// ParseBatch parses a batch of HL7 messages from raw bytes.
//
// A batch may optionally begin with a BHS segment and end with a BTS segment.
// Individual messages within the batch are identified by MSH segment boundaries.
func ParseBatch(data []byte) (*Batch, error) {
	lines := splitLines(data)
	if len(lines) == 0 {
		return nil, ErrMessageTooShort
	}

	batch := &Batch{}
	var msgLines [][]byte

	for _, line := range lines {
		segType := segmentType(line)

		switch segType {
		case "BHS":
			seg := parseStandaloneSegment(line)
			batch.Header = &seg
		case "BTS":
			// Flush any accumulated message.
			if len(msgLines) > 0 {
				msg, err := ParseMessage(joinLines(msgLines))
				if err == nil {
					batch.Messages = append(batch.Messages, msg)
				}
				msgLines = nil
			}
			seg := parseStandaloneSegment(line)
			batch.Trailer = &seg
		case "MSH":
			// Flush previous message if any.
			if len(msgLines) > 0 {
				msg, err := ParseMessage(joinLines(msgLines))
				if err == nil {
					batch.Messages = append(batch.Messages, msg)
				}
			}
			msgLines = [][]byte{line}
		default:
			if len(msgLines) > 0 {
				msgLines = append(msgLines, line)
			}
		}
	}

	// Flush final accumulated message.
	if len(msgLines) > 0 {
		msg, err := ParseMessage(joinLines(msgLines))
		if err == nil {
			batch.Messages = append(batch.Messages, msg)
		}
	}

	return batch, nil
}

// ParseFile parses an HL7 file containing batches from raw bytes.
//
// A file may optionally begin with an FHS segment and end with an FTS segment.
// It contains one or more batches, each optionally delimited by BHS/BTS segments.
// Messages not wrapped in BHS/BTS are placed in an implicit batch.
func ParseFile(data []byte) (*File, error) {
	lines := splitLines(data)
	if len(lines) == 0 {
		return nil, ErrMessageTooShort
	}

	file := &File{}
	var currentBatch *Batch
	var msgLines [][]byte

	flushMessage := func() {
		if len(msgLines) == 0 {
			return
		}
		msg, err := ParseMessage(joinLines(msgLines))
		if err == nil {
			if currentBatch == nil {
				currentBatch = &Batch{}
			}
			currentBatch.Messages = append(currentBatch.Messages, msg)
		}
		msgLines = nil
	}

	flushBatch := func() {
		flushMessage()
		if currentBatch != nil {
			file.Batches = append(file.Batches, *currentBatch)
			currentBatch = nil
		}
	}

	for _, line := range lines {
		segType := segmentType(line)

		switch segType {
		case "FHS":
			seg := parseStandaloneSegment(line)
			file.Header = &seg
		case "FTS":
			flushBatch()
			seg := parseStandaloneSegment(line)
			file.Trailer = &seg
		case "BHS":
			flushBatch()
			currentBatch = &Batch{}
			seg := parseStandaloneSegment(line)
			currentBatch.Header = &seg
		case "BTS":
			flushMessage()
			if currentBatch != nil {
				seg := parseStandaloneSegment(line)
				currentBatch.Trailer = &seg
			}
			flushBatch()
		case "MSH":
			flushMessage()
			msgLines = [][]byte{line}
		default:
			if len(msgLines) > 0 {
				msgLines = append(msgLines, line)
			}
		}
	}

	flushBatch()

	return file, nil
}

// splitLines splits data on \r (with optional \n) into non-empty lines.
func splitLines(data []byte) [][]byte {
	var lines [][]byte
	start := 0
	for i := 0; i < len(data); i++ {
		if data[i] == '\r' || data[i] == '\n' {
			if i > start {
				lines = append(lines, data[start:i])
			}
			if data[i] == '\r' && i+1 < len(data) && data[i+1] == '\n' {
				i++
			}
			start = i + 1
		}
	}
	if start < len(data) {
		trimmed := bytes.TrimRight(data[start:], "\r\n")
		if len(trimmed) > 0 {
			lines = append(lines, trimmed)
		}
	}
	return lines
}

// joinLines joins line slices with \r separators.
func joinLines(lines [][]byte) []byte {
	if len(lines) == 0 {
		return nil
	}
	total := 0
	for _, l := range lines {
		total += len(l) + 1
	}
	result := make([]byte, 0, total)
	for i, l := range lines {
		result = append(result, l...)
		if i < len(lines)-1 {
			result = append(result, '\r')
		}
	}
	return result
}

// segmentType returns the 3-character segment type from a line, or "".
func segmentType(line []byte) string {
	if len(line) < 3 {
		return ""
	}
	return string(line[0:3])
}

// parseStandaloneSegment creates a Segment from a line using default delimiters.
// Used for BHS/BTS/FHS/FTS which may appear outside of a parsed message.
func parseStandaloneSegment(line []byte) Segment {
	delims := DefaultDelimiters()
	// Try to extract delimiters if the line has enough data and looks like it
	// has a field separator at position 3.
	if len(line) >= 8 {
		d, err := extractHeaderDelimiters(line)
		if err == nil {
			delims = d
		}
	}
	return Segment{raw: line, delims: delims}
}

// BatchBuilder constructs a BHS/BTS-wrapped HL7 batch from individual messages.
//
// Example:
//
//	bb := hl7.NewBatchBuilder()
//	bb.SetHeader(3, "MYAPP").SetHeader(4, "MYFAC")
//	bb.Add(msg1).Add(msg2)
//	data, err := bb.Build()
type BatchBuilder struct {
	delims   Delimiters
	fields   map[int]string // fieldNum (1-based) -> plain-text value
	messages []*Message
}

// BatchBuilderOption configures a BatchBuilder.
type BatchBuilderOption func(*BatchBuilder)

// WithBatchDelimiters sets the delimiter set used in the BHS header.
func WithBatchDelimiters(d Delimiters) BatchBuilderOption {
	return func(b *BatchBuilder) {
		b.delims = d
	}
}

// NewBatchBuilder returns a BatchBuilder with a default BHS header using
// DefaultDelimiters(). BHS-7 (date/time) is set to time.Now() at Build time
// unless overridden via SetHeader(7, ...).
func NewBatchBuilder(opts ...BatchBuilderOption) *BatchBuilder {
	b := &BatchBuilder{delims: DefaultDelimiters()}
	for _, opt := range opts {
		opt(b)
	}
	return b
}

// SetHeader sets BHS field fieldNum (1-based) to the given plain-text value.
// The value is escaped at Build time. Common fields:
// BHS-3 (sending application), BHS-4 (sending facility), BHS-11 (batch control ID).
// Returns the receiver for chaining.
func (b *BatchBuilder) SetHeader(fieldNum int, value string) *BatchBuilder {
	if b.fields == nil {
		b.fields = make(map[int]string)
	}
	b.fields[fieldNum] = value
	return b
}

// Add appends msg to the batch. msg.Raw() bytes are written verbatim at Build time.
// Returns the receiver for chaining.
func (b *BatchBuilder) Add(msg *Message) *BatchBuilder {
	b.messages = append(b.messages, msg)
	return b
}

// Reset clears accumulated messages. Header field values set via SetHeader are preserved.
func (b *BatchBuilder) Reset() {
	b.messages = nil
}

// Build finalizes the batch and returns BHS + messages + BTS as a byte slice.
// BTS-1 (message count) is set to the number of messages added via Add.
// BatchBuilder is reusable after Build; call Reset to clear messages while
// keeping header field values.
//
// Returns an error if the delimiter set is invalid.
func (b *BatchBuilder) Build() ([]byte, error) {
	if err := b.delims.validate(); err != nil {
		return nil, err
	}

	delims := b.delims
	now := time.Now()

	// Determine the maximum field number written to the BHS segment.
	// BHS-7 (datetime) is always included as the minimum.
	maxField := 7
	for k := range b.fields {
		if k > maxField {
			maxField = k
		}
	}

	// Collect escaped field values for BHS fields 3..maxField.
	fieldVals := make([][]byte, maxField-2) // index 0 = field 3
	for i := 3; i <= maxField; i++ {
		idx := i - 3
		if v, ok := b.fields[i]; ok {
			fieldVals[idx] = Escape([]byte(v), delims)
		} else if i == 7 {
			// Default BHS-7 to current date/time.
			fieldVals[idx] = []byte(now.Format("20060102150405"))
		}
		// All other unset fields remain nil (written as empty between separators).
	}

	// Pre-calculate BHS segment size:
	//   "BHS" (3) + fieldSep (1) + 4 encoding chars + (maxField-2) separators + field bytes
	bhsSize := 7 + (maxField - 2)
	for _, v := range fieldVals {
		bhsSize += len(v)
	}

	// Pre-calculate BTS segment size: "BTS" (3) + fieldSep (1) + count digits
	countStr := strconv.Itoa(len(b.messages))
	btsSize := 3 + 1 + len(countStr)

	// Pre-calculate total output size.
	totalSize := bhsSize + 1 // BHS + \r
	for _, msg := range b.messages {
		raw := msg.Raw()
		totalSize += len(raw)
		if len(raw) == 0 || raw[len(raw)-1] != '\r' {
			totalSize++ // ensure \r terminator after each message
		}
	}
	totalSize += btsSize + 1 // BTS + \r

	// Allocate once and build output.
	out := make([]byte, 0, totalSize)

	// BHS segment: BHS + fieldSep + encoding chars + fields 3..maxField
	out = append(out, 'B', 'H', 'S')
	out = append(out, delims.Field)
	out = append(out, delims.Component, delims.Repetition, delims.Escape, delims.SubComponent)
	for _, v := range fieldVals {
		out = append(out, delims.Field)
		out = append(out, v...)
	}
	out = append(out, '\r')

	// Messages: write each message's raw bytes, ensuring \r termination.
	for _, msg := range b.messages {
		raw := msg.Raw()
		out = append(out, raw...)
		if len(raw) == 0 || raw[len(raw)-1] != '\r' {
			out = append(out, '\r')
		}
	}

	// BTS segment: BTS + fieldSep + count
	out = append(out, 'B', 'T', 'S')
	out = append(out, delims.Field)
	out = append(out, countStr...)
	out = append(out, '\r')

	return out, nil
}

// extractHeaderDelimiters extracts delimiters from batch/file header segments
// (BHS, FHS) which share the same encoding character layout as MSH.
func extractHeaderDelimiters(data []byte) (Delimiters, error) {
	if len(data) < 8 {
		return Delimiters{}, ErrInvalidMSH
	}
	// BHS and FHS use the same encoding character positions as MSH.
	typ := string(data[0:3])
	if typ != "BHS" && typ != "FHS" && typ != "MSH" {
		return DefaultDelimiters(), nil
	}
	d := Delimiters{
		Field:        data[3],
		Component:    data[4],
		Repetition:   data[5],
		Escape:       data[6],
		SubComponent: data[7],
	}
	if err := d.validate(); err != nil {
		return DefaultDelimiters(), nil
	}
	return d, nil
}