// Hardware is a logical representation of a machine that can execute Workflows.
type Hardware struct {
	HardwareSpec
}

type HardwareSpec struct {
	// NetworkInterfaces defines the desired DHCP and netboot configuration for a network interface.
	NetworkInterfaces NetworkInterfaces

	// StorageDevices is a list of storage devices that will be available in the OSIE.
	// Optional.
	StorageDevices []StorageDevice

	// Instance describes instance specific data.
	Instance Instance

	// BMCRef references a Rufio Machine object. It exists in the current API and will not be changed
	// with this proposal.
	BMCRef LocalObjectReference
}

// NetworkInterfaces maps a MAC address to a NetworkInterface.
type NetworkInterfaces map[MAC]NetworkInterface

// MAC is a Media Access Control address.
type MAC string

// NetworkInterface is the desired configuration for a particular network interface.
type NetworkInterface struct {
	// IP to configure during DHCP.
	IP string

	// Netmask to configure during DHCP.
	Netmask string

	// Gateway to configure during DHCP.
	Gateway string

	// Hostname to configure during DHCP.
	// Optional.
	Hostname string

	// VLAN ID to configure during DHCP.
	// Optional.
	VLANID int

	// Nameservers to configure during DHCP.
	Nameservers []string

	// Timeservers to configure during DHCP.
	// Optional.
	Timeservers []string

	// DisableNetboot disables netbooting for this interface.
	// Default false.
	DisableNetboot bool

	// DisableDHCP disables DHCP for this interface. Implies DisableNetboot.
	// Default false.
	DisableDHCP bool

	// OSIE references an OSIE object.
	OSIE LocalObjectReference
}

// StorageDevice describes a storage device path that will be present in the OSIE.
type StorageDevice string

// Instance describes instance specific data. Instance specific data is typically dependent on the
// permanent OS that a piece of hardware runs. This data is often served by an instance metadata
// service such as Tinkerbell's Hegel. The core Tinkerbell stack does not leverage this data.
type Instance struct {
	// Userdata is data with a structure understood by the producer and consumer of the data.
	Userdata string

	// Vendordata is data with a structure understood by the producer and consumer of the data.
	Vendordata string
}

// OSIE describes and Operating System Initialization Environment. It is used by Tinkerbell
// to provision machines and should launch the Tink Worker component.
type OSIE struct {
	Spec OSIESpec
}

type OSIESpec struct {
	// KernelURL is a URL to a kernel image.
	KernelURL string

	// InitrdURL is a URL to an initrd image.
	InitrdURL string

	// KernelParams defines a set of key-value pairs that are passed to the Kernel on boot.
	// E.g. map{"console": "ttyS0,9600"} is passed as console=ttyS0,9600.
	// Optional.
	KernelParams map[string]string

	// PXEScriptURL is a URL to an iPXE script served during netboot in-place of default iPXE scripts.
	// Optional.
	IPXEScriptURL string
}

// Template defines a set of actions to be run on a target machine. The template is rendered
// prior to execution where it is exposed to Hardware and user defined data. All fields within
// TemplateSpec may contain template values. See https://pkg.go.dev/text/template for more details.
type Template struct {
	Spec TemplateSpec
}

type TemplateSpec struct {
	// Actions defines the set of actions to be run on a target machine. Actions are run sequentially
	// in the order they are specified. At least 1 action must be specified. Names of actions
	// must be unique within a Template.
	Actions []Action

	// Volumes to be mounted on all actions. If an action specifies the same volume it will take
	// precedence.
	// Optional.
	Volumes []Volume

	// Environment defines environment variables to be available in all actions. If an action
	// secifies the same environment variable it will take precedence.
	// Optional.
	Environment map[string]string
}

// Action defines an individual action to be run on a target machine.
type Action struct {
	// Name is a unique name for the action.
	Name string

	// Image is an OCI image.
	Image string

	// Command defines the command to use when launching the image.
	// Optional.
	Command string

	// Volumes defines the volumes to mount into the container.
	// Optional.
	Volumes []Volume

	// Environment defines environment variables used when launching the container.
	// Optional.
	Environment map[string]string
}

// Volume is a specification for mounting a volume in an action. Volumes take the form
// {VOLUME-NAME | HOST-DIR}:CONTAINER-DIR:OPTIONS. When specifying a VOLUME-NAME that does not exist
// it will be created for you.
//
// Examples
//
// Read-only bind mount
//   /etc/data:/data:ro
//
// Writable volume name bound to /data
//   shared_volume:/data
//
// See https://docs.docker.com/storage/volumes/ for additional details
type Volume string

// Workflow describes a set of actions to be run on a specific Hardware. Workflows execute
// once and should be considered ephemeral.
type Workflow struct {
	Spec   WorkflowSpec
	Status WorkflowStatus
}

type WorkflowSpec struct {
	// HardwareRef is a reference to a Hardware resource this workflow will execute on.
	// If no namespace is specified the Workflow's namespace is assumed.
	HardwareRef NamespacedReference

	// TemplateRef is a reference to a Template resource used to render workflow actions.
	// If no namespace is specified the Workflow's namespace is assumed.
	TemplateRef NamespacedReference

	// TemplateData is arbitrary user defined data that is available during template rendering.
	// The complete data structure should be marshalable using packages such as the standard
	// library json package.
	// Optional.
	TemplateData map[string]any

	// Timeout defines the time the workflow has to complete after the first action is requested.
	// When set to 0, no timeout is applied.
	// Optional.
	Timeout int32
}

// NamespacedReference is a cross namespace reference for an object. The object being referenced
// is context dependent.
type NamespacedReference struct {
	Name      string
	Namespace string
}

type WorkflowStatus struct {
	// Actions is the list of rendered actions and their status.
	Actions RenderedActions

	// State describes the current state of the workflow.
	State State

	// Result describes the result of the workflow.
	Result Result
}

// RenderedActions is a map of action name to RenderedAction.
type RenderedActions map[string]ActionStatus

// ActionStatus describes status information about an action.
type ActionStatus struct {
	// Rendered is the rendered action.
	Rendered Action

	// StartedAt is the time the action was started.
	StartedAt *metav1.Time

	// State describes the current state of the action.
	State State

	// Result describes the result of the action.
	Result Result

	// Reason is a human readable string describing the result of the action.
	Reason string
}

// State describes the point in time state of a workflow or action.
type State string

const (
	StatePending  State = "Pending"
	StateRunning  State = "Running"
	StateComplete State = "Complete"
)

// Result describes the result of a workflow or action.
type Result string

const (
	ResultSuccess Result = "Success"
	ResultFailure Result = "Failure"
	ResultTimeout Result = "Timeout"
)