// Package smbios implements parsing of SMBIOS data structures.
// SMBIOS data is commonly populated by platform firmware to convey various
// metadata (including name, vendor, slots and serial numbers) about the
// platform to the operating system.
// The SMBIOS standard is maintained by DMTF and available at
// https://www.dmtf.org/sites/default/files/standards/documents/
// DSP0134_3.6.0.pdf. The rest of this package just refers to it as "the
// standard".
package smbios

import (
	"bufio"
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"reflect"
	"strings"
)

// See spec section 6.1.2
type structureHeader struct {
	// Types 128 through 256 are reserved for OEM and system-specific use.
	Type uint8
	// Length of the structure including this header, excluding the string
	// set.
	Length uint8
	// Unique handle for this structure.
	Handle uint16
}

type Structure struct {
	Type             uint8
	Handle           uint16
	FormattedSection []byte
	Strings          []string
}

// Table represents a decoded SMBIOS table consisting of its structures.
// A few known structures are parsed if present, the rest is put into
// Structures unparsed.
type Table struct {
	BIOSInformationRaw       *BIOSInformationRaw
	SystemInformationRaw     *SystemInformationRaw
	BaseboardsInformationRaw []*BaseboardInformationRaw
	SystemSlotsRaw           []*SystemSlotRaw
	MemoryDevicesRaw         []*MemoryDeviceRaw

	Structures []Structure
}

const (
	structTypeInactive   = 126
	structTypeEndOfTable = 127
)

func Unmarshal(table *bufio.Reader) (*Table, error) {
	var tbl Table
	for {
		var structHdr structureHeader
		if err := binary.Read(table, binary.LittleEndian, &structHdr); err != nil {
			if err == io.EOF {
				// Be tolerant of EOFs on structure boundaries even though
				// the EOT marker is specified as a type 127 structure.
				break
			}
			return nil, fmt.Errorf("unable to read structure header: %w", err)
		}
		if int(structHdr.Length) < binary.Size(structHdr) {
			return nil, fmt.Errorf("invalid structure: header length (%d) smaller than header", structHdr.Length)
		}
		if structHdr.Type == structTypeEndOfTable {
			break
		}
		var s Structure
		s.Type = structHdr.Type
		s.Handle = structHdr.Handle
		s.FormattedSection = make([]byte, structHdr.Length-uint8(binary.Size(structHdr)))
		if _, err := io.ReadFull(table, s.FormattedSection); err != nil {
			return nil, fmt.Errorf("error while reading structure (handle %d) contents: %w", structHdr.Handle, err)
		}
		// Read string-set
		for {
			str, err := table.ReadString(0x00)
			if err != nil {
				return nil, fmt.Errorf("error while reading string table (handle %d): %w", structHdr.Handle, err)
			}
			// Remove trailing null byte
			str = strings.TrimSuffix(str, "\x00")
			// Don't populate a zero-length first string if the string-set is
			// empty.
			if len(str) != 0 {
				s.Strings = append(s.Strings, str)
			}
			maybeTerminator, err := table.ReadByte()
			if err != nil {
				return nil, fmt.Errorf("error while reading string table (handle %d): %w", structHdr.Handle, err)
			}
			if maybeTerminator == 0 {
				// We have a valid string-set terminator, exit the loop
				break
			}
			// The next byte was not a terminator, put it back
			if err := table.UnreadByte(); err != nil {
				panic(err) // Cannot happen operationally
			}
		}
		switch structHdr.Type {
		case structTypeInactive:
			continue
		case structTypeBIOSInformation:
			var biosInfo BIOSInformationRaw
			if err := UnmarshalStructureRaw(s, &biosInfo); err != nil {
				return nil, fmt.Errorf("failed unmarshaling BIOS Information: %w", err)
			}
			tbl.BIOSInformationRaw = &biosInfo
		case structTypeSystemInformation:
			var systemInfo SystemInformationRaw
			if err := UnmarshalStructureRaw(s, &systemInfo); err != nil {
				return nil, fmt.Errorf("failed unmarshaling System Information: %w", err)
			}
			tbl.SystemInformationRaw = &systemInfo
		case structTypeBaseboardInformation:
			fmt.Println(s)
			var baseboardInfo BaseboardInformationRaw
			if err := UnmarshalStructureRaw(s, &baseboardInfo); err != nil {
				return nil, fmt.Errorf("failed unmarshaling Baseboard Information: %w", err)
			}
			tbl.BaseboardsInformationRaw = append(tbl.BaseboardsInformationRaw, &baseboardInfo)
		case structTypeSystemSlot:
			var sysSlot SystemSlotRaw
			if err := UnmarshalStructureRaw(s, &sysSlot); err != nil {
				return nil, fmt.Errorf("failed unmarshaling System Slot: %w", err)
			}
			tbl.SystemSlotsRaw = append(tbl.SystemSlotsRaw, &sysSlot)
		case structTypeMemoryDevice:
			var memoryDev MemoryDeviceRaw
			if err := UnmarshalStructureRaw(s, &memoryDev); err != nil {
				return nil, fmt.Errorf("failed unmarshaling Memory Device: %w", err)
			}
			tbl.MemoryDevicesRaw = append(tbl.MemoryDevicesRaw, &memoryDev)
		default:
			// Just pass through the raw structure
			tbl.Structures = append(tbl.Structures, s)
		}
	}
	return &tbl, nil
}

// Version contains a two-part version number consisting of a major and minor
// version. This is a common structure in SMBIOS.
type Version struct {
	Major uint8
	Minor uint8
}

func (v *Version) String() string {
	return fmt.Sprintf("%d.%d", v.Major, v.Minor)
}

// AtLeast returns true if the version in v is at least the given version.
func (v *Version) AtLeast(major, minor uint8) bool {
	return v.Major >= major && v.Minor >= minor
}

// UnmarshalStructureRaw unmarshals a SMBIOS structure into a Go struct which
// has some constraints. The first two fields need to be a `uint16 handle` and
// a `StructureVersion Version` field. After that any number of fields may
// follow as long as they are either of type `string` (which will be looked up
// in the string table) or readable by binary.Read. To determine the structure
// version, the smbios_min_vers struct tag needs to be put on the first field
// of a newer structure version. The version implicitly starts with 2.0.
// The version determined is written to the second target struct field.
// Fields which do not have a fixed size need to be typed as a slice and tagged
// with smbios_repeat set to the name of the field containing the count. The
// count field itself needs to be some width of uint.
func UnmarshalStructureRaw(rawStruct Structure, target any) error {
	v := reflect.ValueOf(target)
	if v.Kind() != reflect.Pointer {
		return errors.New("target needs to be a pointer")
	}
	v = v.Elem()
	if v.Kind() != reflect.Struct {
		return errors.New("target needs to be a pointer to a struct")
	}
	v.Field(0).SetUint(uint64(rawStruct.Handle))
	r := bytes.NewReader(rawStruct.FormattedSection)
	completedVersion := Version{Major: 0, Minor: 0}
	parsingVersion := Version{Major: 2, Minor: 0}
	numFields := v.NumField()
	hasAborted := false
	for i := 2; i < numFields; i++ {
		fieldType := v.Type().Field(i)
		if min := fieldType.Tag.Get("smbios_min_ver"); min != "" {
			var ver Version
			if _, err := fmt.Sscanf(min, "%d.%d", &ver.Major, &ver.Minor); err != nil {
				panic(fmt.Sprintf("invalid smbios_min_ver tag in %v: %v", fieldType.Name, err))
			}
			completedVersion = parsingVersion
			parsingVersion = ver
		}
		f := v.Field(i)

		if repeat := fieldType.Tag.Get("smbios_repeat"); repeat != "" {
			repeatCountField := v.FieldByName(repeat)
			if !repeatCountField.IsValid() {
				panic(fmt.Sprintf("invalid smbios_repeat tag in %v: no such field %q", fieldType.Name, repeat))
			}
			if !repeatCountField.CanUint() {
				panic(fmt.Sprintf("invalid smbios_repeat tag in %v: referenced field %q is not uint-compatible", fieldType.Name, repeat))
			}
			if f.Kind() != reflect.Slice {
				panic(fmt.Sprintf("cannot repeat a field (%q) which is not a slice", fieldType.Name))
			}
			if repeatCountField.Uint() > 65536 {
				return fmt.Errorf("refusing to read a field repeated more than 65536 times (given %d times)", repeatCountField.Uint())
			}
			repeatCount := int(repeatCountField.Uint())
			f.Set(reflect.MakeSlice(f.Type(), repeatCount, repeatCount))
			for j := 0; j < repeatCount; j++ {
				fs := f.Index(j)
				err := unmarshalField(&rawStruct, fs, r)
				if errors.Is(err, io.EOF) {
					hasAborted = true
					break
				} else if err != nil {
					return fmt.Errorf("error unmarshaling field %q: %w", fieldType.Name, err)
				}
			}
		}
		err := unmarshalField(&rawStruct, f, r)
		if errors.Is(err, io.EOF) {
			hasAborted = true
			break
		} else if err != nil {
			return fmt.Errorf("error unmarshaling field %q: %w", fieldType.Name, err)
		}
	}
	if !hasAborted {
		completedVersion = parsingVersion
	}
	if completedVersion.Major == 0 {
		return fmt.Errorf("structure's formatted section (%d bytes) is smaller than its minimal size", len(rawStruct.FormattedSection))
	}
	v.Field(1).Set(reflect.ValueOf(completedVersion))
	return nil
}

func unmarshalField(rawStruct *Structure, field reflect.Value, r *bytes.Reader) error {
	if field.Kind() == reflect.String {
		var stringTableIdx uint8
		err := binary.Read(r, binary.LittleEndian, &stringTableIdx)
		if err != nil {
			return err
		}
		if stringTableIdx == 0 {
			return nil
		}
		if int(stringTableIdx)-1 >= len(rawStruct.Strings) {
			return fmt.Errorf("string index (%d) bigger than string table (%q)", stringTableIdx-1, rawStruct.Strings)
		}
		field.SetString(rawStruct.Strings[stringTableIdx-1])
		return nil
	}
	return binary.Read(r, binary.LittleEndian, field.Addr().Interface())
}