package mft

import (
	"encoding/binary"
	"testing"
)

func TestParseAttributeRejectsShortNameData(t *testing.T) {
	data := make([]byte, minAttributeDataLength)
	binary.LittleEndian.PutUint32(data[0x00:], uint32(AttributeTypeData))
	data[0x08] = 0x00
	data[0x09] = 2
	binary.LittleEndian.PutUint16(data[0x0A:], 0x15)

	if _, err := ParseAttribute(data); err == nil {
		t.Fatal("expected ParseAttribute to reject truncated attribute name")
	}
}

func TestParseDataRunsRejectsShortRecord(t *testing.T) {
	if _, err := ParseDataRuns([]byte{0x11, 0x01}); err == nil {
		t.Fatal("expected ParseDataRuns to reject truncated data run")
	}
}

func TestFileReferenceRoundTripPreservesHighRecordBits(t *testing.T) {
	want := FileReference{
		RecordNumber:   0x00000000BA987654,
		SequenceNumber: 0x1234,
	}
	encoded := make([]byte, 8)
	binary.LittleEndian.PutUint64(encoded, want.RecordNumber)
	binary.LittleEndian.PutUint16(encoded[6:], want.SequenceNumber)

	got, err := ParseFileReference(encoded)
	if err != nil {
		t.Fatalf("ParseFileReference returned error: %v", err)
	}
	if got != want {
		t.Fatalf("ParseFileReference = %+v, want %+v", got, want)
	}
	if roundTrip := got.ToUint64(); roundTrip != binary.LittleEndian.Uint64(encoded) {
		t.Fatalf("ToUint64 = %#x, want %#x", roundTrip, binary.LittleEndian.Uint64(encoded))
	}
}

func TestParseFileReferenceZeroExtendsSixByteRecordNumber(t *testing.T) {
	encoded := []byte{0x54, 0x76, 0x98, 0xBA, 0x00, 0x00, 0x34, 0x12}
	got, err := ParseFileReference(encoded)
	if err != nil {
		t.Fatalf("ParseFileReference returned error: %v", err)
	}
	if got.RecordNumber != 0x00000000BA987654 {
		t.Fatalf("RecordNumber = %#x, want %#x", got.RecordNumber, 0x00000000BA987654)
	}
	if got.SequenceNumber != 0x1234 {
		t.Fatalf("SequenceNumber = %#x, want %#x", got.SequenceNumber, 0x1234)
	}
}

func TestParseDataRunsSignExtendsOffset(t *testing.T) {
	runs, err := ParseDataRuns([]byte{0x11, 0x02, 0xFE, 0x00})
	if err != nil {
		t.Fatalf("ParseDataRuns returned error: %v", err)
	}
	if len(runs) != 1 {
		t.Fatalf("len(runs) = %d, want 1", len(runs))
	}
	if runs[0].LengthInClusters != 2 {
		t.Fatalf("LengthInClusters = %d, want 2", runs[0].LengthInClusters)
	}
	if runs[0].OffsetCluster != -2 {
		t.Fatalf("OffsetCluster = %d, want -2", runs[0].OffsetCluster)
	}
}

func TestApplyFixUpRejectsInvalidSequenceRange(t *testing.T) {
	data := make([]byte, 1024)
	if _, err := applyFixUp(data, 1020, 4); err == nil {
		t.Fatal("expected applyFixUp to reject out-of-range update sequence")
	}
}

func TestParseRecordRejectsInvalidFixupWithoutPanic(t *testing.T) {
	data := make([]byte, 1024)
	copy(data[:4], fileSignature)
	binary.LittleEndian.PutUint16(data[0x14:], 0x2A)

	defer func() {
		if r := recover(); r != nil {
			t.Fatalf("ParseRecord panicked: %v", r)
		}
	}()

	if _, err := ParseRecord(data); err == nil {
		t.Fatal("expected ParseRecord to reject invalid fixup data")
	}
}