Types

type ActivationGroup struct {
	Name       string
	Attributes []*Attribute
}

type AnimationSystem struct {
	P1      []float32
	P2      []float32
	P3      []float32
	Radiues float32
}

type ArtNet struct {
	Maps []*Map
}

type Attribute struct {
	Name             string
	Pretty           string
	ActivationGroup  NodeReference[ActivationGroup]
	Feature          NodeReference[Feature]
	MainAttribute    NodeReference[Attribute]
	PhysicalUnit     string
	Color            ColorCIE
	SubPhysicalUnits *[]*SubPhysicalUnit
}

type AttributeDefinitions struct {
	ActivationGroups []*ActivationGroup
	FeatureGroups    []*FeatureGroup
	Attributes       []*Attribute
}

type Axis struct {
	GeometryBase
}

type Beam struct {
	GeometryBase
	LampType         string
	PowerConsumption float32
	LuminousFlux     float32
	ColorTemperature float32
	BeamAngle        float32
	FieldAngle       float32
	ThrowRatio       float32
	RectangleRatio   float32
	BeamRadius       float32
	BeamType         string
	CRI              uint
	EmitterSpectrum  NodeReference[Emitter]
}

type Break struct {
	DMXOffset DMXAddress
	DMXBreak  uint
}

type CITP struct {
}

type CRI struct {
	CES string
	CRI uint
}

type CRIGroup struct {
	ColorTemperature float32
	CRIs             []*CRI
}

type ChannelFunction struct {
	Name              string
	Attribute         NodeReference[Attribute]
	OriginalAttribute string
	DMXFrom           DMXValue
	Default           DMXValue
	PhysicalFrom      float32
	PhysicalTo        float32
	RealFade          float32
	RealAcceleration  float32
	Wheel             NodeReference[Wheel]
	Emitter           NodeReference[Emitter]
	Filter            NodeReference[Filter]
	ColorSpace        NodeReference[ColorSpace]
	Gamut             NodeReference[Gamut]
	ModeMaster        string //TODO: reference to dmx channel or other channel function
	ModeFrom          DMXValue
	ModeTo            DMXValue
	DMXProfile        NodeReference[DMXProfile]
	Min               float32 // Fallback to PhysicalFrom if 0.0
	Max               float32 // Fallback to PhysicalTo if 0.0
	CustomName        string  // Default: Node Name of the Channel function Example: Head_Dimmer.Dimmer.Dimmer
	ChannelSets       []*ChannelSet
	SubChannelSets    []*SubChannelSet
}

type ChannelSet struct {
	Name         string
	DMXFrom      DMXValue
	PhysicalFrom float32
	PhysicalTo   float32
	WheelSlot    NodeReference[WheelSlot]
}

type ColorCIE struct {
	X  float32
	Y  float32
	Y2 float32
}

type ColorSpace struct {
	Name       string
	Mode       string //enum + TODO: default data (see https://www.gdtf.eu/gdtf/file-spec/physical-descriptions/#table-20-color-space-attributes)
	Red        ColorCIE
	Green      ColorCIE
	Blue       ColorCIE
	WhitePoint ColorCIE
}

type Connector struct {
	Name     string
	Type     string
	DMXBreak uint    // obsolete (see https://www.gdtf.eu/gdtf/file-spec/physical-descriptions/#table-27-connector-attributes)
	Gender   int     // obsolete
	Length   float32 // obsolete
}

type DMXAddress struct {
	Address  int16 // 0 indexed
	Universe int   // 0 indexed
}

type DMXChannel struct {
	DMXBreak        int
	Offset          []int
	InitialFunction NodeReference[ChannelFunction] //TODO:
	Highlight       DMXValue
	Geometry        string
	LogicalChannels []*LogicalChannel
}

type DMXMode struct {
	Name        string
	Description string
	Geometry    NodeReference[GeometryNodeReference]
	DMXChannels []*DMXChannel
	Relations   []*Relation
	FTMacros    []*FTMacro
}

type DMXProfile struct {
	Name   string
	Points []*Point
}

type DMXValue = string

type Display struct {
	GeometryBase
	Texture FileReference
}

type Emitter struct {
	Name               string
	Color              ColorCIE
	DominantWaveLength float32
	DiodePart          string
	Measurements       []*Measurement
}

type FTMacro struct {
	Name            string
	ChannelFunction NodeReference[ChannelFunction]
	MacroDMXs       []*MacroDMX
}

type Feature struct {
	Name       string
	Attributes []*Attribute
}

type FeatureGroup struct {
	Name     string
	Pretty   string
	Features []*Feature
}

type FileReference = string // without extension and without path

type Filter struct {
	Name         string
	Color        ColorCIE
	Measurements []*Measurement
}

type FilterBeam struct {
	GeometryBase
}

type FilterColor struct {
	GeometryBase
}

type FilterGobo struct {
	GeometryBase
}

type FilterShaper struct {
	GeometryBase
}

type FixtureType struct {
	FixtureTypeID    string
	Name             string
	ShortName        string
	LongName         string
	Manufacturer     string
	Description      string
	Thumbnail        NodeReference[image.Image]
	ThumbnailOffsetX int
	ThumbnailOffsetY int
	CanHaveChildren  bool
	RefFT            *string

	AttributeDefinitions AttributeDefinitions
	Wheels               []*Wheel
	PhysicalDescriptions []*PhysicalDescription
	Models               []*Model
	Geometries           Geometries
	DMXModes             map[string]*DMXMode
	Revisions            []*Revision
	FTPresets            *[]string
	Protocols            Protocol
}

type GDTF struct {
	DataVersion string
	FixtureType FixtureType
}

type Gamut struct {
	Name   string
	Points []*ColorCIE
}

type Geometries struct {
	GeometryList          []*Geometry
	AxisList              []*Axis
	FilterBeamList        []*FilterBeam
	FilterColorList       []*FilterColor
	FilterGoboList        []*FilterGobo
	FilterShaperList      []*FilterShaper
	BeamList              []*Beam
	MediaServerLayerList  []*MediaServerLayer
	MediaServerCameraList []*MediaServerCamera
	MediaServerMasterList []*MediaServerMaster
	DisplayList           []*Display
	LaserList             []*Laser
	GeometryReferenceList []*GeometryReference
	WiringObjectList      []*WiringObject
	InventoryList         []*Inventory
	StructureList         []*Structure
	SupportList           []*Support
	MagnetList            []*Magnet

	Parent *GeometryNodeReference
}

type Geometry struct {
	GeometryBase
}

type GeometryBase struct {
	Name     string
	Model    NodeReference[Model]
	Position Matrix
	Geometries
}

type GeometryNodeReference struct {
	Ptr  any
	Type string
}

type GeometryReference struct {
	Name        string
	Model       NodeReference[Model]
	Position    Matrix
	GeometryRef NodeReference[GeometryNodeReference] // only top level geometries allowed to be referenced
	Breaks      []*Break
}

type GeometryReferenceCreation interface {
	CreateGeometryReferencePointer(refPointers *ReferencePointers, parentPrefix string)
}

type Hex = int

type Inventory struct {
	GeometryBase
	Count int
}

type Laser struct {
	GeometryBase
	ColorType         string  // enum
	Color             float32 // Required if ColorType is “SingleWaveLength”; Unit:nm (nanometers)
	OutputStrength    float32
	Emitter           NodeReference[Emitter]
	BeamDiameter      float32
	BeamDivergenceMin float32
	BeamDivergenceMax float32
	ScanAnglePan      float32
	ScanAngleTilt     float32
	ScanSpeed         float32
	Protocols         []*LaserProtocol
}

type LaserProtocol struct {
	Name string
}

type LegHeight struct {
	Value float32
}

type LogicalChannel struct {
	Attribute          NodeReference[Attribute]
	Snap               string // enum
	Master             string // enum
	MibFade            float32
	DMXChangeTimeLimit float32
	ChannelFunctions   []*ChannelFunction
}

type MacroDMX struct {
	Steps []*MacroDMXStep
}

type MacroDMXStep struct {
	Duration  float32
	DMXValues []*MacroDMXValue
}

type MacroDMXValue struct {
	Value      DMXValue
	DMXChannel NodeReference[DMXChannel]
}

type Magnet struct {
	GeometryBase
}

type Map struct {
	Key   uint // Art-Net value
	Value uint // DMX value
}

type Matrix [4][4]float64

type Measurement struct {
	Phyiscal          float32
	LuminousIntensity float32
	Transmission      float32
	InterpolationTo   string
	MeasurementPoints []*MeasurementPoint
}

type MeasurementPoint struct {
	WaveLength float32
	Energy     float32
}

type MediaServerCamera struct {
	GeometryBase
}

type MediaServerLayer struct {
	GeometryBase
}

type MediaServerMaster struct {
	GeometryBase
}

type MeshGenerator interface {
	GenerateMesh(parentTransformation MeshTypes.Matrix) *MeshTypes.Mesh
}

type Model struct {
	Name            string
	Length          float32 // in meter
	Width           float32 // in meter
	Height          float32 // in meter
	PrimitiveType   string  // enum
	File            *string
	SVGOffsetX      float32
	SVGOffsetY      float32
	SVGSideOffsetX  float32
	SVGSideOffsetY  float32
	SVGFrontOffsetX float32
	SVGFrontOffsetY float32
	Mesh            *MeshTypes.Mesh
}

type NodeReference[T any] struct {
	String string
	Ptr    *T
}

type OpenSoundControl struct {
}

type OperatingTemperature struct {
	Low  float32
	High float32
}

type PhysicalDescription struct {
	Emitters              []*Emitter
	Filters               []*Filter
	ColorSpace            *ColorSpace
	AdditionalColorSpaces []*ColorSpace
	Gamuts                []*Gamut
	DMXProfiles           []*DMXProfile
	CRIs                  []*CRIGroup
	Connectors            []*Connector
	Properties            *Properties
}

type PinPatch struct {
	ToWiringObject NodeReference[WiringObject]
	FromPin        int
	ToPin          int
}

type Point struct {
	DMXPercentage float32
	CFC0          float32
	CFC1          float32
	CFC2          float32
	CFC3          float32
}

type PosiStageNet struct {
}

type PrismFacet struct {
	Color    ColorCIE
	Rotation Rotation
}

type Properties struct {
	OperatingTemperature *OperatingTemperature
	Weight               *Weight
	PowerConsumption     any
	LegHeight            *LegHeight
}

type Protocol struct {
	RDM              []*RDM
	ArtNet           []*ArtNet
	SACN             []*SACN
	PosiStageNet     []*PosiStageNet
	OpenSoundControl []*OpenSoundControl
	CITP             []*CITP
}

type RDM struct {
	ManufacturerID   Hex
	DeviceModelID    Hex
	SoftwareVersions []*RDMSoftwareVersion
}

type RDMDMXPersonality struct {
	Value   Hex
	DMXMode NodeReference[DMXMode] // reference to DMX Mode
}

type RDMSoftwareVersion struct {
	Value            Hex
	DMXPersonalities []*RDMDMXPersonality
}

type ReferenceCreation interface {
	CreateReferencePointer(refPointers *ReferencePointers)
}

type ReferencePointers struct {
	ActivationGroups map[string]*ActivationGroup
	Features         map[string]*Feature
	Attributes       map[string]*Attribute
	Wheels           map[string]*Wheel
	WheelSlots       map[string]*WheelSlot
	Emitters         map[string]*Emitter
	Filters          map[string]*Filter
	ColorSpaces      map[string]*ColorSpace // TODO: find example since spec sheet is not specific enough
	Gamuts           map[string]*Gamut
	DMXProfiles      map[string]*DMXProfile
	DMXModes         map[string]*DMXMode
	DMXChannels      map[string]*DMXChannel
	SubPhysicalUnits map[string]*SubPhysicalUnit //TODO: find example since spec sheet is not specific enough
	WiringObjects    map[string]*WiringObject    //TODO: find example since spec sheet is not specific enough
	ChannelFunctions map[string]*ChannelFunction
	Geometries       map[string]*GeometryNodeReference
	Models           map[string]*Model
}

type ReferenceResolver interface {
	ResolveReference(refPointers *ReferencePointers)
}

type Relation struct {
	Name     string
	Master   *DMXChannel
	Follower *DMXChannel
	Type     string //enum with "Multiply" or "Override"
}

type Revision struct {
	Text       string
	Date       time.Time
	UserID     uint
	ModifiedBy string
}

type Rotation [3][3]float32

type SACN struct {
	Maps []*Map
}

type Structure struct {
	GeometryBase
	LinkedGeometry            string // for now (analyse if this can be a NodeReference instead)
	StructureType             string // enum
	CrossSectionType          string // enum
	CrossSectionHeight        float32
	CrossSectionWallThickness float32
	TrussCrossSection         string
}

type SubChannelSet struct {
	Name            string
	PhysicalFrom    float32
	PhysicalTo      float32
	SubPhysicalUnit NodeReference[SubPhysicalUnit]
	DMXProfile      NodeReference[DMXProfile]
}

type SubPhysicalUnit struct {
	Type         string
	PhysicalUnit string
	PhysicalFrom float32
	PhysicalTo   float32
}

type Support struct {
	GeometryBase
	SupportType      string //enum
	RopeCrossSection string
	RopeOffset       Vector3
	CapacityX        float32
	CapacityY        float32
	CapacityZ        float32
	CapacityXX       float32
	CapacityYY       float32
	CapacityZZ       float32
	ResistanceX      float32
	ResistanceY      float32
	ResistanceZ      float32
	ResistanceXX     float32
	ResistanceYY     float32
	ResistanceZZ     float32
}

type Vector3 struct {
	X float32
	Y float32
	Z float32
}

type Weight struct {
	Value float32
}

type Wheel struct {
	Name       string
	WheelSlots []*WheelSlot
}

type WheelSlot struct {
	Name             string
	Color            ColorCIE
	Filter           NodeReference[Filter] // ref to Physical/Filter
	MediaFileName    *string
	PrismFacets      []*PrismFacet
	AnimationSystems []*AnimationSystem
}

type WiringObject struct {
	GeometryBase
	ConnectorType     string
	ComponentType     string //enum
	SignalType        string
	PinCount          int
	ElectricalPayLoad float32
	VoltageRangeMax   float32
	VoltageRangeMin   float32
	FrequencyRangeMax float32
	FrequencyRangeMin float32
	MaxPayLoad        float32
	Voltage           float32
	SignalLayer       int
	CosPhi            float32
	FuseCurrent       float32 // in ampere
	FuseRating        string  //enum
	Orientation       string  //enum
	WireGroup         string
	PinPatches        []*PinPatch
}