continuation_test.go

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

package hl7

import (
	"errors"
	"testing"
)

// msh is a shared MSH prefix used across continuation tests.
const msh = "MSH|^~\\&|Send|Recv|App|Fac|20240101||QRY^R02|1|P|2.5.1"

func TestConcatenate_basic(t *testing.T) {
	// First page: MSH + QRD + DSC
	page1Raw := []byte(msh + "\rQRD|20240101000000|R|I|Q001|||10^RD&Records&ISO|12345|PID^LName^FName\rDSC|Q002|I")
	// Second page: MSH + QRD (continuation)
	page2Raw := []byte(msh + "\rQRD|20240101000000|R|I|Q002|||10^RD&Records&ISO|67890|PID^LName^FName")

	page1, err := ParseMessage(page1Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page1): %v", err)
	}
	page2, err := ParseMessage(page2Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page2): %v", err)
	}

	result, err := page1.Concatenate(page2)
	if err != nil {
		t.Fatalf("Concatenate: %v", err)
	}

	segs := result.Segments()
	// Expected: MSH QRD QRD (DSC stripped from page1, MSH stripped from page2)
	if len(segs) != 3 {
		t.Fatalf("len(Segments()) = %d, want 3", len(segs))
	}
	if segs[0].Type() != "MSH" {
		t.Errorf("seg[0].Type() = %q, want MSH", segs[0].Type())
	}
	if segs[1].Type() != "QRD" {
		t.Errorf("seg[1].Type() = %q, want QRD", segs[1].Type())
	}
	if segs[2].Type() != "QRD" {
		t.Errorf("seg[2].Type() = %q, want QRD", segs[2].Type())
	}
}

func TestConcatenate_noDSC(t *testing.T) {
	// First page has no DSC segment.
	page1Raw := []byte(msh + "\rQRD|20240101000000|R|I|Q001")
	page2Raw := []byte(msh + "\rQRD|20240101000000|R|I|Q002")

	page1, err := ParseMessage(page1Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page1): %v", err)
	}
	page2, err := ParseMessage(page2Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page2): %v", err)
	}

	result, err := page1.Concatenate(page2)
	if err != nil {
		t.Fatalf("Concatenate: %v", err)
	}

	segs := result.Segments()
	// Expected: MSH QRD QRD (no DSC to remove, MSH stripped from page2)
	if len(segs) != 3 {
		t.Fatalf("len(Segments()) = %d, want 3", len(segs))
	}
	for i, want := range []string{"MSH", "QRD", "QRD"} {
		if segs[i].Type() != want {
			t.Errorf("seg[%d].Type() = %q, want %q", i, segs[i].Type(), want)
		}
	}
}

func TestConcatenate_noPayloadInNext(t *testing.T) {
	// Second message has only MSH (no additional segments).
	page1Raw := []byte(msh + "\rQRD|20240101000000|R|I|Q001\rDSC|Q002|I")
	page2Raw := []byte(msh)

	page1, err := ParseMessage(page1Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page1): %v", err)
	}
	page2, err := ParseMessage(page2Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page2): %v", err)
	}

	result, err := page1.Concatenate(page2)
	if err != nil {
		t.Fatalf("Concatenate: %v", err)
	}

	segs := result.Segments()
	// Expected: MSH QRD only — DSC stripped from page1, MSH stripped from page2
	if len(segs) != 2 {
		t.Fatalf("len(Segments()) = %d, want 2", len(segs))
	}
	if segs[0].Type() != "MSH" {
		t.Errorf("seg[0].Type() = %q, want MSH", segs[0].Type())
	}
	if segs[1].Type() != "QRD" {
		t.Errorf("seg[1].Type() = %q, want QRD", segs[1].Type())
	}
}

func TestConcatenate_delimiterMismatch(t *testing.T) {
	// Standard delimiters.
	page1Raw := []byte("MSH|^~\\&|Send|Recv|App|Fac|20240101||QRY^R02|1|P|2.5.1\rDSC|Q002|I")
	// Different component separator ($instead of ^).
	page2Raw := []byte("MSH|$~\\&|Send|Recv|App|Fac|20240101||QRY$R02|2|P|2.5.1")

	page1, err := ParseMessage(page1Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page1): %v", err)
	}
	page2, err := ParseMessage(page2Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page2): %v", err)
	}

	_, err = page1.Concatenate(page2)
	if !errors.Is(err, ErrDelimiterMismatch) {
		t.Errorf("err = %v, want ErrDelimiterMismatch", err)
	}
}

func TestConcatenate_resultParseable(t *testing.T) {
	// Verify the result is a valid, fully parseable message with working Get().
	page1Raw := []byte(msh + "\rPID|1||12345^^^MRN||Smith^John\rDSC|Q002|I")
	page2Raw := []byte(msh + "\rPID|2||67890^^^MRN||Jones^Jane")

	page1, err := ParseMessage(page1Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page1): %v", err)
	}
	page2, err := ParseMessage(page2Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page2): %v", err)
	}

	result, err := page1.Concatenate(page2)
	if err != nil {
		t.Fatalf("Concatenate: %v", err)
	}

	// MSH-9.1 should be accessible.
	msgType := result.Get("MSH-9.1").String()
	if msgType != "QRY" {
		t.Errorf("MSH-9.1 = %q, want QRY", msgType)
	}

	// First PID segment (index 0).
	pid1ID := result.Get("PID(0)-3.1").String()
	if pid1ID != "12345" {
		t.Errorf("PID(0)-3.1 = %q, want 12345", pid1ID)
	}

	// Second PID segment (index 1).
	pid2ID := result.Get("PID(1)-3.1").String()
	if pid2ID != "67890" {
		t.Errorf("PID(1)-3.1 = %q, want 67890", pid2ID)
	}

	// Second PID family name.
	pid2Name := result.Get("PID(1)-5.1").String()
	if pid2Name != "Jones" {
		t.Errorf("PID(1)-5.1 = %q, want Jones", pid2Name)
	}
}

func TestConcatenate_multiplePages(t *testing.T) {
	// Chain three messages: a.Concatenate(b) then ab.Concatenate(c).
	pageARaw := []byte(msh + "\rOBX|1|ST|8302-2^Body Height^LN||170|cm\rDSC|Q002|I")
	pageBRaw := []byte(msh + "\rOBX|2|ST|29463-7^Body Weight^LN||70|kg\rDSC|Q003|I")
	pageCRaw := []byte(msh + "\rOBX|3|NM|8310-5^Body Temperature^LN||37.0|Cel")

	pageA, err := ParseMessage(pageARaw)
	if err != nil {
		t.Fatalf("ParseMessage(A): %v", err)
	}
	pageB, err := ParseMessage(pageBRaw)
	if err != nil {
		t.Fatalf("ParseMessage(B): %v", err)
	}
	pageC, err := ParseMessage(pageCRaw)
	if err != nil {
		t.Fatalf("ParseMessage(C): %v", err)
	}

	ab, err := pageA.Concatenate(pageB)
	if err != nil {
		t.Fatalf("A.Concatenate(B): %v", err)
	}

	abc, err := ab.Concatenate(pageC)
	if err != nil {
		t.Fatalf("AB.Concatenate(C): %v", err)
	}

	segs := abc.Segments()
	// Expected: MSH OBX OBX OBX (DSC stripped at each merge step, MSH stripped from B and C)
	if len(segs) != 4 {
		t.Fatalf("len(Segments()) = %d, want 4", len(segs))
	}
	for i, want := range []string{"MSH", "OBX", "OBX", "OBX"} {
		if segs[i].Type() != want {
			t.Errorf("seg[%d].Type() = %q, want %q", i, segs[i].Type(), want)
		}
	}

	// Verify OBX sequence IDs are correct.
	for i, wantID := range []string{"1", "2", "3"} {
		loc := "OBX(" + string(rune('0'+i)) + ")-1"
		got := abc.Get(loc).String()
		if got != wantID {
			t.Errorf("%s = %q, want %q", loc, got, wantID)
		}
	}
}

func TestConcatenate_nextHasADDSegments(t *testing.T) {
	// page2's OBX carries an ADD continuation segment for OBX-5. ParseMessage
	// merges ADD into its preceding segment, so the parsed page2 has 2 segments
	// (MSH, OBX) — not 3. Concatenate must handle this transparently.
	page1Raw := []byte(msh + "\rOBX|1|TX|note||Page one content\rDSC|Q002|I")
	page2Raw := []byte(msh + "\rOBX|2|TX|note||Page two first part\rADD|Page two second part")

	page1, err := ParseMessage(page1Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page1): %v", err)
	}
	page2, err := ParseMessage(page2Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page2): %v", err)
	}

	// Confirm ADD was merged: page2 has MSH + OBX only, not MSH + OBX + ADD.
	if len(page2.Segments()) != 2 {
		t.Fatalf("page2 segment count = %d, want 2 (ADD merged into OBX)", len(page2.Segments()))
	}

	result, err := page1.Concatenate(page2)
	if err != nil {
		t.Fatalf("Concatenate: %v", err)
	}

	segs := result.Segments()
	// Expected: MSH OBX(page1) OBX(page2, ADD-merged). DSC stripped from page1,
	// MSH stripped from page2.
	if len(segs) != 3 {
		t.Fatalf("len(Segments()) = %d, want 3", len(segs))
	}
	for i, want := range []string{"MSH", "OBX", "OBX"} {
		if segs[i].Type() != want {
			t.Errorf("seg[%d].Type() = %q, want %q", i, segs[i].Type(), want)
		}
	}

	// OBX(0)-5: page1's observation value, unchanged.
	if got := result.Get("OBX(0)-5").String(); got != "Page one content" {
		t.Errorf("OBX(0)-5 = %q, want %q", got, "Page one content")
	}

	// OBX(1)-5: page2's own field value, unchanged.
	// mergeADD strips "\rADD" but keeps the "|", so ADD field 1 becomes a
	// distinct next field of OBX rather than being concatenated onto OBX-5.
	if got := result.Get("OBX(1)-5").String(); got != "Page two first part" {
		t.Errorf("OBX(1)-5 = %q, want %q", got, "Page two first part")
	}
	// OBX(1)-6: ADD field 1 separated from the preceding segment by "|".
	if got := result.Get("OBX(1)-6").String(); got != "Page two second part" {
		t.Errorf("OBX(1)-6 = %q, want %q", got, "Page two second part")
	}
}

func TestConcatenate_secondPageStartsWithADD(t *testing.T) {
	// HL7 continuation scenario: page1 splits an OBX at a field boundary and
	// ends with DSC. page2 starts with MSH (for transport) followed immediately
	// by an ADD segment that continues OBX-5 from page1.
	//
	// After Concatenate the ADD must be merged into the OBX from page1, not
	// lost when the page2 MSH is stripped.
	page1Raw := []byte(msh + "\rOBX|1|TX|note||First part\rDSC|Q002|I")
	page2Raw := []byte(msh + "\rADD|Second part")

	page1, err := ParseMessage(page1Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page1): %v", err)
	}
	page2, err := ParseMessage(page2Raw)
	if err != nil {
		t.Fatalf("ParseMessage(page2): %v", err)
	}

	result, err := page1.Concatenate(page2)
	if err != nil {
		t.Fatalf("Concatenate: %v", err)
	}

	segs := result.Segments()
	// Expected: MSH OBX. DSC stripped from page1, MSH stripped from page2.
	// The ADD from page2 continues OBX so no ADD segment is visible.
	if len(segs) != 2 {
		t.Fatalf("len(Segments()) = %d, want 2", len(segs))
	}
	for i, want := range []string{"MSH", "OBX"} {
		if segs[i].Type() != want {
			t.Errorf("seg[%d].Type() = %q, want %q", i, segs[i].Type(), want)
		}
	}

	// OBX-5: page1's original field value, unchanged.
	if got := result.Get("OBX(0)-5").String(); got != "First part" {
		t.Errorf("OBX(0)-5 = %q, want %q", got, "First part")
	}
	// OBX-6: ADD field 1 from page2. mergeADD appends fields (not within-field
	// concatenation), so ADD field 1 becomes the next field of OBX.
	if got := result.Get("OBX(0)-6").String(); got != "Second part" {
		t.Errorf("OBX(0)-6 = %q, want %q", got, "Second part")
	}
}

func BenchmarkConcatenate(b *testing.B) {
	page1Raw := []byte(msh + "\rPID|1||12345^^^MRN||Smith^John|||M\rOBR|1||ORD001|CBC\rOBX|1|ST|8302-2^Body Height^LN||170|cm\rDSC|Q002|I")
	page2Raw := []byte(msh + "\rPID|2||67890^^^MRN||Jones^Jane|||F\rOBR|2||ORD002|CMP\rOBX|2|NM|8310-5^Body Temp^LN||37.0|Cel")

	page1, err := ParseMessage(page1Raw)
	if err != nil {
		b.Fatalf("ParseMessage(page1): %v", err)
	}
	page2, err := ParseMessage(page2Raw)
	if err != nil {
		b.Fatalf("ParseMessage(page2): %v", err)
	}

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		result, err := page1.Concatenate(page2)
		if err != nil {
			b.Fatalf("Concatenate: %v", err)
		}
		_ = result
	}
}